mirror of https://gitee.com/openkylin/qemu.git
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:
commit
1b507e55f8
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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:
|
||||
|
||||
|
|
|
@ -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
|
||||
------------------------
|
||||
|
||||
|
|
|
@ -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
|
||||
----------------
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
121
hmp-commands.hx
|
@ -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",
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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" },
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
@ -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");
|
||||
}
|
||||
|
|
|
@ -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");
|
||||
}
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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");
|
||||
}
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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().
|
||||
|
|
|
@ -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
187
monitor/misc.c
|
@ -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();
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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:
|
||||
#
|
||||
|
|
|
@ -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
|
||||
#
|
||||
|
|
|
@ -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:
|
||||
#
|
||||
|
|
|
@ -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, \
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 },
|
||||
|
|
|
@ -32,4 +32,4 @@ def test_no_die_id(self):
|
|||
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)
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -110,7 +110,7 @@ def _migrate(self, hardware, scenario, src, dst, connect_uri):
|
|||
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 @@ def _migrate(self, hardware, scenario, src, dst, connect_uri):
|
|||
"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 @@ def _migrate(self, hardware, scenario, src, dst, connect_uri):
|
|||
{ "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)
|
||||
|
||||
|
|
|
@ -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
|
||||
;;
|
||||
*)
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
}))
|
||||
|
|
|
@ -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)"
|
||||
|
|
|
@ -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://"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
|
@ -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"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
|
@ -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'])
|
||||
|
|
|
@ -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}]
|
||||
|
|
|
@ -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
|
||||
|
||||
|
|
|
@ -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, \
|
||||
|
|
|
@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
|
@ -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, \
|
||||
|
|
|
@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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
|
||||
}
|
||||
]
|
||||
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -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:
|
||||
|
|
|
@ -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"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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");
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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",
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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
38
ui/vnc.c
|
@ -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
|
||||
|
|
Loading…
Reference in New Issue