OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

Remove many old deprecated features 

The following features have been deprecated for well over the 2
 release cycle we promise
 
   ``-drive file=json:{...{'driver':'file'}}`` (since 3.0)
   ``-vnc acl`` (since 4.0.0)
   ``-mon ...,control=readline,pretty=on|off`` (since 4.1)
   ``migrate_set_downtime`` and ``migrate_set_speed`` (since 2.8.0)
   ``query-named-block-nodes`` result ``encryption_key_missing`` (since 2.10.0)
   ``query-block`` result ``inserted.encryption_key_missing`` (since 2.10.0)
   ``migrate-set-cache-size`` and ``query-migrate-cache-size`` (since 2.11.0)
   ``query-named-block-nodes`` and ``query-block`` result dirty-bitmaps[i].status (since 4.0)
   ``query-cpus`` (since 2.12.0)
   ``query-cpus-fast`` ``arch`` output member (since 3.0.0)
   ``query-events`` (since 4.0)
   chardev client socket with ``wait`` option (since 4.0)
   ``acl_show``, ``acl_reset``, ``acl_policy``, ``acl_add``, ``acl_remove`` (since 4.0.0)
   ``ide-drive`` (since 4.2)
   ``scsi-disk`` (since 4.2)
 -----BEGIN PGP SIGNATURE-----
 
 iQIzBAABCAAdFiEE2vOm/bJrYpEtDo4/vobrtBUQT98FAmBTHBsACgkQvobrtBUQ
 T9/6cA//QVlWFvNJjmYuXMFOkYdokqde9W66iMO2vt+p3LSqlcxVa59+ZOcb5XWc
 7xYcZlDHEHRMe8DWrTwUyjftJ7Ild+/HY5Nz8NqDFvX08umIhC6qmzBSG64O3fU5
 KtSLWe+KfbUH2usmczQO1zGG8mSIAMnOdugpLln9W13v7X9NO4yC+/O36Mm8l4VK
 VEF+o9w7+s2l7QloLdhVe7RVOrqz6+9TFHx1+q1pPhMbzlv5vbfp9vIreiCgmqiO
 rPLXB4bjklktWSkJBe/2Jt7ixNQZrT0DfnCmshHJmmBxTCI1+b798Xy+7j9Dz8ER
 LzKHhlsilCv/jb8QKlIZSxvoDE02vAgwyVXlqxc7FdyaLmg/Emwr5LGUFHKCyhDR
 3hmJafNokdWPcHwBYwRTdbG1OlgKA+yHSBzQ4OnjsTsKrrzlBrm9B9DiDVABXadS
 5NnhvjZfaRmzjXZinf1th7fdMtLs4k+9XKn6szkrp2QhtlX9gyhkXuOhdwRVcyJB
 V/8dLZDdOB3Kpbu5DGlmmIzdHQx5bo/tQqZlvJJNmcOWe+TKwHg56WRUYQ3PFQZK
 M2A4XTd5kil6+PT7AnDHLoYAFdfScq6R32V38AI7S34kPrejftbSbDz8EVRXnrzj
 zzXGNWtSQpIDZGgNEg3Ta6aIf28TxLCA7nRhuPYIDcswlUsHn4c=
 =cFRH
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/berrange-gitlab/tags/dep-many-pull-request' into staging

Remove many old deprecated features

The following features have been deprecated for well over the 2
release cycle we promise

  ``-drive file=json:{...{'driver':'file'}}`` (since 3.0)
  ``-vnc acl`` (since 4.0.0)
  ``-mon ...,control=readline,pretty=on|off`` (since 4.1)
  ``migrate_set_downtime`` and ``migrate_set_speed`` (since 2.8.0)
  ``query-named-block-nodes`` result ``encryption_key_missing`` (since 2.10.0)
  ``query-block`` result ``inserted.encryption_key_missing`` (since 2.10.0)
  ``migrate-set-cache-size`` and ``query-migrate-cache-size`` (since 2.11.0)
  ``query-named-block-nodes`` and ``query-block`` result dirty-bitmaps[i].status (since 4.0)
  ``query-cpus`` (since 2.12.0)
  ``query-cpus-fast`` ``arch`` output member (since 3.0.0)
  ``query-events`` (since 4.0)
  chardev client socket with ``wait`` option (since 4.0)
  ``acl_show``, ``acl_reset``, ``acl_policy``, ``acl_add``, ``acl_remove`` (since 4.0.0)
  ``ide-drive`` (since 4.2)
  ``scsi-disk`` (since 4.2)

# gpg: Signature made Thu 18 Mar 2021 09:23:39 GMT
# gpg:                using RSA key DAF3A6FDB26B62912D0E8E3FBE86EBB415104FDF
# gpg: Good signature from "Daniel P. Berrange <dan@berrange.com>" [full]
# gpg:                 aka "Daniel P. Berrange <berrange@redhat.com>" [full]
# Primary key fingerprint: DAF3 A6FD B26B 6291 2D0E  8E3F BE86 EBB4 1510 4FDF

* remotes/berrange-gitlab/tags/dep-many-pull-request:
  block: remove support for using "file" driver with block/char devices
  block: remove 'dirty-bitmaps' field from 'BlockInfo' struct
  block: remove dirty bitmaps 'status' field
  block: remove 'encryption_key_missing' flag from QAPI
  hw/scsi: remove 'scsi-disk' device
  hw/ide: remove 'ide-drive' device
  chardev: reject use of 'wait' flag for socket client chardevs
  machine: remove 'arch' field from 'query-cpus-fast' QMP command
  machine: remove 'query-cpus' QMP command
  migrate: remove QMP/HMP commands for speed, downtime and cache size
  monitor: remove 'query-events' QMP command
  monitor: raise error when 'pretty' option is used with HMP
  ui, monitor: remove deprecated VNC ACL option and HMP commands

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2021-03-18 19:00:49 +00:00
parent 4083904bc9 8d17adf34f
commit 1b507e55f8
64 changed files with 369 additions and 1801 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
block/dirty-bitmap.c
View File

@ -166,43 +166,6 @@ bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap)
return !bitmap->disabled;
}
/**
* bdrv_dirty_bitmap_status: This API is now deprecated.
* Called with BQL taken.
*
* A BdrvDirtyBitmap can be in four possible user-visible states:
* (1) Active: successor is NULL, and disabled is false: full r/w mode
* (2) Disabled: successor is NULL, and disabled is true: qualified r/w mode,
* guest writes are dropped, but monitor writes are possible,
* through commands like merge and clear.
* (3) Frozen: successor is not NULL.
* A frozen bitmap cannot be renamed, deleted, cleared, set,
* enabled, merged to, etc. A frozen bitmap can only abdicate()
* or reclaim().
* In this state, the anonymous successor bitmap may be either
* Active and recording writes from the guest (e.g. backup jobs),
* or it can be Disabled and not recording writes.
* (4) Locked: Whether Active or Disabled, the user cannot modify this bitmap
* in any way from the monitor.
* (5) Inconsistent: This is a persistent bitmap whose "in use" bit is set, and
* is unusable by QEMU. It can be deleted to remove it from
* the qcow2.
*/
DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap)
{
if (bdrv_dirty_bitmap_inconsistent(bitmap)) {
return DIRTY_BITMAP_STATUS_INCONSISTENT;
} else if (bdrv_dirty_bitmap_has_successor(bitmap)) {
return DIRTY_BITMAP_STATUS_FROZEN;
} else if (bdrv_dirty_bitmap_busy(bitmap)) {
return DIRTY_BITMAP_STATUS_LOCKED;
} else if (!bdrv_dirty_bitmap_enabled(bitmap)) {
return DIRTY_BITMAP_STATUS_DISABLED;
} else {
return DIRTY_BITMAP_STATUS_ACTIVE;
}
}
/* Called with BQL taken. */
static bool bdrv_dirty_bitmap_recording(BdrvDirtyBitmap *bitmap)
{
@ -582,7 +545,6 @@ BlockDirtyInfoList *bdrv_query_dirty_bitmaps(BlockDriverState *bs)
info->granularity = bdrv_dirty_bitmap_granularity(bm);
info->has_name = !!bm->name;
info->name = g_strdup(bm->name);
info->status = bdrv_dirty_bitmap_status(bm);
info->recording = bdrv_dirty_bitmap_recording(bm);
info->busy = bdrv_dirty_bitmap_busy(bm);
info->persistent = bm->persistent;

17
block/file-posix.c
View File

@ -719,15 +719,9 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
}
if (!device) {
if (S_ISBLK(st.st_mode)) {
warn_report("Opening a block device as a file using the '%s' "
"driver is deprecated", bs->drv->format_name);
} else if (S_ISCHR(st.st_mode)) {
warn_report("Opening a character device as a file using the '%s' "
"driver is deprecated", bs->drv->format_name);
} else if (!S_ISREG(st.st_mode)) {
error_setg(errp, "A regular file was expected by the '%s' driver, "
"but something else was given", bs->drv->format_name);
if (!S_ISREG(st.st_mode)) {
error_setg(errp, "'%s' driver requires '%s' to be a regular file",
bs->drv->format_name, bs->filename);
ret = -EINVAL;
goto fail;
} else {
@ -736,8 +730,9 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
}
} else {
if (!(S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode))) {
error_setg(errp, "'%s' driver expects either "
"a character or block device", bs->drv->format_name);
error_setg(errp, "'%s' driver requires '%s' to be either "
"a character or block device",
bs->drv->format_name, bs->filename);
ret = -EINVAL;
goto fail;
}

6
block/qapi.c
View File

@ -62,7 +62,6 @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
info->ro = bs->read_only;
info->drv = g_strdup(bs->drv->format_name);
info->encrypted = bs->encrypted;
info->encryption_key_missing = false;
info->cache = g_new(BlockdevCacheInfo, 1);
*info->cache = (BlockdevCacheInfo) {
@ -384,11 +383,6 @@ static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info,
info->io_status = blk_iostatus(blk);
}
if (bs && !QLIST_EMPTY(&bs->dirty_bitmaps)) {
info->has_dirty_bitmaps = true;
info->dirty_bitmaps = bdrv_query_dirty_bitmaps(bs);
}
if (bs && bs->drv) {
info->has_inserted = true;
info->inserted = bdrv_block_device_info(blk, bs, false, errp);

12
chardev/char-socket.c
View File

@ -1339,14 +1339,10 @@ static bool qmp_chardev_validate_socket(ChardevSocket *sock,
return false;
}
if (sock->has_wait) {
warn_report("'wait' option is deprecated with "
"socket in client connect mode");
if (sock->wait) {
error_setg(errp, "%s",
"'wait' option is incompatible with "
"socket in client connect mode");
return false;
}
error_setg(errp, "%s",
"'wait' option is incompatible with "
"socket in client connect mode");
return false;
}
}

2
docs/devel/migration.rst
View File

@ -641,7 +641,7 @@ time per vCPU.
.. note::
During the postcopy phase, the bandwidth limits set using
``migrate_set_speed`` is ignored (to avoid delaying requested pages that
``migrate_set_parameter`` is ignored (to avoid delaying requested pages that
the destination is waiting for).
Postcopy device transfer

2
docs/qdev-device-use.txt
View File

@ -388,7 +388,7 @@ type.
some DEVNAMEs:
default device suppressing DEVNAMEs
CD-ROM ide-cd, ide-drive, ide-hd, scsi-cd, scsi-hd
CD-ROM ide-cd, ide-hd, scsi-cd, scsi-hd
floppy floppy, isa-fdc
parallel isa-parallel
serial isa-serial

2
docs/rdma.txt
View File

@ -89,7 +89,7 @@ RUNNING:
First, set the migration speed to match your hardware's capabilities:
QEMU Monitor Command:
$ migrate_set_speed 40g # or whatever is the MAX of your RDMA device
$ migrate_set_parameter max_bandwidth 40g # or whatever is the MAX of your RDMA device
Next, on the destination machine, add the following to the QEMU command line:

108
docs/system/deprecated.rst
View File

@ -21,19 +21,6 @@ deprecated.
System emulator command line arguments
--------------------------------------
``-drive file=json:{...{'driver':'file'}}`` (since 3.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''
The 'file' driver for drives is no longer appropriate for character or host
devices and will only accept regular files (S_IFREG). The correct driver
for these file types is 'host_cdrom' or 'host_device' as appropriate.
``-vnc acl`` (since 4.0.0)
''''''''''''''''''''''''''
The ``acl`` option to the ``-vnc`` argument has been replaced
by the ``tls-authz`` and ``sasl-authz`` options.
``QEMU_AUDIO_`` environment variables and ``-audio-help`` (since 4.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
@ -59,13 +46,6 @@ needs two devices (``-device intel-hda -device hda-duplex``) and
``pcspk`` which can be activated using ``-machine
pcspk-audiodev=<name>``.
``-mon ...,control=readline,pretty=on|off`` (since 4.1)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''
The ``pretty=on|off`` switch has no effect for HMP monitors, but is
silently ignored. Using the switch with HMP monitors will become an
error in the future.
RISC-V ``-bios`` (since 5.1)
''''''''''''''''''''''''''''
@ -196,31 +176,11 @@ Use argument ``id`` instead.
Use argument ``id`` instead.
``migrate_set_downtime`` and ``migrate_set_speed`` (since 2.8.0)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Use ``migrate-set-parameters`` instead.
``query-named-block-nodes`` result ``encryption_key_missing`` (since 2.10.0)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Always false.
``query-block`` result ``inserted.encryption_key_missing`` (since 2.10.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Always false.
``blockdev-add`` empty string argument ``backing`` (since 2.10.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Use argument value ``null`` instead.
``migrate-set-cache-size`` and ``query-migrate-cache-size`` (since 2.11.0)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Use ``migrate-set-parameters`` and ``query-migrate-parameters`` instead.
``block-commit`` arguments ``base`` and ``top`` (since 3.1.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
@ -231,49 +191,6 @@ Use arguments ``base-node`` and ``top-node`` instead.
Specify the properties for the object as top-level arguments instead.
``query-named-block-nodes`` and ``query-block`` result dirty-bitmaps[i].status (since 4.0)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
The ``status`` field of the ``BlockDirtyInfo`` structure, returned by
these commands is deprecated. Two new boolean fields, ``recording`` and
``busy`` effectively replace it.
``query-block`` result field ``dirty-bitmaps`` (Since 4.2)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
The ``dirty-bitmaps`` field of the ``BlockInfo`` structure, returned by
the query-block command is itself now deprecated. The ``dirty-bitmaps``
field of the ``BlockDeviceInfo`` struct should be used instead, which is the
type of the ``inserted`` field in query-block replies, as well as the
type of array items in query-named-block-nodes.
Since the ``dirty-bitmaps`` field is optionally present in both the old and
new locations, clients must use introspection to learn where to anticipate
the field if/when it does appear in command output.
``query-cpus`` (since 2.12.0)
'''''''''''''''''''''''''''''
The ``query-cpus`` command is replaced by the ``query-cpus-fast`` command.
``query-cpus-fast`` ``arch`` output member (since 3.0.0)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''
The ``arch`` output member of the ``query-cpus-fast`` command is
replaced by the ``target`` output member.
``query-events`` (since 4.0)
''''''''''''''''''''''''''''
The ``query-events`` command has been superseded by the more powerful
and accurate ``query-qmp-schema`` command.
chardev client socket with ``wait`` option (since 4.0)
''''''''''''''''''''''''''''''''''''''''''''''''''''''
Character devices creating sockets in client mode should not specify
the 'wait' field, which is only applicable to sockets in server mode
``nbd-server-add`` and ``nbd-server-remove`` (since 5.2)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''
@ -281,16 +198,6 @@ Use the more generic commands ``block-export-add`` and ``block-export-del``
instead. As part of this deprecation, where ``nbd-server-add`` used a
single ``bitmap``, the new ``block-export-add`` uses a list of ``bitmaps``.
Human Monitor Protocol (HMP) commands
-------------------------------------
``acl_show``, ``acl_reset``, ``acl_policy``, ``acl_add``, ``acl_remove`` (since 4.0.0)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
The ``acl_show``, ``acl_reset``, ``acl_policy``, ``acl_add``, and
``acl_remove`` commands are deprecated with no replacement. Authorization
for VNC should be performed using the pluggable QAuthZ objects.
System emulator CPUS
--------------------
@ -331,21 +238,6 @@ The ``I7200`` guest CPU relies on the nanoMIPS ISA, which is deprecated
(the ISA has never been upstreamed to a compiler toolchain). Therefore
this CPU is also deprecated.
System emulator devices
-----------------------
``ide-drive`` (since 4.2)
'''''''''''''''''''''''''
The 'ide-drive' device is deprecated. Users should use 'ide-hd' or
'ide-cd' as appropriate to get an IDE hard disk or CD-ROM as needed.
``scsi-disk`` (since 4.2)
'''''''''''''''''''''''''
The 'scsi-disk' device is deprecated. Users should use 'scsi-hd' or
'scsi-cd' as appropriate to get a SCSI hard disk or CD-ROM as needed.
System emulator machines
------------------------

108
docs/system/removed-features.rst
View File

@ -45,6 +45,24 @@ This option lacked the possibility to specify an audio backend device.
Use ``-device usb-audio`` now instead (and specify a corresponding USB
host controller or ``-usb`` if necessary).
``-vnc acl`` (removed in 6.0)
'''''''''''''''''''''''''''''
The ``acl`` option to the ``-vnc`` argument has been replaced
by the ``tls-authz`` and ``sasl-authz`` options.
``-mon ...,control=readline,pretty=on|off`` (removed in 6.0)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
The ``pretty=on|off`` switch has no effect for HMP monitors and
its use is rejected.
``-drive file=json:{...{'driver':'file'}}`` (removed 6.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''
The 'file' driver for drives is no longer appropriate for character or host
devices and will only accept regular files (S_IFREG). The correct driver
for these file types is 'host_cdrom' or 'host_device' as appropriate.
QEMU Machine Protocol (QMP) commands
------------------------------------
@ -66,6 +84,65 @@ documentation of ``query-hotpluggable-cpus`` for additional details.
Use ``blockdev-change-medium`` or ``change-vnc-password`` instead.
``query-events`` (removed in 6.0)
'''''''''''''''''''''''''''''''''
The ``query-events`` command has been superseded by the more powerful
and accurate ``query-qmp-schema`` command.
``migrate_set_cache_size`` and ``query-migrate-cache-size`` (removed in 6.0)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Use ``migrate_set_parameter`` and ``info migrate_parameters`` instead.
``migrate_set_downtime`` and ``migrate_set_speed`` (removed in 6.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Use ``migrate_set_parameter`` instead.
``query-cpus`` (removed in 6.0)
'''''''''''''''''''''''''''''''
The ``query-cpus`` command is replaced by the ``query-cpus-fast`` command.
``query-cpus-fast`` ``arch`` output member (removed in 6.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
The ``arch`` output member of the ``query-cpus-fast`` command is
replaced by the ``target`` output member.
chardev client socket with ``wait`` option (removed in 6.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Character devices creating sockets in client mode should not specify
the 'wait' field, which is only applicable to sockets in server mode
``query-named-block-nodes`` result ``encryption_key_missing`` (removed in 6.0)
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Removed with no replacement.
``query-block`` result ``inserted.encryption_key_missing`` (removed in 6.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Removed with no replacement.
``query-named-block-nodes`` and ``query-block`` result dirty-bitmaps[i].status (removed in 6.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
The ``status`` field of the ``BlockDirtyInfo`` structure, returned by
these commands is removed. Two new boolean fields, ``recording`` and
``busy`` effectively replace it.
``query-block`` result field ``dirty-bitmaps`` (removed in 6.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
The ``dirty-bitmaps`` field of the ``BlockInfo`` structure, returned by
the query-block command is itself now removed. The ``dirty-bitmaps``
field of the ``BlockDeviceInfo`` struct should be used instead, which is the
type of the ``inserted`` field in query-block replies, as well as the
type of array items in query-named-block-nodes.
Human Monitor Protocol (HMP) commands
-------------------------------------
@ -87,6 +164,23 @@ documentation of ``query-hotpluggable-cpus`` for additional details.
No replacement. The ``change vnc password`` and ``change DEVICE MEDIUM``
commands are not affected.
``acl_show``, ``acl_reset``, ``acl_policy``, ``acl_add``, ``acl_remove`` (removed in 6.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
The ``acl_show``, ``acl_reset``, ``acl_policy``, ``acl_add``, and
``acl_remove`` commands were removed with no replacement. Authorization
for VNC should be performed using the pluggable QAuthZ objects.
``migrate-set-cache-size`` and ``info migrate-cache-size`` (removed in 6.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Use ``migrate-set-parameters`` and ``info migrate-parameters`` instead.
``migrate_set_downtime`` and ``migrate_set_speed`` (removed in 6.0)
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Use ``migrate-set-parameters`` instead.
Guest Emulator ISAs
-------------------
@ -163,6 +257,20 @@ the upstream Linux kernel in 2018, and it has also been dropped from glibc, so
there is no new Linux development taking place with this architecture. For
running the old binaries, you can use older versions of QEMU.
System emulator devices
-----------------------
``ide-drive`` (removed in 6.0)
''''''''''''''''''''''''''''''
The 'ide-drive' device has been removed. Users should use 'ide-hd' or
'ide-cd' as appropriate to get an IDE hard disk or CD-ROM as needed.
``scsi-disk`` (removed in 6.0)
''''''''''''''''''''''''''''''
The 'scsi-disk' device has been removed. Users should use 'scsi-hd' or
'scsi-cd' as appropriate to get a SCSI hard disk or CD-ROM as needed.
Related binaries
----------------

5
docs/xbzrle.txt
View File

@ -90,11 +90,6 @@ Usage
3. Set the XBZRLE cache size - the cache size is in MBytes and should be a
power of 2. The cache default value is 64MBytes. (on source only)
{qemu} migrate_set_cache_size 256m
Commit 73af8dd8d7 "migration: Make xbzrle_cache_size a migration parameter"
(v2.11.0) deprecated migrate-set-cache-size, therefore, the new parameter
is recommended.
{qemu} migrate_set_parameter xbzrle-cache-size 256m
4. Start outgoing migration

13
hmp-commands-info.hx
View File

@ -567,19 +567,6 @@ SRST
Show current migration parameters.
ERST
{
.name = "migrate_cache_size",
.args_type = "",
.params = "",
.help = "show current migration xbzrle cache size",
.cmd = hmp_info_migrate_cache_size,
},
SRST
``info migrate_cache_size``
Show current migration xbzrle cache size.
ERST
{
.name = "balloon",
.args_type = "",

121
hmp-commands.hx
View File

@ -979,51 +979,6 @@ SRST
Pause an ongoing migration. Currently it only supports postcopy.
ERST
{
.name = "migrate_set_cache_size",
.args_type = "value:o",
.params = "value",
.help = "set cache size (in bytes) for XBZRLE migrations,"
"the cache size will be rounded down to the nearest "
"power of 2.\n"
"The cache size affects the number of cache misses."
"In case of a high cache miss ratio you need to increase"
" the cache size",
.cmd = hmp_migrate_set_cache_size,
},
SRST
``migrate_set_cache_size`` *value*
Set cache size to *value* (in bytes) for xbzrle migrations.
ERST
{
.name = "migrate_set_speed",
.args_type = "value:o",
.params = "value",
.help = "set maximum speed (in bytes) for migrations. "
"Defaults to MB if no size suffix is specified, ie. B/K/M/G/T",
.cmd = hmp_migrate_set_speed,
},
SRST
``migrate_set_speed`` *value*
Set maximum speed to *value* (in bytes) for migrations.
ERST
{
.name = "migrate_set_downtime",
.args_type = "value:T",
.params = "value",
.help = "set maximum tolerated downtime (in seconds) for migrations",
.cmd = hmp_migrate_set_downtime,
},
SRST
``migrate_set_downtime`` *second*
Set maximum tolerated downtime (in seconds) for migration.
ERST
{
.name = "migrate_set_capability",
.args_type = "capability:s,state:b",
@ -1433,82 +1388,6 @@ SRST
Change watchdog action.
ERST
{
.name = "acl_show",
.args_type = "aclname:s",
.params = "aclname",
.help = "list rules in the access control list",
.cmd = hmp_acl_show,
},
SRST
``acl_show`` *aclname*
List all the matching rules in the access control list, and the default
policy. There are currently two named access control lists,
*vnc.x509dname* and *vnc.username* matching on the x509 client
certificate distinguished name, and SASL username respectively.
ERST
{
.name = "acl_policy",
.args_type = "aclname:s,policy:s",
.params = "aclname allow|deny",
.help = "set default access control list policy",
.cmd = hmp_acl_policy,
},
SRST
``acl_policy`` *aclname* ``allow|deny``
Set the default access control list policy, used in the event that
none of the explicit rules match. The default policy at startup is
always ``deny``.
ERST
{
.name = "acl_add",
.args_type = "aclname:s,match:s,policy:s,index:i?",
.params = "aclname match allow|deny [index]",
.help = "add a match rule to the access control list",
.cmd = hmp_acl_add,
},
SRST
``acl_add`` *aclname* *match* ``allow|deny`` [*index*]
Add a match rule to the access control list, allowing or denying access.
The match will normally be an exact username or x509 distinguished name,
but can optionally include wildcard globs. eg ``*@EXAMPLE.COM`` to
allow all users in the ``EXAMPLE.COM`` kerberos realm. The match will
normally be appended to the end of the ACL, but can be inserted
earlier in the list if the optional *index* parameter is supplied.
ERST
{
.name = "acl_remove",
.args_type = "aclname:s,match:s",
.params = "aclname match",
.help = "remove a match rule from the access control list",
.cmd = hmp_acl_remove,
},
SRST
``acl_remove`` *aclname* *match*
Remove the specified match rule from the access control list.
ERST
{
.name = "acl_reset",
.args_type = "aclname:s",
.params = "aclname",
.help = "reset the access control list",
.cmd = hmp_acl_reset,
},
SRST
``acl_reset`` *aclname*
Remove all matches from the access control list, and set the default
policy back to ``deny``.
ERST
{
.name = "nbd_server_start",
.args_type = "all:-a,writable:-w,uri:s",

8
hw/core/machine-hmp-cmds.c
View File

@ -130,7 +130,7 @@ void hmp_info_numa(Monitor *mon, const QDict *qdict)
{
int i, nb_numa_nodes;
NumaNodeMem *node_mem;
CpuInfoList *cpu_list, *cpu;
CpuInfoFastList *cpu_list, *cpu;
MachineState *ms = MACHINE(qdev_get_machine());
nb_numa_nodes = ms->numa_state ? ms->numa_state->num_nodes : 0;
@ -139,7 +139,7 @@ void hmp_info_numa(Monitor *mon, const QDict *qdict)
return;
}
cpu_list = qmp_query_cpus(&error_abort);
cpu_list = qmp_query_cpus_fast(&error_abort);
node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
query_numa_node_mem(node_mem, ms);
@ -148,7 +148,7 @@ void hmp_info_numa(Monitor *mon, const QDict *qdict)
for (cpu = cpu_list; cpu; cpu = cpu->next) {
if (cpu->value->has_props && cpu->value->props->has_node_id &&
cpu->value->props->node_id == i) {
monitor_printf(mon, " %" PRIi64, cpu->value->CPU);
monitor_printf(mon, " %" PRIi64, cpu->value->cpu_index);
}
}
monitor_printf(mon, "\n");
@ -157,6 +157,6 @@ void hmp_info_numa(Monitor *mon, const QDict *qdict)
monitor_printf(mon, "node %d plugged: %" PRId64 " MB\n", i,
node_mem[i].node_plugged_mem >> 20);
}
qapi_free_CpuInfoList(cpu_list);
qapi_free_CpuInfoFastList(cpu_list);
g_free(node_mem);
}

120
hw/core/machine-qmp-cmds.c
View File

@ -24,125 +24,6 @@
#include "sysemu/runstate.h"
#include "sysemu/sysemu.h"
CpuInfoList *qmp_query_cpus(Error **errp)
{
MachineState *ms = MACHINE(qdev_get_machine());
MachineClass *mc = MACHINE_GET_CLASS(ms);
CpuInfoList *head = NULL, **tail = &head;
CPUState *cpu;
CPU_FOREACH(cpu) {
CpuInfo *value;
#if defined(TARGET_I386)
X86CPU *x86_cpu = X86_CPU(cpu);
CPUX86State *env = &x86_cpu->env;
#elif defined(TARGET_PPC)
PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
CPUPPCState *env = &ppc_cpu->env;
#elif defined(TARGET_SPARC)
SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
CPUSPARCState *env = &sparc_cpu->env;
#elif defined(TARGET_RISCV)
RISCVCPU *riscv_cpu = RISCV_CPU(cpu);
CPURISCVState *env = &riscv_cpu->env;
#elif defined(TARGET_MIPS)
MIPSCPU *mips_cpu = MIPS_CPU(cpu);
CPUMIPSState *env = &mips_cpu->env;
#elif defined(TARGET_TRICORE)
TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
CPUTriCoreState *env = &tricore_cpu->env;
#elif defined(TARGET_S390X)
S390CPU *s390_cpu = S390_CPU(cpu);
CPUS390XState *env = &s390_cpu->env;
#endif
cpu_synchronize_state(cpu);
value = g_malloc0(sizeof(*value));
value->CPU = cpu->cpu_index;
value->current = (cpu == first_cpu);
value->halted = cpu->halted;
value->qom_path = object_get_canonical_path(OBJECT(cpu));
value->thread_id = cpu->thread_id;
#if defined(TARGET_I386)
value->arch = CPU_INFO_ARCH_X86;
value->u.x86.pc = env->eip + env->segs[R_CS].base;
#elif defined(TARGET_PPC)
value->arch = CPU_INFO_ARCH_PPC;
value->u.ppc.nip = env->nip;
#elif defined(TARGET_SPARC)
value->arch = CPU_INFO_ARCH_SPARC;
value->u.q_sparc.pc = env->pc;
value->u.q_sparc.npc = env->npc;
#elif defined(TARGET_MIPS)
value->arch = CPU_INFO_ARCH_MIPS;
value->u.q_mips.PC = env->active_tc.PC;
#elif defined(TARGET_TRICORE)
value->arch = CPU_INFO_ARCH_TRICORE;
value->u.tricore.PC = env->PC;
#elif defined(TARGET_S390X)
value->arch = CPU_INFO_ARCH_S390;
value->u.s390.cpu_state = env->cpu_state;
#elif defined(TARGET_RISCV)
value->arch = CPU_INFO_ARCH_RISCV;
value->u.riscv.pc = env->pc;
#else
value->arch = CPU_INFO_ARCH_OTHER;
#endif
value->has_props = !!mc->cpu_index_to_instance_props;
if (value->has_props) {
CpuInstanceProperties *props;
props = g_malloc0(sizeof(*props));
*props = mc->cpu_index_to_instance_props(ms, cpu->cpu_index);
value->props = props;
}
QAPI_LIST_APPEND(tail, value);
}
return head;
}
static CpuInfoArch sysemu_target_to_cpuinfo_arch(SysEmuTarget target)
{
/*
* The @SysEmuTarget -> @CpuInfoArch mapping below is based on the
* TARGET_ARCH -> TARGET_BASE_ARCH mapping in the "configure" script.
*/
switch (target) {
case SYS_EMU_TARGET_I386:
case SYS_EMU_TARGET_X86_64:
return CPU_INFO_ARCH_X86;
case SYS_EMU_TARGET_PPC:
case SYS_EMU_TARGET_PPC64:
return CPU_INFO_ARCH_PPC;
case SYS_EMU_TARGET_SPARC:
case SYS_EMU_TARGET_SPARC64:
return CPU_INFO_ARCH_SPARC;
case SYS_EMU_TARGET_MIPS:
case SYS_EMU_TARGET_MIPSEL:
case SYS_EMU_TARGET_MIPS64:
case SYS_EMU_TARGET_MIPS64EL:
return CPU_INFO_ARCH_MIPS;
case SYS_EMU_TARGET_TRICORE:
return CPU_INFO_ARCH_TRICORE;
case SYS_EMU_TARGET_S390X:
return CPU_INFO_ARCH_S390;
case SYS_EMU_TARGET_RISCV32:
case SYS_EMU_TARGET_RISCV64:
return CPU_INFO_ARCH_RISCV;
default:
return CPU_INFO_ARCH_OTHER;
}
}
static void cpustate_to_cpuinfo_s390(CpuInfoS390 *info, const CPUState *cpu)
{
#ifdef TARGET_S390X
@ -183,7 +64,6 @@ CpuInfoFastList *qmp_query_cpus_fast(Error **errp)
value->props = props;
}
value->arch = sysemu_target_to_cpuinfo_arch(target);
value->target = target;
if (target == SYS_EMU_TARGET_S390X) {
cpustate_to_cpuinfo_s390(&value->u.s390x, cpu);

2
hw/i386/pc.c
View File

@ -338,10 +338,8 @@ GlobalProperty pc_compat_1_4[] = {
PC_CPU_MODEL_IDS("1.4.0")
{ "scsi-hd", "discard_granularity", "0" },
{ "scsi-cd", "discard_granularity", "0" },
{ "scsi-disk", "discard_granularity", "0" },
{ "ide-hd", "discard_granularity", "0" },
{ "ide-cd", "discard_granularity", "0" },
{ "ide-drive", "discard_granularity", "0" },
{ "virtio-blk-pci", "discard_granularity", "0" },
/* DEV_NVECTORS_UNSPECIFIED as a uint32_t string: */
{ "virtio-serial-pci", "vectors", "0xFFFFFFFF" },

38
hw/ide/qdev.c
View File

@ -283,20 +283,6 @@ static void ide_cd_realize(IDEDevice *dev, Error **errp)
ide_dev_initfn(dev, IDE_CD, errp);
}
static void ide_drive_realize(IDEDevice *dev, Error **errp)
{
DriveInfo *dinfo = NULL;
warn_report("'ide-drive' is deprecated, "
"please use 'ide-hd' or 'ide-cd' instead");
if (dev->conf.blk) {
dinfo = blk_legacy_dinfo(dev->conf.blk);
}
ide_dev_initfn(dev, dinfo && dinfo->media_cd ? IDE_CD : IDE_HD, errp);
}
#define DEFINE_IDE_DEV_PROPERTIES() \
DEFINE_BLOCK_PROPERTIES(IDEDrive, dev.conf), \
DEFINE_BLOCK_ERROR_PROPERTIES(IDEDrive, dev.conf), \
@ -355,29 +341,6 @@ static const TypeInfo ide_cd_info = {
.class_init = ide_cd_class_init,
};
static Property ide_drive_properties[] = {
DEFINE_IDE_DEV_PROPERTIES(),
DEFINE_PROP_END_OF_LIST(),
};
static void ide_drive_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
IDEDeviceClass *k = IDE_DEVICE_CLASS(klass);
k->realize = ide_drive_realize;
dc->fw_name = "drive";
dc->desc = "virtual IDE disk or CD-ROM (legacy)";
device_class_set_props(dc, ide_drive_properties);
}
static const TypeInfo ide_drive_info = {
.name = "ide-drive",
.parent = TYPE_IDE_DEVICE,
.instance_size = sizeof(IDEDrive),
.class_init = ide_drive_class_init,
};
static void ide_device_class_init(ObjectClass *klass, void *data)
{
DeviceClass *k = DEVICE_CLASS(klass);
@ -402,7 +365,6 @@ static void ide_register_types(void)
type_register_static(&ide_bus_info);
type_register_static(&ide_hd_info);
type_register_static(&ide_cd_info);
type_register_static(&ide_drive_info);
type_register_static(&ide_device_type_info);
}

13
hw/ppc/mac_newworld.c
View File

@ -539,8 +539,6 @@ static char *core99_fw_dev_path(FWPathProvider *p, BusState *bus,
DeviceState *dev)
{
PCIDevice *pci;
IDEBus *ide_bus;
IDEState *ide_s;
MACIOIDEState *macio_ide;
if (!strcmp(object_get_typename(OBJECT(dev)), "macio-newworld")) {
@ -553,17 +551,6 @@ static char *core99_fw_dev_path(FWPathProvider *p, BusState *bus,
return g_strdup_printf("ata-3@%x", macio_ide->addr);
}
if (!strcmp(object_get_typename(OBJECT(dev)), "ide-drive")) {
ide_bus = IDE_BUS(qdev_get_parent_bus(dev));
ide_s = idebus_active_if(ide_bus);
if (ide_s->drive_kind == IDE_CD) {
return g_strdup("cdrom");
}
return g_strdup("disk");
}
if (!strcmp(object_get_typename(OBJECT(dev)), "ide-hd")) {
return g_strdup("disk");
}

13
hw/ppc/mac_oldworld.c
View File

@ -384,8 +384,6 @@ static char *heathrow_fw_dev_path(FWPathProvider *p, BusState *bus,
DeviceState *dev)
{
PCIDevice *pci;
IDEBus *ide_bus;
IDEState *ide_s;
MACIOIDEState *macio_ide;
if (!strcmp(object_get_typename(OBJECT(dev)), "macio-oldworld")) {
@ -398,17 +396,6 @@ static char *heathrow_fw_dev_path(FWPathProvider *p, BusState *bus,
return g_strdup_printf("ata-3@%x", macio_ide->addr);
}
if (!strcmp(object_get_typename(OBJECT(dev)), "ide-drive")) {
ide_bus = IDE_BUS(qdev_get_parent_bus(dev));
ide_s = idebus_active_if(ide_bus);
if (ide_s->drive_kind == IDE_CD) {
return g_strdup("cdrom");
}
return g_strdup("disk");
}
if (!strcmp(object_get_typename(OBJECT(dev)), "ide-hd")) {
return g_strdup("disk");
}

62
hw/scsi/scsi-disk.c
View File

@ -2476,28 +2476,6 @@ static void scsi_cd_realize(SCSIDevice *dev, Error **errp)
aio_context_release(ctx);
}
static void scsi_disk_realize(SCSIDevice *dev, Error **errp)
{
DriveInfo *dinfo;
Error *local_err = NULL;
warn_report("'scsi-disk' is deprecated, "
"please use 'scsi-hd' or 'scsi-cd' instead");
if (!dev->conf.blk) {
scsi_realize(dev, &local_err);
assert(local_err);
error_propagate(errp, local_err);
return;
}
dinfo = blk_legacy_dinfo(dev->conf.blk);
if (dinfo && dinfo->media_cd) {
scsi_cd_realize(dev, errp);
} else {
scsi_hd_realize(dev, errp);
}
}
static const SCSIReqOps scsi_disk_emulate_reqops = {
.size = sizeof(SCSIDiskReq),
@ -3161,45 +3139,6 @@ static const TypeInfo scsi_block_info = {
};
#endif
static Property scsi_disk_properties[] = {
DEFINE_SCSI_DISK_PROPERTIES(),
DEFINE_PROP_BIT("removable", SCSIDiskState, features,
SCSI_DISK_F_REMOVABLE, false),
DEFINE_PROP_BIT("dpofua", SCSIDiskState, features,
SCSI_DISK_F_DPOFUA, false),
DEFINE_PROP_UINT64("wwn", SCSIDiskState, qdev.wwn, 0),
DEFINE_PROP_UINT64("port_wwn", SCSIDiskState, qdev.port_wwn, 0),
DEFINE_PROP_UINT16("port_index", SCSIDiskState, port_index, 0),
DEFINE_PROP_UINT64("max_unmap_size", SCSIDiskState, max_unmap_size,
DEFAULT_MAX_UNMAP_SIZE),
DEFINE_PROP_UINT64("max_io_size", SCSIDiskState, max_io_size,
DEFAULT_MAX_IO_SIZE),
DEFINE_PROP_INT32("scsi_version", SCSIDiskState, qdev.default_scsi_version,
5),
DEFINE_PROP_END_OF_LIST(),
};
static void scsi_disk_class_initfn(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
SCSIDeviceClass *sc = SCSI_DEVICE_CLASS(klass);
sc->realize = scsi_disk_realize;
sc->alloc_req = scsi_new_request;
sc->unit_attention_reported = scsi_disk_unit_attention_reported;
dc->fw_name = "disk";
dc->desc = "virtual SCSI disk or CD-ROM (legacy)";
dc->reset = scsi_disk_reset;
device_class_set_props(dc, scsi_disk_properties);
dc->vmsd = &vmstate_scsi_disk_state;
}
static const TypeInfo scsi_disk_info = {
.name = "scsi-disk",
.parent = TYPE_SCSI_DISK_BASE,
.class_init = scsi_disk_class_initfn,
};
static void scsi_disk_register_types(void)
{
type_register_static(&scsi_disk_base_info);
@ -3208,7 +3147,6 @@ static void scsi_disk_register_types(void)
#ifdef __linux__
type_register_static(&scsi_block_info);
#endif
type_register_static(&scsi_disk_info);
}
type_init(scsi_disk_register_types)

15
hw/sparc64/sun4u.c
View File

@ -749,9 +749,6 @@ static char *sun4u_fw_dev_path(FWPathProvider *p, BusState *bus,
DeviceState *dev)
{
PCIDevice *pci;
IDEBus *ide_bus;
IDEState *ide_s;
int bus_id;
if (!strcmp(object_get_typename(OBJECT(dev)), "pbm-bridge")) {
pci = PCI_DEVICE(dev);
@ -764,18 +761,6 @@ static char *sun4u_fw_dev_path(FWPathProvider *p, BusState *bus,
}
}
if (!strcmp(object_get_typename(OBJECT(dev)), "ide-drive")) {
ide_bus = IDE_BUS(qdev_get_parent_bus(dev));
ide_s = idebus_active_if(ide_bus);
bus_id = ide_bus->bus_id;
if (ide_s->drive_kind == IDE_CD) {
return g_strdup_printf("ide@%x/cdrom", bus_id);
}
return g_strdup_printf("ide@%x/disk", bus_id);
}
if (!strcmp(object_get_typename(OBJECT(dev)), "ide-hd")) {
return g_strdup("disk");
}

1
include/block/dirty-bitmap.h
View File

@ -46,7 +46,6 @@ bool bdrv_dirty_bitmap_enabled(BdrvDirtyBitmap *bitmap);
bool bdrv_dirty_bitmap_has_successor(BdrvDirtyBitmap *bitmap);
const char *bdrv_dirty_bitmap_name(const BdrvDirtyBitmap *bitmap);
int64_t bdrv_dirty_bitmap_size(const BdrvDirtyBitmap *bitmap);
DirtyBitmapStatus bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap);
void bdrv_set_dirty_bitmap(BdrvDirtyBitmap *bitmap,
int64_t offset, int64_t bytes);
void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,

4
include/monitor/hmp.h
View File

@ -28,7 +28,6 @@ void hmp_info_mice(Monitor *mon, const QDict *qdict);
void hmp_info_migrate(Monitor *mon, const QDict *qdict);
void hmp_info_migrate_capabilities(Monitor *mon, const QDict *qdict);
void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict);
void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict);
void hmp_info_cpus(Monitor *mon, const QDict *qdict);
void hmp_info_vnc(Monitor *mon, const QDict *qdict);
void hmp_info_spice(Monitor *mon, const QDict *qdict);
@ -64,11 +63,8 @@ void hmp_migrate_continue(Monitor *mon, const QDict *qdict);
void hmp_migrate_incoming(Monitor *mon, const QDict *qdict);
void hmp_migrate_recover(Monitor *mon, const QDict *qdict);
void hmp_migrate_pause(Monitor *mon, const QDict *qdict);
void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict);
void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict);
void hmp_migrate_set_capability(Monitor *mon, const QDict *qdict);
void hmp_migrate_set_parameter(Monitor *mon, const QDict *qdict);
void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict);
void hmp_client_migrate_info(Monitor *mon, const QDict *qdict);
void hmp_migrate_start_postcopy(Monitor *mon, const QDict *qdict);
void hmp_x_colo_lost_heartbeat(Monitor *mon, const QDict *qdict);

45
migration/migration.c
View File

@ -2316,51 +2316,6 @@ void qmp_migrate_continue(MigrationStatus state, Error **errp)
qemu_sem_post(&s->pause_sem);
}
void qmp_migrate_set_cache_size(int64_t value, Error **errp)
{
MigrateSetParameters p = {
.has_xbzrle_cache_size = true,
.xbzrle_cache_size = value,
};
qmp_migrate_set_parameters(&p, errp);
}
uint64_t qmp_query_migrate_cache_size(Error **errp)
{
return migrate_xbzrle_cache_size();
}
void qmp_migrate_set_speed(int64_t value, Error **errp)
{
MigrateSetParameters p = {
.has_max_bandwidth = true,
.max_bandwidth = value,
};
qmp_migrate_set_parameters(&p, errp);
}
void qmp_migrate_set_downtime(double value, Error **errp)
{
if (value < 0 || value > MAX_MIGRATE_DOWNTIME_SECONDS) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
"downtime_limit",
"an integer in the range of 0 to "
stringify(MAX_MIGRATE_DOWNTIME_SECONDS)" seconds");
return;
}
value *= 1000; /* Convert to milliseconds */
MigrateSetParameters p = {
.has_downtime_limit = true,
.downtime_limit = (int64_t)value,
};
qmp_migrate_set_parameters(&p, errp);
}
bool migrate_release_ram(void)
{
MigrationState *s;

2
migration/ram.c
View File

@ -121,7 +121,7 @@ static void XBZRLE_cache_unlock(void)
/**
* xbzrle_cache_resize: resize the xbzrle cache
*
* This function is called from qmp_migrate_set_cache_size in main
* This function is called from migrate_params_apply in main
* thread, possibly while a migration is in progress. A running
* migration may be using the cache and might finish during this call,
* hence changes to the cache are protected by XBZRLE.lock().

34
monitor/hmp-cmds.c
View File

@ -518,12 +518,6 @@ void hmp_info_migrate_parameters(Monitor *mon, const QDict *qdict)
qapi_free_MigrationParameters(params);
}
void hmp_info_migrate_cache_size(Monitor *mon, const QDict *qdict)
{
monitor_printf(mon, "xbzrel cache size: %" PRId64 " kbytes\n",
qmp_query_migrate_cache_size(NULL) >> 10);
}
#ifdef CONFIG_VNC
/* Helper for hmp_info_vnc_clients, _servers */
@ -1226,34 +1220,6 @@ void hmp_migrate_pause(Monitor *mon, const QDict *qdict)
hmp_handle_error(mon, err);
}
/* Kept for backwards compatibility */
void hmp_migrate_set_downtime(Monitor *mon, const QDict *qdict)
{
Error *err = NULL;
double value = qdict_get_double(qdict, "value");
qmp_migrate_set_downtime(value, &err);
hmp_handle_error(mon, err);
}
void hmp_migrate_set_cache_size(Monitor *mon, const QDict *qdict)
{
int64_t value = qdict_get_int(qdict, "value");
Error *err = NULL;
qmp_migrate_set_cache_size(value, &err);
hmp_handle_error(mon, err);
}
/* Kept for backwards compatibility */
void hmp_migrate_set_speed(Monitor *mon, const QDict *qdict)
{
Error *err = NULL;
int64_t value = qdict_get_int(qdict, "value");
qmp_migrate_set_speed(value, &err);
hmp_handle_error(mon, err);
}
void hmp_migrate_set_capability(Monitor *mon, const QDict *qdict)
{

187
monitor/misc.c
View File

@ -1045,193 +1045,6 @@ static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
QLIST_INSERT_HEAD (&capture_head, s, entries);
}
static QAuthZList *find_auth(Monitor *mon, const char *name)
{
Object *obj;
Object *container;
container = object_get_objects_root();
obj = object_resolve_path_component(container, name);
if (!obj) {
monitor_printf(mon, "acl: unknown list '%s'\n", name);
return NULL;
}
return QAUTHZ_LIST(obj);
}
static bool warn_acl;
static void hmp_warn_acl(void)
{
if (warn_acl) {
return;
}
error_report("The acl_show, acl_reset, acl_policy, acl_add, acl_remove "
"commands are deprecated with no replacement. Authorization "
"for VNC should be performed using the pluggable QAuthZ "
"objects");
warn_acl = true;
}
static void hmp_acl_show(Monitor *mon, const QDict *qdict)
{
const char *aclname = qdict_get_str(qdict, "aclname");
QAuthZList *auth = find_auth(mon, aclname);
QAuthZListRuleList *rules;
size_t i = 0;
hmp_warn_acl();
if (!auth) {
return;
}
monitor_printf(mon, "policy: %s\n",
QAuthZListPolicy_str(auth->policy));
rules = auth->rules;
while (rules) {
QAuthZListRule *rule = rules->value;
i++;
monitor_printf(mon, "%zu: %s %s\n", i,
QAuthZListPolicy_str(rule->policy),
rule->match);
rules = rules->next;
}
}
static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
{
const char *aclname = qdict_get_str(qdict, "aclname");
QAuthZList *auth = find_auth(mon, aclname);
hmp_warn_acl();
if (!auth) {
return;
}
auth->policy = QAUTHZ_LIST_POLICY_DENY;
qapi_free_QAuthZListRuleList(auth->rules);
auth->rules = NULL;
monitor_printf(mon, "acl: removed all rules\n");
}
static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
{
const char *aclname = qdict_get_str(qdict, "aclname");
const char *policy = qdict_get_str(qdict, "policy");
QAuthZList *auth = find_auth(mon, aclname);
int val;
Error *err = NULL;
hmp_warn_acl();
if (!auth) {
return;
}
val = qapi_enum_parse(&QAuthZListPolicy_lookup,
policy,
QAUTHZ_LIST_POLICY_DENY,
&err);
if (err) {
error_free(err);
monitor_printf(mon, "acl: unknown policy '%s', "
"expected 'deny' or 'allow'\n", policy);
} else {
auth->policy = val;
if (auth->policy == QAUTHZ_LIST_POLICY_ALLOW) {
monitor_printf(mon, "acl: policy set to 'allow'\n");
} else {
monitor_printf(mon, "acl: policy set to 'deny'\n");
}
}
}
static QAuthZListFormat hmp_acl_get_format(const char *match)
{
if (strchr(match, '*')) {
return QAUTHZ_LIST_FORMAT_GLOB;
} else {
return QAUTHZ_LIST_FORMAT_EXACT;
}
}
static void hmp_acl_add(Monitor *mon, const QDict *qdict)
{
const char *aclname = qdict_get_str(qdict, "aclname");
const char *match = qdict_get_str(qdict, "match");
const char *policystr = qdict_get_str(qdict, "policy");
int has_index = qdict_haskey(qdict, "index");
int index = qdict_get_try_int(qdict, "index", -1);
QAuthZList *auth = find_auth(mon, aclname);
Error *err = NULL;
QAuthZListPolicy policy;
QAuthZListFormat format;
size_t i = 0;
hmp_warn_acl();
if (!auth) {
return;
}
policy = qapi_enum_parse(&QAuthZListPolicy_lookup,
policystr,
QAUTHZ_LIST_POLICY_DENY,
&err);
if (err) {
error_free(err);
monitor_printf(mon, "acl: unknown policy '%s', "
"expected 'deny' or 'allow'\n", policystr);
return;
}
format = hmp_acl_get_format(match);
if (has_index && index == 0) {
monitor_printf(mon, "acl: unable to add acl entry\n");
return;
}
if (has_index) {
i = qauthz_list_insert_rule(auth, match, policy,
format, index - 1, &err);
} else {
i = qauthz_list_append_rule(auth, match, policy,
format, &err);
}
if (err) {
monitor_printf(mon, "acl: unable to add rule: %s",
error_get_pretty(err));
error_free(err);
} else {
monitor_printf(mon, "acl: added rule at position %zu\n", i + 1);
}
}
static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
{
const char *aclname = qdict_get_str(qdict, "aclname");
const char *match = qdict_get_str(qdict, "match");
QAuthZList *auth = find_auth(mon, aclname);
ssize_t i = 0;
hmp_warn_acl();
if (!auth) {
return;
}
i = qauthz_list_delete_rule(auth, match);
if (i >= 0) {
monitor_printf(mon, "acl: removed rule at position %zu\n", i + 1);
} else {
monitor_printf(mon, "acl: no matching acl entry\n");
}
}
void qmp_getfd(const char *fdname, Error **errp)
{
Monitor *cur_mon = monitor_cur();

4
monitor/monitor.c
View File

@ -716,8 +716,8 @@ int monitor_init(MonitorOptions *opts, bool allow_hmp, Error **errp)
return -1;
}
if (opts->pretty) {
warn_report("'pretty' is deprecated for HMP monitors, it has no "
"effect and will be removed in future versions");
error_setg(errp, "'pretty' is not compatible with HMP monitors");
return -1;
}
monitor_init_hmp(chr, true, &local_err);
break;

24
monitor/qmp-cmds-control.c
View File

@ -130,30 +130,6 @@ CommandInfoList *qmp_query_commands(Error **errp)
return list;
}
EventInfoList *qmp_query_events(Error **errp)
{
/*
* TODO This deprecated command is the only user of
* QAPIEvent_str() and QAPIEvent_lookup[]. When the command goes,
* they should go, too.
*/
EventInfoList *ev_list = NULL;
QAPIEvent e;
for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
const char *event_name = QAPIEvent_str(e);
EventInfo *info;
assert(event_name != NULL);
info = g_malloc0(sizeof(*info));
info->name = g_strdup(event_name);
QAPI_LIST_PREPEND(ev_list, info);
}
return ev_list;
}
/*
* Minor hack: generated marshalling suppressed for this command
* ('gen': false in the schema) so we can parse the JSON string

64
qapi/block-core.json
View File

@ -319,8 +319,6 @@
#
# @encrypted: true if the backing device is encrypted
#
# @encryption_key_missing: always false
#
# @detect_zeroes: detect and optimize zero writes (Since 2.1)
#
# @bps: total throughput limit in bytes per second is specified
@ -385,10 +383,6 @@
# @dirty-bitmaps: dirty bitmaps information (only present if node
# has one or more dirty bitmaps) (Since 4.2)
#
# Features:
# @deprecated: Member @encryption_key_missing is deprecated. It is
# always false.
#
# Since: 0.14
#
##
@ -396,8 +390,6 @@
'data': { 'file': 'str', '*node-name': 'str', 'ro': 'bool', 'drv': 'str',
'*backing_file': 'str', 'backing_file_depth': 'int',
'encrypted': 'bool',
'encryption_key_missing': { 'type': 'bool',
'features': [ 'deprecated' ] },
'detect_zeroes': 'BlockdevDetectZeroesOptions',
'bps': 'int', 'bps_rd': 'int', 'bps_wr': 'int',
'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int',
@ -426,43 +418,6 @@
##
{ 'enum': 'BlockDeviceIoStatus', 'data': [ 'ok', 'failed', 'nospace' ] }
##
# @DirtyBitmapStatus:
#
# An enumeration of possible states that a dirty bitmap can report to the user.
#
# @frozen: The bitmap is currently in-use by some operation and is immutable.
# If the bitmap was @active prior to the operation, new writes by the
# guest are being recorded in a temporary buffer, and will not be lost.
# Generally, bitmaps are cleared on successful use in an operation and
# the temporary buffer is committed into the bitmap. On failure, the
# temporary buffer is merged back into the bitmap without first
# clearing it.
# Please refer to the documentation for each bitmap-using operation,
# See also @blockdev-backup, @drive-backup.
#
# @disabled: The bitmap is not currently recording new writes by the guest.
# This is requested explicitly via @block-dirty-bitmap-disable.
# It can still be cleared, deleted, or used for backup operations.
#
# @active: The bitmap is actively monitoring for new writes, and can be cleared,
# deleted, or used for backup operations.
#
# @locked: The bitmap is currently in-use by some operation and is immutable.
# If the bitmap was @active prior to the operation, it is still
# recording new writes. If the bitmap was @disabled, it is not
# recording new writes. (Since 2.12)
#
# @inconsistent: This is a persistent dirty bitmap that was marked in-use on
# disk, and is unusable by QEMU. It can only be deleted.
# Please rely on the inconsistent field in @BlockDirtyInfo
# instead, as the status field is deprecated. (Since 4.0)
#
# Since: 2.4
##
{ 'enum': 'DirtyBitmapStatus',
'data': ['active', 'disabled', 'frozen', 'locked', 'inconsistent'] }
##
# @BlockDirtyInfo:
#
@ -474,8 +429,6 @@
#
# @granularity: granularity of the dirty bitmap in bytes (since 1.4)
#
# @status: current status of the dirty bitmap (since 2.4)
#
# @recording: true if the bitmap is recording new writes from the guest.
# Replaces `active` and `disabled` statuses. (since 4.0)
#
@ -491,17 +444,11 @@
# @busy to be false. This bitmap cannot be used. To remove
# it, use @block-dirty-bitmap-remove. (Since 4.0)
#
# Features:
# @deprecated: Member @status is deprecated. Use @recording and
# @locked instead.
#
# Since: 1.3
##
{ 'struct': 'BlockDirtyInfo',
'data': {'*name': 'str', 'count': 'int', 'granularity': 'uint32',
'recording': 'bool', 'busy': 'bool',
'status': { 'type': 'DirtyBitmapStatus',
'features': [ 'deprecated' ] },
'persistent': 'bool', '*inconsistent': 'bool' } }
##
@ -592,9 +539,6 @@
# @tray_open: True if the device's tray is open
# (only present if it has a tray)
#
# @dirty-bitmaps: dirty bitmaps information (only present if the
# driver has one or more dirty bitmaps) (Since 2.0)
#
# @io-status: @BlockDeviceIoStatus. Only present if the device
# supports it and the VM is configured to stop on errors
# (supported device models: virtio-blk, IDE, SCSI except
@ -603,18 +547,12 @@
# @inserted: @BlockDeviceInfo describing the device if media is
# present
#
# Features:
# @deprecated: Member @dirty-bitmaps is deprecated. Use @inserted
# member @dirty-bitmaps instead.
#
# Since: 0.14
##
{ 'struct': 'BlockInfo',
'data': {'device': 'str', '*qdev': 'str', 'type': 'str', 'removable': 'bool',
'locked': 'bool', '*inserted': 'BlockDeviceInfo',
'*tray_open': 'bool', '*io-status': 'BlockDeviceIoStatus',
'*dirty-bitmaps': { 'type': ['BlockDirtyInfo'],
'features': [ 'deprecated' ] } } }
'*tray_open': 'bool', '*io-status': 'BlockDeviceIoStatus' } }
##
# @BlockMeasureInfo:

45
qapi/control.json
View File

@ -159,51 +159,6 @@
{ 'command': 'query-commands', 'returns': ['CommandInfo'],
'allow-preconfig': true }
##
# @EventInfo:
#
# Information about a QMP event
#
# @name: The event name
#
# Since: 1.2
##
{ 'struct': 'EventInfo', 'data': {'name': 'str'} }
##
# @query-events:
#
# Return information on QMP events.
#
# Features:
# @deprecated: This command is deprecated, because its output doesn't
# reflect compile-time configuration. Use 'query-qmp-schema'
# instead.
#
# Returns: A list of @EventInfo.
#
# Since: 1.2
#
# Example:
#
# -> { "execute": "query-events" }
# <- {
# "return": [
# {
# "name":"SHUTDOWN"
# },
# {
# "name":"RESET"
# }
# ]
# }
#
# Note: This example has been shortened as the real response is too long.
#
##
{ 'command': 'query-events', 'returns': ['EventInfo'],
'features': [ 'deprecated' ] }
##
# @quit:
#

181
qapi/machine.json
View File

@ -34,129 +34,6 @@
'sh4eb', 'sparc', 'sparc64', 'tricore', 'unicore32',
'x86_64', 'xtensa', 'xtensaeb' ] }
##
# @CpuInfoArch:
#
# An enumeration of cpu types that enable additional information during
# @query-cpus and @query-cpus-fast.
#
# @s390: since 2.12
#
# @riscv: since 2.12
#
# Since: 2.6
##
{ 'enum': 'CpuInfoArch',
'data': ['x86', 'sparc', 'ppc', 'mips', 'tricore', 's390', 'riscv', 'other' ] }
##
# @CpuInfo:
#
# Information about a virtual CPU
#
# @CPU: the index of the virtual CPU
#
# @current: this only exists for backwards compatibility and should be ignored
#
# @halted: true if the virtual CPU is in the halt state. Halt usually refers
# to a processor specific low power mode.
#
# @qom_path: path to the CPU object in the QOM tree (since 2.4)
#
# @thread_id: ID of the underlying host thread
#
# @props: properties describing to which node/socket/core/thread
# virtual CPU belongs to, provided if supported by board (since 2.10)
#
# @arch: architecture of the cpu, which determines which additional fields
# will be listed (since 2.6)
#
# Since: 0.14
#
# Notes: @halted is a transient state that changes frequently. By the time the
# data is sent to the client, the guest may no longer be halted.
##
{ 'union': 'CpuInfo',
'base': {'CPU': 'int', 'current': 'bool', 'halted': 'bool',
'qom_path': 'str', 'thread_id': 'int',
'*props': 'CpuInstanceProperties', 'arch': 'CpuInfoArch' },
'discriminator': 'arch',
'data': { 'x86': 'CpuInfoX86',
'sparc': 'CpuInfoSPARC',
'ppc': 'CpuInfoPPC',
'mips': 'CpuInfoMIPS',
'tricore': 'CpuInfoTricore',
's390': 'CpuInfoS390',
'riscv': 'CpuInfoRISCV' } }
##
# @CpuInfoX86:
#
# Additional information about a virtual i386 or x86_64 CPU
#
# @pc: the 64-bit instruction pointer
#
# Since: 2.6
##
{ 'struct': 'CpuInfoX86', 'data': { 'pc': 'int' } }
##
# @CpuInfoSPARC:
#
# Additional information about a virtual SPARC CPU
#
# @pc: the PC component of the instruction pointer
#
# @npc: the NPC component of the instruction pointer
#
# Since: 2.6
##
{ 'struct': 'CpuInfoSPARC', 'data': { 'pc': 'int', 'npc': 'int' } }
##
# @CpuInfoPPC:
#
# Additional information about a virtual PPC CPU
#
# @nip: the instruction pointer
#
# Since: 2.6
##
{ 'struct': 'CpuInfoPPC', 'data': { 'nip': 'int' } }
##
# @CpuInfoMIPS:
#
# Additional information about a virtual MIPS CPU
#
# @PC: the instruction pointer
#
# Since: 2.6
##
{ 'struct': 'CpuInfoMIPS', 'data': { 'PC': 'int' } }
##
# @CpuInfoTricore:
#
# Additional information about a virtual Tricore CPU
#
# @PC: the instruction pointer
#
# Since: 2.6
##
{ 'struct': 'CpuInfoTricore', 'data': { 'PC': 'int' } }
##
# @CpuInfoRISCV:
#
# Additional information about a virtual RISCV CPU
#
# @pc: the instruction pointer
#
# Since 2.12
##
{ 'struct': 'CpuInfoRISCV', 'data': { 'pc': 'int' } }
##
# @CpuS390State:
#
@ -180,53 +57,6 @@
##
{ 'struct': 'CpuInfoS390', 'data': { 'cpu-state': 'CpuS390State' } }
##
# @query-cpus:
#
# Returns a list of information about each virtual CPU.
#
# This command causes vCPU threads to exit to userspace, which causes
# a small interruption to guest CPU execution. This will have a negative
# impact on realtime guests and other latency sensitive guest workloads.
#
# Features:
# @deprecated: This command is deprecated, because it interferes with
# the guest. Use 'query-cpus-fast' instead to avoid the vCPU
# interruption.
#
# Returns: a list of @CpuInfo for each virtual CPU
#
# Since: 0.14
#
# Example:
#
# -> { "execute": "query-cpus" }
# <- { "return": [
# {
# "CPU":0,
# "current":true,
# "halted":false,
# "qom_path":"/machine/unattached/device[0]",
# "arch":"x86",
# "pc":3227107138,
# "thread_id":3134
# },
# {
# "CPU":1,
# "current":false,
# "halted":true,
# "qom_path":"/machine/unattached/device[2]",
# "arch":"x86",
# "pc":7108165,
# "thread_id":3135
# }
# ]
# }
#
##
{ 'command': 'query-cpus', 'returns': ['CpuInfo'],
'features': [ 'deprecated' ] }
##
# @CpuInfoFast:
#
@ -241,14 +71,9 @@
# @props: properties describing to which node/socket/core/thread
# virtual CPU belongs to, provided if supported by board
#
# @arch: base architecture of the cpu
#
# @target: the QEMU system emulation target, which determines which
# additional fields will be listed (since 3.0)
#
# Features:
# @deprecated: Member @arch is deprecated. Use @target instead.
#
# Since: 2.12
#
##
@ -257,8 +82,6 @@
'qom-path' : 'str',
'thread-id' : 'int',
'*props' : 'CpuInstanceProperties',
'arch' : { 'type': 'CpuInfoArch',
'features': [ 'deprecated' ] },
'target' : 'SysEmuTarget' },
'discriminator' : 'target',
'data' : { 's390x' : 'CpuInfoS390' } }
@ -266,9 +89,7 @@
##
# @query-cpus-fast:
#
# Returns information about all virtual CPUs. This command does not
# incur a performance penalty and should be used in production
# instead of query-cpus.
# Returns information about all virtual CPUs.
#
# Returns: list of @CpuInfoFast
#

98
qapi/migration.json
View File

@ -1398,104 +1398,6 @@
##
{ 'command': 'migrate-continue', 'data': {'state': 'MigrationStatus'} }
##
# @migrate_set_downtime:
#
# Set maximum tolerated downtime for migration.
#
# @value: maximum downtime in seconds
#
# Features:
# @deprecated: This command is deprecated. Use
# 'migrate-set-parameters' instead.
#
# Returns: nothing on success
#
# Since: 0.14
#
# Example:
#
# -> { "execute": "migrate_set_downtime", "arguments": { "value": 0.1 } }
# <- { "return": {} }
#
##
{ 'command': 'migrate_set_downtime', 'data': {'value': 'number'},
'features': [ 'deprecated' ] }
##
# @migrate_set_speed:
#
# Set maximum speed for migration.
#
# @value: maximum speed in bytes per second.
#
# Features:
# @deprecated: This command is deprecated. Use
# 'migrate-set-parameters' instead.
#
# Returns: nothing on success
#
# Since: 0.14
#
# Example:
#
# -> { "execute": "migrate_set_speed", "arguments": { "value": 1024 } }
# <- { "return": {} }
#
##
{ 'command': 'migrate_set_speed', 'data': {'value': 'int'},
'features': [ 'deprecated' ] }
##
# @migrate-set-cache-size:
#
# Set cache size to be used by XBZRLE migration
#
# @value: cache size in bytes
#
# Features:
# @deprecated: This command is deprecated. Use
# 'migrate-set-parameters' instead.
#
# The size will be rounded down to the nearest power of 2.
# The cache size can be modified before and during ongoing migration
#
# Returns: nothing on success
#
# Since: 1.2
#
# Example:
#
# -> { "execute": "migrate-set-cache-size",
# "arguments": { "value": 536870912 } }
# <- { "return": {} }
#
##
{ 'command': 'migrate-set-cache-size', 'data': {'value': 'int'},
'features': [ 'deprecated' ] }
##
# @query-migrate-cache-size:
#
# Query migration XBZRLE cache size
#
# Features:
# @deprecated: This command is deprecated. Use
# 'query-migrate-parameters' instead.
#
# Returns: XBZRLE cache size in bytes
#
# Since: 1.2
#
# Example:
#
# -> { "execute": "query-migrate-cache-size" }
# <- { "return": 67108864 }
#
##
{ 'command': 'query-migrate-cache-size', 'returns': 'size',
'features': [ 'deprecated' ] }
##
# @migrate:
#

5
qemu-options.hx
View File

@ -3740,8 +3740,9 @@ DEF("mon", HAS_ARG, QEMU_OPTION_mon, \
"-mon [chardev=]name[,mode=readline|control][,pretty[=on|off]]\n", QEMU_ARCH_ALL)
SRST
``-mon [chardev=]name[,mode=readline|control][,pretty[=on|off]]``
Setup monitor on chardev name. ``pretty`` turns on JSON pretty
printing easing human reading and debugging.
Setup monitor on chardev name. ``pretty`` is only valid when
``mode=control``, turning on JSON pretty printing to ease
human reading and debugging.
ERST
DEF("debugcon", HAS_ARG, QEMU_OPTION_debugcon, \

2
scripts/device-crash-test
View File

@ -76,7 +76,6 @@ ERROR_RULE_LIST = [
{'device':'ics', 'expected':True}, # ics_base_realize: required link 'xics' not found: Property '.xics' not found
# "-device ide-cd" does work on more recent QEMU versions, so it doesn't have expected=True
{'device':'ide-cd'}, # No drive specified
{'device':'ide-drive', 'expected':True}, # No drive specified
{'device':'ide-hd', 'expected':True}, # No drive specified
{'device':'ipmi-bmc-extern', 'expected':True}, # IPMI external bmc requires chardev attribute
{'device':'isa-debugcon', 'expected':True}, # Can't create serial device, empty char device
@ -94,7 +93,6 @@ ERROR_RULE_LIST = [
{'device':'pci-bridge-seat', 'expected':True}, # Bridge chassis not specified. Each bridge is required to be assigned a unique chassis id > 0.
{'device':'pxb', 'expected':True}, # Bridge chassis not specified. Each bridge is required to be assigned a unique chassis id > 0.
{'device':'scsi-block', 'expected':True}, # drive property not set
{'device':'scsi-disk', 'expected':True}, # drive property not set
{'device':'scsi-generic', 'expected':True}, # drive property not set
{'device':'scsi-hd', 'expected':True}, # drive property not set
{'device':'spapr-pci-host-bridge', 'expected':True}, # BUID not specified for PHB

1
softmmu/vl.c
View File

@ -177,7 +177,6 @@ static struct {
{ .driver = "floppy", .flag = &default_floppy },
{ .driver = "ide-cd", .flag = &default_cdrom },
{ .driver = "ide-hd", .flag = &default_cdrom },
{ .driver = "ide-drive", .flag = &default_cdrom },
{ .driver = "scsi-cd", .flag = &default_cdrom },
{ .driver = "scsi-hd", .flag = &default_cdrom },
{ .driver = "VGA", .flag = &default_vga },

2
tests/acceptance/pc_cpu_hotplug_props.py
View File

@ -32,4 +32,4 @@ class OmittedCPUProps(Test):
self.vm.add_args('-cpu', 'qemu64')
self.vm.add_args('-device', 'qemu64-x86_64-cpu,socket-id=1,core-id=0,thread-id=0')
self.vm.launch()
self.assertEquals(len(self.vm.command('query-cpus')), 2)
self.assertEquals(len(self.vm.command('query-cpus-fast')), 2)

2
tests/acceptance/x86_cpu_model_versions.py
View File

@ -246,7 +246,7 @@ class CascadelakeArchCapabilities(avocado_qemu.Test):
:avocado: tags=arch:x86_64
"""
def get_cpu_prop(self, prop):
cpu_path = self.vm.command('query-cpus')[0].get('qom_path')
cpu_path = self.vm.command('query-cpus-fast')[0].get('qom-path')
return self.vm.command('qom-get', path=cpu_path, property=prop)
def test_4_1(self):

18
tests/migration/guestperf/engine.py
View File

@ -110,7 +110,7 @@ class Engine(object):
src_vcpu_time = []
src_pid = src.get_pid()
vcpus = src.command("query-cpus")
vcpus = src.command("query-cpus-fast")
src_threads = []
for vcpu in vcpus:
src_threads.append(vcpu["thread_id"])
@ -149,11 +149,11 @@ class Engine(object):
"state": True }
])
resp = src.command("migrate_set_speed",
value=scenario._bandwidth * 1024 * 1024)
resp = src.command("migrate-set-parameters",
max_bandwidth=scenario._bandwidth * 1024 * 1024)
resp = src.command("migrate_set_downtime",
value=scenario._downtime / 1024.0)
resp = src.command("migrate-set-parameters",
downtime_limit=scenario._downtime / 1024.0)
if scenario._compression_mt:
resp = src.command("migrate-set-capabilities",
@ -182,9 +182,11 @@ class Engine(object):
{ "capability": "xbzrle",
"state": True }
])
resp = src.command("migrate-set-cache-size",
value=(hardware._mem * 1024 * 1024 * 1024 / 100 *
scenario._compression_xbzrle_cache))
resp = src.command("migrate-set-parameters",
xbzrle_cache_size=(
hardware._mem *
1024 * 1024 * 1024 / 100 *
scenario._compression_xbzrle_cache))
resp = src.command("migrate", uri=connect_uri)

4
tests/qemu-iotests/051
View File

@ -185,9 +185,7 @@ case "$QEMU_DEFAULT_MACHINE" in
pc)
run_qemu -drive if=none,id=disk -device ide-cd,drive=disk
run_qemu -drive if=none,id=disk -device lsi53c895a -device scsi-cd,drive=disk
run_qemu -drive if=none,id=disk -device ide-drive,drive=disk
run_qemu -drive if=none,id=disk -device ide-hd,drive=disk
run_qemu -drive if=none,id=disk -device lsi53c895a -device scsi-disk,drive=disk
run_qemu -drive if=none,id=disk -device lsi53c895a -device scsi-hd,drive=disk
;;
*)
@ -238,9 +236,7 @@ case "$QEMU_DEFAULT_MACHINE" in
pc)
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device ide-cd,drive=disk
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device lsi53c895a -device scsi-cd,drive=disk
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device ide-drive,drive=disk
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device ide-hd,drive=disk
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device lsi53c895a -device scsi-disk,drive=disk
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device lsi53c895a -device scsi-hd,drive=disk
;;
*)

20
tests/qemu-iotests/051.pc.out
View File

@ -156,20 +156,10 @@ Testing: -drive if=none,id=disk -device lsi53c895a -device scsi-cd,drive=disk
QEMU X.Y.Z monitor - type 'help' for more information
(qemu) quit
Testing: -drive if=none,id=disk -device ide-drive,drive=disk
QEMU X.Y.Z monitor - type 'help' for more information
(qemu) QEMU_PROG: -device ide-drive,drive=disk: warning: 'ide-drive' is deprecated, please use 'ide-hd' or 'ide-cd' instead
QEMU_PROG: -device ide-drive,drive=disk: Device needs media, but drive is empty
Testing: -drive if=none,id=disk -device ide-hd,drive=disk
QEMU X.Y.Z monitor - type 'help' for more information
(qemu) QEMU_PROG: -device ide-hd,drive=disk: Device needs media, but drive is empty
Testing: -drive if=none,id=disk -device lsi53c895a -device scsi-disk,drive=disk
QEMU X.Y.Z monitor - type 'help' for more information
(qemu) QEMU_PROG: -device scsi-disk,drive=disk: warning: 'scsi-disk' is deprecated, please use 'scsi-hd' or 'scsi-cd' instead
QEMU_PROG: -device scsi-disk,drive=disk: Device needs media, but drive is empty
Testing: -drive if=none,id=disk -device lsi53c895a -device scsi-hd,drive=disk
QEMU X.Y.Z monitor - type 'help' for more information
(qemu) QEMU_PROG: -device scsi-hd,drive=disk: Device needs media, but drive is empty
@ -228,20 +218,10 @@ Testing: -drive file=TEST_DIR/t.qcow2,if=none,id=disk,readonly=on -device lsi53c
QEMU X.Y.Z monitor - type 'help' for more information
(qemu) quit
Testing: -drive file=TEST_DIR/t.qcow2,if=none,id=disk,readonly=on -device ide-drive,drive=disk
QEMU X.Y.Z monitor - type 'help' for more information
(qemu) QEMU_PROG: -device ide-drive,drive=disk: warning: 'ide-drive' is deprecated, please use 'ide-hd' or 'ide-cd' instead
QEMU_PROG: -device ide-drive,drive=disk: Block node is read-only
Testing: -drive file=TEST_DIR/t.qcow2,if=none,id=disk,readonly=on -device ide-hd,drive=disk
QEMU X.Y.Z monitor - type 'help' for more information
(qemu) QEMU_PROG: -device ide-hd,drive=disk: Block node is read-only
Testing: -drive file=TEST_DIR/t.qcow2,if=none,id=disk,readonly=on -device lsi53c895a -device scsi-disk,drive=disk
QEMU X.Y.Z monitor - type 'help' for more information
(qemu) QEMU_PROG: -device scsi-disk,drive=disk: warning: 'scsi-disk' is deprecated, please use 'scsi-hd' or 'scsi-cd' instead
quit
Testing: -drive file=TEST_DIR/t.qcow2,if=none,id=disk,readonly=on -device lsi53c895a -device scsi-hd,drive=disk
QEMU X.Y.Z monitor - type 'help' for more information
(qemu) quit

4
tests/qemu-iotests/124
View File

@ -348,7 +348,6 @@ class TestIncrementalBackup(TestIncrementalBackupBase):
'name': 'bitmap0',
'count': 458752,
'granularity': 65536,
'status': 'active',
'persistent': False
}))
@ -705,7 +704,6 @@ class TestIncrementalBackupBlkdebug(TestIncrementalBackupBase):
drive0['id'], bitmap.name, {
'count': 458752,
'granularity': 65536,
'status': 'active',
'busy': False,
'recording': True
}))
@ -736,7 +734,6 @@ class TestIncrementalBackupBlkdebug(TestIncrementalBackupBase):
drive0['id'], bitmap.name, {
'count': 458752,
'granularity': 65536,
'status': 'frozen',
'busy': True,
'recording': True
}))
@ -751,7 +748,6 @@ class TestIncrementalBackupBlkdebug(TestIncrementalBackupBase):
drive0['id'], bitmap.name, {
'count': 0,
'granularity': 65536,
'status': 'active',
'busy': False,
'recording': True
}))

2
tests/qemu-iotests/181
View File

@ -109,7 +109,7 @@ if [ ${QEMU_STATUS[$dest]} -lt 0 ]; then
_notrun 'Postcopy is not supported'
fi
_send_qemu_cmd $src 'migrate_set_speed 4k' "(qemu)"
_send_qemu_cmd $src 'migrate_set_parameter max_bandwidth 4k' "(qemu)"
_send_qemu_cmd $src 'migrate_set_capability postcopy-ram on' "(qemu)"
_send_qemu_cmd $src "migrate -d unix:${MIG_SOCKET}" "(qemu)"
_send_qemu_cmd $src 'migrate_start_postcopy' "(qemu)"

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

@ -54,8 +54,7 @@ Testing:
"direct": false,
"writeback": true
},
"file": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"null-co\"}}",
"encryption_key_missing": false
"file": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"null-co\"}}"
},
{
"iops_rd": 0,
@ -82,8 +81,7 @@ Testing:
"direct": false,
"writeback": true
},
"file": "null-co://",
"encryption_key_missing": false
"file": "null-co://"
}
]
}

48
tests/qemu-iotests/191.out
View File

@ -150,8 +150,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.ovl2",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.ovl2"
},
{
"iops_rd": 0,
@ -179,8 +178,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.ovl2",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.ovl2"
},
{
"iops_rd": 0,
@ -221,8 +219,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT"
},
{
"iops_rd": 0,
@ -250,8 +247,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT"
},
{
"iops_rd": 0,
@ -292,8 +288,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.mid",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.mid"
},
{
"iops_rd": 0,
@ -321,8 +316,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.mid",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.mid"
},
{
"iops_rd": 0,
@ -351,8 +345,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.base",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.base"
},
{
"iops_rd": 0,
@ -380,8 +373,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.base",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.base"
}
]
}
@ -565,8 +557,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.ovl2",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.ovl2"
},
{
"iops_rd": 0,
@ -594,8 +585,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.ovl2",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.ovl2"
},
{
"iops_rd": 0,
@ -647,8 +637,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.ovl3",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.ovl3"
},
{
"iops_rd": 0,
@ -676,8 +665,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.ovl3",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.ovl3"
},
{
"iops_rd": 0,
@ -706,8 +694,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.base",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.base"
},
{
"iops_rd": 0,
@ -735,8 +722,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.base",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.base"
},
{
"iops_rd": 0,
@ -777,8 +763,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT"
},
{
"iops_rd": 0,
@ -806,8 +791,7 @@ wrote 65536/65536 bytes at offset 1048576
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT"
}
]
}

4
tests/qemu-iotests/194
View File

@ -95,7 +95,7 @@ with iotests.FilePath('source.img') as source_img_path, \
iotests.log(event, filters=[iotests.filter_qmp_event])
iotests.log('Check bitmaps on source:')
iotests.log(source_vm.qmp('query-block')['return'][0]['dirty-bitmaps'])
iotests.log(source_vm.qmp('query-block')['return'][0]['inserted']['dirty-bitmaps'])
iotests.log('Check bitmaps on target:')
iotests.log(dest_vm.qmp('query-block')['return'][0]['dirty-bitmaps'])
iotests.log(dest_vm.qmp('query-block')['return'][0]['inserted']['dirty-bitmaps'])

4
tests/qemu-iotests/194.out
View File

@ -24,6 +24,6 @@ Stopping the NBD server on destination...
Wait for migration completion on target...
{"data": {"status": "completed"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
Check bitmaps on source:
[{"busy": false, "count": 0, "granularity": 65536, "name": "bitmap0", "persistent": false, "recording": true, "status": "active"}]
[{"busy": false, "count": 0, "granularity": 65536, "name": "bitmap0", "persistent": false, "recording": true}]
Check bitmaps on target:
[{"busy": false, "count": 0, "granularity": 65536, "name": "bitmap0", "persistent": false, "recording": true, "status": "active"}]
[{"busy": false, "count": 0, "granularity": 65536, "name": "bitmap0", "persistent": false, "recording": true}]

10
tests/qemu-iotests/226.out
View File

@ -3,23 +3,23 @@ QA output created by 226
=== Testing with driver:file ===
== Testing RO ==
qemu-io: can't open: A regular file was expected by the 'file' driver, but something else was given
qemu-io: warning: Opening a character device as a file using the 'file' driver is deprecated
qemu-io: can't open: 'file' driver requires 'TEST_DIR/t.IMGFMT' to be a regular file
qemu-io: can't open: 'file' driver requires '/dev/null' to be a regular file
== Testing RW ==
qemu-io: can't open: Could not open 'TEST_DIR/t.IMGFMT': Is a directory
qemu-io: warning: Opening a character device as a file using the 'file' driver is deprecated
qemu-io: can't open: 'file' driver requires '/dev/null' to be a regular file
=== Testing with driver:host_device ===
== Testing RO ==
qemu-io: can't open: 'host_device' driver expects either a character or block device
qemu-io: can't open: 'host_device' driver requires 'TEST_DIR/t.IMGFMT' to be either a character or block device
== Testing RW ==
qemu-io: can't open: Could not open 'TEST_DIR/t.IMGFMT': Is a directory
=== Testing with driver:host_cdrom ===
== Testing RO ==
qemu-io: can't open: 'host_cdrom' driver expects either a character or block device
qemu-io: can't open: 'host_cdrom' driver requires 'TEST_DIR/t.IMGFMT' to be either a character or block device
== Testing RW ==
qemu-io: can't open: Could not open 'TEST_DIR/t.IMGFMT': Is a directory

2
tests/qemu-iotests/236
View File

@ -39,7 +39,7 @@ overwrite = [("0xab", "0", "64k"), # Full overwrite
def query_bitmaps(vm):
res = vm.qmp("query-block")
return { "bitmaps": { device['device']: device.get('dirty-bitmaps', []) for
return { "bitmaps": { device['device']: device.get('inserted', {}).get('dirty-bitmaps', []) for
device in res['return'] } }
with iotests.FilePath('img') as img_path, \

42
tests/qemu-iotests/236.out
View File

@ -27,8 +27,7 @@ write -P0xcd 0x3ff0000 64k
"granularity": 65536,
"name": "bitmapB",
"persistent": false,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -36,8 +35,7 @@ write -P0xcd 0x3ff0000 64k
"granularity": 65536,
"name": "bitmapA",
"persistent": false,
"recording": true,
"status": "active"
"recording": true
}
]
}
@ -93,8 +91,7 @@ write -P0xcd 0x3ff0000 64k
"granularity": 65536,
"name": "bitmapB",
"persistent": false,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -102,8 +99,7 @@ write -P0xcd 0x3ff0000 64k
"granularity": 65536,
"name": "bitmapA",
"persistent": false,
"recording": true,
"status": "active"
"recording": true
}
]
}
@ -197,8 +193,7 @@ write -P0xea 0x3fe0000 64k
"granularity": 65536,
"name": "bitmapC",
"persistent": false,
"recording": false,
"status": "disabled"
"recording": false
},
{
"busy": false,
@ -206,8 +201,7 @@ write -P0xea 0x3fe0000 64k
"granularity": 65536,
"name": "bitmapB",
"persistent": false,
"recording": false,
"status": "disabled"
"recording": false
},
{
"busy": false,
@ -215,8 +209,7 @@ write -P0xea 0x3fe0000 64k
"granularity": 65536,
"name": "bitmapA",
"persistent": false,
"recording": false,
"status": "disabled"
"recording": false
}
]
}
@ -270,8 +263,7 @@ write -P0xea 0x3fe0000 64k
"granularity": 65536,
"name": "bitmapC",
"persistent": false,
"recording": false,
"status": "disabled"
"recording": false
},
{
"busy": false,
@ -279,8 +271,7 @@ write -P0xea 0x3fe0000 64k
"granularity": 65536,
"name": "bitmapB",
"persistent": false,
"recording": false,
"status": "disabled"
"recording": false
},
{
"busy": false,
@ -288,8 +279,7 @@ write -P0xea 0x3fe0000 64k
"granularity": 65536,
"name": "bitmapA",
"persistent": false,
"recording": false,
"status": "disabled"
"recording": false
}
]
}
@ -336,8 +326,7 @@ write -P0xea 0x3fe0000 64k
"granularity": 65536,
"name": "bitmapD",
"persistent": false,
"recording": false,
"status": "disabled"
"recording": false
},
{
"busy": false,
@ -345,8 +334,7 @@ write -P0xea 0x3fe0000 64k
"granularity": 65536,
"name": "bitmapC",
"persistent": false,
"recording": false,
"status": "disabled"
"recording": false
},
{
"busy": false,
@ -354,8 +342,7 @@ write -P0xea 0x3fe0000 64k
"granularity": 65536,
"name": "bitmapB",
"persistent": false,
"recording": false,
"status": "disabled"
"recording": false
},
{
"busy": false,
@ -363,8 +350,7 @@ write -P0xea 0x3fe0000 64k
"granularity": 65536,
"name": "bitmapA",
"persistent": false,
"recording": false,
"status": "disabled"
"recording": false
}
]
}

3
tests/qemu-iotests/246
View File

@ -30,7 +30,8 @@ gran_large = 128 * 1024
def query_bitmaps(vm):
res = vm.qmp("query-block")
return { "bitmaps": { device['device']: device.get('dirty-bitmaps', []) for
return { "bitmaps": { device['device']: device.get('inserted', {})
.get('dirty-bitmaps', []) for
device in res['return'] } }
with iotests.FilePath('img') as img_path, \

66
tests/qemu-iotests/246.out
View File

@ -24,8 +24,7 @@
"granularity": 65536,
"name": "Transient",
"persistent": false,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -33,8 +32,7 @@
"granularity": 131072,
"name": "Large",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -42,8 +40,7 @@
"granularity": 65536,
"name": "Medium",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -51,8 +48,7 @@
"granularity": 32768,
"name": "Small",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
}
]
}
@ -68,8 +64,7 @@
"granularity": 32768,
"name": "Small",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -77,8 +72,7 @@
"granularity": 65536,
"name": "Medium",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -86,8 +80,7 @@
"granularity": 131072,
"name": "Large",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
}
]
}
@ -108,8 +101,7 @@
"granularity": 65536,
"name": "Newtwo",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -117,8 +109,7 @@
"granularity": 65536,
"name": "New",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -126,8 +117,7 @@
"granularity": 32768,
"name": "Small",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -135,8 +125,7 @@
"granularity": 65536,
"name": "Medium",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -144,8 +133,7 @@
"granularity": 131072,
"name": "Large",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
}
]
}
@ -163,8 +151,7 @@
"granularity": 65536,
"name": "New",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -172,8 +159,7 @@
"granularity": 65536,
"name": "Newtwo",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -181,8 +167,7 @@
"granularity": 32768,
"name": "Small",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -190,8 +175,7 @@
"granularity": 65536,
"name": "Medium",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -199,8 +183,7 @@
"granularity": 131072,
"name": "Large",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
}
]
}
@ -232,8 +215,7 @@
"granularity": 65536,
"name": "NewB",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -241,8 +223,7 @@
"granularity": 65536,
"name": "NewC",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -250,8 +231,7 @@
"granularity": 32768,
"name": "Small",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -259,8 +239,7 @@
"granularity": 65536,
"name": "Medium",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -268,8 +247,7 @@
"granularity": 131072,
"name": "Large",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
}
]
}

2
tests/qemu-iotests/254
View File

@ -73,7 +73,7 @@ vm.qmp_log('transaction', indent=2, actions=[
result = vm.qmp('query-block')['return'][0]
log("query-block: device = {}, node-name = {}, dirty-bitmaps:".format(
result['device'], result['inserted']['node-name']))
log(result['dirty-bitmaps'], indent=2)
log(result['inserted']['dirty-bitmaps'], indent=2)
log("\nbitmaps in backing image:")
log(result['inserted']['image']['backing-image']['format-specific'] \
['data']['bitmaps'], indent=2)

9
tests/qemu-iotests/254.out
View File

@ -99,8 +99,7 @@ query-block: device = drive0, node-name = snap, dirty-bitmaps:
"granularity": 65536,
"name": "bitmap2",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -108,8 +107,7 @@ query-block: device = drive0, node-name = snap, dirty-bitmaps:
"granularity": 65536,
"name": "bitmap1",
"persistent": true,
"recording": true,
"status": "active"
"recording": true
},
{
"busy": false,
@ -117,8 +115,7 @@ query-block: device = drive0, node-name = snap, dirty-bitmaps:
"granularity": 65536,
"name": "bitmap0",
"persistent": false,
"recording": true,
"status": "active"
"recording": true
}
]

378
tests/qemu-iotests/257.out
View File

File diff suppressed because it is too large Load Diff

5
tests/qemu-iotests/260
View File

@ -32,8 +32,9 @@ size = 64 * 1024 * 3
def print_bitmap(msg, vm):
result = vm.qmp('query-block')['return'][0]
if 'dirty-bitmaps' in result:
bitmap = result['dirty-bitmaps'][0]
info = result.get("inserted", {})
if 'dirty-bitmaps' in info:
bitmap = info['dirty-bitmaps'][0]
log('{}: name={} dirty-clusters={}'.format(msg, bitmap['name'],
bitmap['count'] // 64 // 1024))
else:

15
tests/qemu-iotests/273.out
View File

@ -69,8 +69,7 @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT"
},
{
"iops_rd": 0,
@ -98,8 +97,7 @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT"
},
{
"iops_rd": 0,
@ -139,8 +137,7 @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.mid",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.mid"
},
{
"iops_rd": 0,
@ -168,8 +165,7 @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.mid",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.mid"
},
{
"iops_rd": 0,
@ -197,8 +193,7 @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
"direct": false,
"writeback": true
},
"file": "TEST_DIR/t.IMGFMT.base",
"encryption_key_missing": false
"file": "TEST_DIR/t.IMGFMT.base"
}
]
}

6
tests/qemu-iotests/tests/migrate-bitmaps-postcopy-test
View File

@ -67,10 +67,12 @@ def event_dist(e1, e2):
def check_bitmaps(vm, count):
result = vm.qmp('query-block')
info = result['return'][0].get('inserted', {})
if count == 0:
assert 'dirty-bitmaps' not in result['return'][0]
assert 'dirty-bitmaps' not in info
else:
assert len(result['return'][0]['dirty-bitmaps']) == count
assert len(info['dirty-bitmaps']) == count
class TestDirtyBitmapPostcopyMigration(iotests.QMPTestCase):

48
tests/qtest/migration-test.c
View File

@ -658,53 +658,6 @@ static void test_migrate_end(QTestState *from, QTestState *to, bool test_dest)
cleanup("dest_serial");
}
static void deprecated_set_downtime(QTestState *who, const double value)
{
QDict *rsp;
rsp = qtest_qmp(who,
"{ 'execute': 'migrate_set_downtime',"
" 'arguments': { 'value': %f } }", value);
g_assert(qdict_haskey(rsp, "return"));
qobject_unref(rsp);
migrate_check_parameter_int(who, "downtime-limit", value * 1000);
}
static void deprecated_set_speed(QTestState *who, long long value)
{
QDict *rsp;
rsp = qtest_qmp(who, "{ 'execute': 'migrate_set_speed',"
"'arguments': { 'value': %lld } }", value);
g_assert(qdict_haskey(rsp, "return"));
qobject_unref(rsp);
migrate_check_parameter_int(who, "max-bandwidth", value);
}
static void deprecated_set_cache_size(QTestState *who, long long value)
{
QDict *rsp;
rsp = qtest_qmp(who, "{ 'execute': 'migrate-set-cache-size',"
"'arguments': { 'value': %lld } }", value);
g_assert(qdict_haskey(rsp, "return"));
qobject_unref(rsp);
migrate_check_parameter_int(who, "xbzrle-cache-size", value);
}
static void test_deprecated(void)
{
QTestState *from;
from = qtest_init("-machine none");
deprecated_set_downtime(from, 0.12345);
deprecated_set_speed(from, 12345);
deprecated_set_cache_size(from, 4096);
qtest_quit(from);
}
static int migrate_postcopy_prepare(QTestState **from_ptr,
QTestState **to_ptr,
MigrateStart *args)
@ -1486,7 +1439,6 @@ int main(int argc, char **argv)
qtest_add_func("/migration/postcopy/unix", test_postcopy);
qtest_add_func("/migration/postcopy/recovery", test_postcopy_recovery);
qtest_add_func("/migration/deprecated", test_deprecated);
qtest_add_func("/migration/bad_dest", test_baddest);
qtest_add_func("/migration/precopy/unix", test_precopy_unix);
qtest_add_func("/migration/precopy/tcp", test_precopy_tcp);

6
tests/qtest/numa-test.c
View File

@ -72,7 +72,7 @@ static void test_mon_partial(const void *data)
static QList *get_cpus(QTestState *qts, QDict **resp)
{
*resp = qtest_qmp(qts, "{ 'execute': 'query-cpus' }");
*resp = qtest_qmp(qts, "{ 'execute': 'query-cpus-fast' }");
g_assert(*resp);
g_assert(qdict_haskey(*resp, "return"));
return qdict_get_qlist(*resp, "return");
@ -97,10 +97,10 @@ static void test_query_cpus(const void *data)
int64_t cpu_idx, node;
cpu = qobject_to(QDict, e);
g_assert(qdict_haskey(cpu, "CPU"));
g_assert(qdict_haskey(cpu, "cpu-index"));
g_assert(qdict_haskey(cpu, "props"));
cpu_idx = qdict_get_int(cpu, "CPU");
cpu_idx = qdict_get_int(cpu, "cpu-index");
props = qdict_get_qdict(cpu, "props");
g_assert(qdict_haskey(props, "node-id"));
node = qdict_get_int(props, "node-id");

6
tests/qtest/qmp-test.c
View File

@ -252,7 +252,7 @@ static void test_qmp_oob(void)
* Try any command that does not support OOB but with OOB flag. We
* should get failure.
*/
resp = qtest_qmp(qts, "{ 'exec-oob': 'query-cpus' }");
resp = qtest_qmp(qts, "{ 'exec-oob': 'query-cpus-fast' }");
g_assert(qdict_haskey(resp, "error"));
qobject_unref(resp);
@ -289,7 +289,7 @@ static void test_qmp_preconfig(void)
g_assert(!qmp_rsp_is_err(qtest_qmp(qs, "{ 'execute': 'query-commands' }")));
/* forbidden commands, expected error */
g_assert(qmp_rsp_is_err(qtest_qmp(qs, "{ 'execute': 'query-cpus' }")));
g_assert(qmp_rsp_is_err(qtest_qmp(qs, "{ 'execute': 'query-cpus-fast' }")));
/* check that query-status returns preconfig state */
rsp = qtest_qmp(qs, "{ 'execute': 'query-status' }");
@ -313,7 +313,7 @@ static void test_qmp_preconfig(void)
g_assert(qmp_rsp_is_err(qtest_qmp(qs, "{ 'execute': 'x-exit-preconfig' }")));
/* enabled commands, no error expected */
g_assert(!qmp_rsp_is_err(qtest_qmp(qs, "{ 'execute': 'query-cpus' }")));
g_assert(!qmp_rsp_is_err(qtest_qmp(qs, "{ 'execute': 'query-cpus-fast' }")));
qtest_quit(qs);
}

6
tests/qtest/test-hmp.c
View File

@ -45,9 +45,9 @@ static const char *hmp_cmds[] = {
"log all",
"log none",
"memsave 0 4096 \"/dev/null\"",
"migrate_set_cache_size 1",
"migrate_set_downtime 1",
"migrate_set_speed 1",
"migrate_set_parameter xbzrle_cache_size 1",
"migrate_set_parameter downtime_limit 1",
"migrate_set_parameter max_bandwidth 1",
"netdev_add user,id=net1",
"set_link net1 off",
"set_link net1 on",

4
tests/qtest/test-x86-cpuid-compat.c
View File

@ -13,12 +13,12 @@ static char *get_cpu0_qom_path(void)
QDict *cpu0;
char *path;
resp = qmp("{'execute': 'query-cpus', 'arguments': {}}");
resp = qmp("{'execute': 'query-cpus-fast', 'arguments': {}}");
g_assert(qdict_haskey(resp, "return"));
ret = qdict_get_qlist(resp, "return");
cpu0 = qobject_to(QDict, qlist_peek(ret));
path = g_strdup(qdict_get_str(cpu0, "qom_path"));
path = g_strdup(qdict_get_str(cpu0, "qom-path"));
qobject_unref(resp);
return path;
}

8
tests/qtest/vhost-user-test.c
View File

@ -756,8 +756,8 @@ static void test_migrate(void *obj, void *arg, QGuestAllocator *alloc)
/* slow down migration to have time to fiddle with log */
/* TODO: qtest could learn to break on some places */
rsp = qmp("{ 'execute': 'migrate_set_speed',"
"'arguments': { 'value': 10 } }");
rsp = qmp("{ 'execute': 'migrate-set-parameters',"
"'arguments': { 'max-bandwidth': 10 } }");
g_assert(qdict_haskey(rsp, "return"));
qobject_unref(rsp);
@ -776,8 +776,8 @@ static void test_migrate(void *obj, void *arg, QGuestAllocator *alloc)
munmap(log, size);
/* speed things up */
rsp = qmp("{ 'execute': 'migrate_set_speed',"
"'arguments': { 'value': 0 } }");
rsp = qmp("{ 'execute': 'migrate-set-parameters',"
"'arguments': { 'max-bandwidth': 0 } }");
g_assert(qdict_haskey(rsp, "return"));
qobject_unref(rsp);

38
ui/vnc.c
View File

@ -3507,9 +3507,6 @@ static QemuOptsList qemu_vnc_opts = {
},{
.name = "sasl",
.type = QEMU_OPT_BOOL,
},{
.name = "acl",
.type = QEMU_OPT_BOOL,
},{
.name = "tls-authz",
.type = QEMU_OPT_STRING,
@ -3961,7 +3958,6 @@ void vnc_display_open(const char *id, Error **errp)
bool reverse = false;
const char *credid;
bool sasl = false;
int acl = 0;
const char *tlsauthz;
const char *saslauthz;
int lock_key_sync = 1;
@ -4053,29 +4049,13 @@ void vnc_display_open(const char *id, Error **errp)
goto fail;
}
}
if (qemu_opt_get(opts, "acl")) {
error_report("The 'acl' option to -vnc is deprecated. "
"Please use the 'tls-authz' and 'sasl-authz' "
"options instead");
}
acl = qemu_opt_get_bool(opts, "acl", false);
tlsauthz = qemu_opt_get(opts, "tls-authz");
if (acl && tlsauthz) {
error_setg(errp, "'acl' option is mutually exclusive with the "
"'tls-authz' option");
goto fail;
}
if (tlsauthz && !vd->tlscreds) {
error_setg(errp, "'tls-authz' provided but TLS is not enabled");
goto fail;
}
saslauthz = qemu_opt_get(opts, "sasl-authz");
if (acl && saslauthz) {
error_setg(errp, "'acl' option is mutually exclusive with the "
"'sasl-authz' option");
goto fail;
}
if (saslauthz && !sasl) {
error_setg(errp, "'sasl-authz' provided but SASL auth is not enabled");
goto fail;
@ -4113,29 +4093,11 @@ void vnc_display_open(const char *id, Error **errp)
if (tlsauthz) {
vd->tlsauthzid = g_strdup(tlsauthz);
} else if (acl) {
if (strcmp(vd->id, "default") == 0) {
vd->tlsauthzid = g_strdup("vnc.x509dname");
} else {
vd->tlsauthzid = g_strdup_printf("vnc.%s.x509dname", vd->id);
}
vd->tlsauthz = QAUTHZ(qauthz_list_new(vd->tlsauthzid,
QAUTHZ_LIST_POLICY_DENY,
&error_abort));
}
#ifdef CONFIG_VNC_SASL
if (sasl) {
if (saslauthz) {
vd->sasl.authzid = g_strdup(saslauthz);
} else if (acl) {
if (strcmp(vd->id, "default") == 0) {
vd->sasl.authzid = g_strdup("vnc.username");
} else {
vd->sasl.authzid = g_strdup_printf("vnc.%s.username", vd->id);
}
vd->sasl.authz = QAUTHZ(qauthz_list_new(vd->sasl.authzid,
QAUTHZ_LIST_POLICY_DENY,
&error_abort));
}
}
#endif