7:47 a.m.
V2 -> V3:
reorganize patchset to fix compile warning
V1 -> V2:
replace QEMU_JOB_ASYNC with QEMU_JOB_QUERY
Sometimes domain's memory dirty rate is expected by user in order to
decide whether it's proper to be migrated out or not.
We have already completed the QEMU part of the capability:
https://patchew.org/QEMU/1600237327-33618-1-git-send-email-zhengchuan@hua...
And this serial of patches introduce the corresponding LIBVIRT part --
DomainGetDirtyRateInfo API and corresponding virsh api -- "getdirtyrate".
instructions:
bash# virsh getdirtyrate --help
NAME
getdirtyrate - Get a vm's memory dirty rate
SYNOPSIS
getdirtyrate <domain> [--seconds <number>] [--calculate] [--query]
DESCRIPTION
Get memory dirty rate of a domain in order to decide whether it's proper to be
migrated out or not.
OPTIONS
[--domain] <string> domain name, id or uuid
--seconds <number> calculate memory dirty rate within specified seconds, a
valid range of values is [1, 60], and would default to 1s.
--calculate calculate dirty rate only, can be used together with --query, either
or both is expected, otherwise would default to both.
--query query dirty rate only, can be used together with --calculate, either
or both is expected, otherwise would default to both.
example:
bash# virsh getdirtyrate --calculate --query --domain vm0 --seconds 1
status: measured
startTime: 820148
calcTime: 1 s
dirtyRate: 6 MB/s
Hao Wang (7):
migration/dirtyrate: Introduce virDomainDirtyRateInfo structure
migration/dirtyrate: set up framwork of domainGetDirtyRateInfo API
migration/dirtyrate: Implement qemuDomainGetDirtyRateInfo
migration/dirtyrate: Implement qemuDomainCalculateDirtyRate
migration/dirtyrate: Implement qemuDomainCalculateDirtyRate
migration/dirtyrate: Implement qemuMonitorJSONExtractDirtyRateInfo
migration/dirtyrate: Introduce getdirtyrate virsh api
include/libvirt/libvirt-domain.h | 56 ++++++++++++++++
src/driver-hypervisor.h | 7 ++
src/libvirt-domain.c | 46 +++++++++++++
src/libvirt_public.syms | 5 ++
src/qemu/qemu_driver.c | 67 ++++++++++++++++++
src/qemu/qemu_migration.c | 59 ++++++++++++++++
src/qemu/qemu_migration.h | 10 +++
src/qemu/qemu_monitor.c | 24 +++++++
src/qemu/qemu_monitor.h | 8 +++
src/qemu/qemu_monitor_json.c | 97 ++++++++++++++++++++++++++
src/qemu/qemu_monitor_json.h | 8 +++
src/remote/remote_driver.c | 1 +
src/remote/remote_protocol.x | 21 +++++-
tools/virsh-domain.c | 112 +++++++++++++++++++++++++++++++
14 files changed, 520 insertions(+), 1 deletion(-)
--
2.23.0
7:47 a.m.
New subject: [PATCH v3 1/7] migration/dirtyrate: Introduce virDomainDirtyRateInfo structure
Introduce virDomainDirtyRateInfo structure used for domain's memory dirty rate query.
Signed-off-by: Hao Wang <wanghao232(a)huawei.com>
Reviewed-by: Chuan Zheng <zhengchuan(a)huawei.com>
---
include/libvirt/libvirt-domain.h | 24 ++++++++++++++++++++++++
1 file changed, 24 insertions(+)
diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h
index b3310729bf..145f517068 100644
--- a/include/libvirt/libvirt-domain.h
+++ b/include/libvirt/libvirt-domain.h
@@ -5096,4 +5096,28 @@ int virDomainBackupBegin(virDomainPtr domain,
char *virDomainBackupGetXMLDesc(virDomainPtr domain,
unsigned int flags);
+/**
+ * virDomainDirtyRateInfo:
+ *
+ * a virDomainDirtyRateInfo is a structure filled by virDomainGetDirtyRate() and
+ * extracting dirty rate infomation for a given active Domain.
+ */
+
+typedef struct _virDomainDirtyRateInfo virDomainDirtyRateInfo;
+
+struct _virDomainDirtyRateInfo {
+ int status; /* the status of dirtyrate calculation */
+ long long dirtyRate; /* the dirtyrate in MB/s */
+ long long startTime; /* the start time of dirtyrate calculation */
+ long long calcTime; /* the period of dirtyrate calculation */
+};
+
+/**
+ * virDomainDirtyRateInfoPtr:
+ *
+ * a virDomainDirtyRateInfoPtr is a pointer to a virDomainDirtyRateInfo structure.
+ */
+
+typedef virDomainDirtyRateInfo *virDomainDirtyRateInfoPtr;
+
#endif /* LIBVIRT_DOMAIN_H */
--
2.23.0
7:47 a.m.
New subject: [PATCH v3 2/7] migration/dirtyrate: set up framwork of domainGetDirtyRateInfo API
Introduce DomainGetDirtyRateInfo API for domain's memory dirty rate
calculation and query.
Signed-off-by: Hao Wang <wanghao232(a)huawei.com>
Signed-off-by: Zhou Yimin <zhouyimin(a)huawei.com>
Reviewed-by: Chuan Zheng <zhengchuan(a)huawei.com>
---
include/libvirt/libvirt-domain.h | 5 ++++
src/driver-hypervisor.h | 7 +++++
src/libvirt-domain.c | 46 ++++++++++++++++++++++++++++++++
src/libvirt_public.syms | 5 ++++
src/qemu/qemu_driver.c | 12 +++++++++
src/remote/remote_driver.c | 1 +
src/remote/remote_protocol.x | 21 ++++++++++++++-
7 files changed, 96 insertions(+), 1 deletion(-)
diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h
index 145f517068..1c63191baa 100644
--- a/include/libvirt/libvirt-domain.h
+++ b/include/libvirt/libvirt-domain.h
@@ -5120,4 +5120,9 @@ struct _virDomainDirtyRateInfo {
typedef virDomainDirtyRateInfo *virDomainDirtyRateInfoPtr;
+int virDomainGetDirtyRateInfo(virDomainPtr domain,
+ virDomainDirtyRateInfoPtr info,
+ long long sec,
+ int flags);
+
#endif /* LIBVIRT_DOMAIN_H */
diff --git a/src/driver-hypervisor.h b/src/driver-hypervisor.h
index bce023017d..dc2aefa910 100644
--- a/src/driver-hypervisor.h
+++ b/src/driver-hypervisor.h
@@ -1387,6 +1387,12 @@ typedef char *
(*virDrvDomainBackupGetXMLDesc)(virDomainPtr domain,
unsigned int flags);
+typedef int
+(*virDrvDomainGetDirtyRateInfo)(virDomainPtr domain,
+ virDomainDirtyRateInfoPtr info,
+ long long sec,
+ int flags);
+
typedef struct _virHypervisorDriver virHypervisorDriver;
typedef virHypervisorDriver *virHypervisorDriverPtr;
@@ -1650,4 +1656,5 @@ struct _virHypervisorDriver {
virDrvDomainAgentSetResponseTimeout domainAgentSetResponseTimeout;
virDrvDomainBackupBegin domainBackupBegin;
virDrvDomainBackupGetXMLDesc domainBackupGetXMLDesc;
+ virDrvDomainGetDirtyRateInfo domainGetDirtyRateInfo;
};
diff --git a/src/libvirt-domain.c b/src/libvirt-domain.c
index 3c5f55176a..8714c1ca93 100644
--- a/src/libvirt-domain.c
+++ b/src/libvirt-domain.c
@@ -12758,3 +12758,49 @@ virDomainBackupGetXMLDesc(virDomainPtr domain,
virDispatchError(conn);
return NULL;
}
+
+
+/**
+ * virDomainGetDirtyRateInfo:
+ * @domain: a domain object.
+ * @info: return value of current domain's memory dirty rate info.
+ * @sec: show dirty rate within specified seconds.
+ * @flags: the flags of getdirtyrate action -- calculate and/or query.
+ *
+ * Get the current domain's memory dirty rate (in MB/s).
+ *
+ * Returns 0 in case of success, -1 otherwise.
+ */
+int
+virDomainGetDirtyRateInfo(virDomainPtr domain,
+ virDomainDirtyRateInfoPtr info,
+ long long sec,
+ int flags)
+{
+ virConnectPtr conn;
+
+ VIR_DOMAIN_DEBUG(domain, "info = %p, seconds=%lld", info, sec);
+
+ virResetLastError();
+
+ virCheckDomainReturn(domain, -1);
+ conn = domain->conn;
+
+ virCheckNonNullArgGoto(info, error);
+ virCheckReadOnlyGoto(conn->flags, error);
+
+ if (info)
+ memset(info, 0, sizeof(*info));
+
+ if (conn->driver->domainGetDirtyRateInfo) {
+ if (conn->driver->domainGetDirtyRateInfo(domain, info, sec, flags) < 0)
+ goto error;
+ VIR_DOMAIN_DEBUG(domain, "info = %p, seconds=%lld", info, sec);
+ return 0;
+ }
+
+ virReportUnsupportedError();
+ error:
+ virDispatchError(conn);
+ return -1;
+}
diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms
index 539d2e3943..11864f48b1 100644
--- a/src/libvirt_public.syms
+++ b/src/libvirt_public.syms
@@ -873,4 +873,9 @@ LIBVIRT_6.0.0 {
virDomainBackupGetXMLDesc;
} LIBVIRT_5.10.0;
+LIBVIRT_6.9.0 {
+ global:
+ virDomainGetDirtyRateInfo;
+} LIBVIRT_6.0.0;
+
# .... define new API here using predicted next version number ....
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index f1191c1210..513290c934 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -20123,6 +20123,17 @@ qemuDomainAgentSetResponseTimeout(virDomainPtr dom,
}
+static int
+qemuDomainGetDirtyRateInfo(virDomainPtr dom,
+ virDomainDirtyRateInfoPtr info,
+ long long sec,
+ int flags)
+{
+ /* TODO */
+ return 0;
+}
+
+
static virHypervisorDriver qemuHypervisorDriver = {
.name = QEMU_DRIVER_NAME,
.connectURIProbe = qemuConnectURIProbe,
@@ -20362,6 +20373,7 @@ static virHypervisorDriver qemuHypervisorDriver = {
.domainAgentSetResponseTimeout = qemuDomainAgentSetResponseTimeout, /* 5.10.0 */
.domainBackupBegin = qemuDomainBackupBegin, /* 6.0.0 */
.domainBackupGetXMLDesc = qemuDomainBackupGetXMLDesc, /* 6.0.0 */
+ .domainGetDirtyRateInfo = qemuDomainGetDirtyRateInfo, /* 6.9.0 */
};
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 9cd2fd36ae..325968a22b 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -8458,6 +8458,7 @@ static virHypervisorDriver hypervisor_driver = {
.domainAgentSetResponseTimeout = remoteDomainAgentSetResponseTimeout, /* 5.10.0 */
.domainBackupBegin = remoteDomainBackupBegin, /* 6.0.0 */
.domainBackupGetXMLDesc = remoteDomainBackupGetXMLDesc, /* 6.0.0 */
+ .domainGetDirtyRateInfo = remoteDomainGetDirtyRateInfo, /* 6.9.0 */
};
static virNetworkDriver network_driver = {
diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index 5e5e781e76..3838383bc9 100644
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -3779,6 +3779,19 @@ struct remote_domain_backup_get_xml_desc_ret {
remote_nonnull_string xml;
};
+struct remote_domain_get_dirty_rate_info_args {
+ remote_nonnull_domain dom;
+ hyper sec;
+ int flags;
+};
+
+struct remote_domain_get_dirty_rate_info_ret { /* insert@1 */
+ int status;
+ hyper dirtyRate;
+ hyper startTime;
+ hyper calcTime;
+};
+
/*----- Protocol. -----*/
/* Define the program number, protocol version and procedure numbers here. */
@@ -6682,5 +6695,11 @@ enum remote_procedure {
* @generate: both
* @acl: none
*/
- REMOTE_PROC_DOMAIN_EVENT_MEMORY_FAILURE = 423
+ REMOTE_PROC_DOMAIN_EVENT_MEMORY_FAILURE = 423,
+
+ /**
+ * @generate: both
+ * @acl: domain:read
+ */
+ REMOTE_PROC_DOMAIN_GET_DIRTY_RATE_INFO = 424
};
--
2.23.0
2:14 p.m.
New subject: [PATCH v3 2/7] migration/dirtyrate: set up framwork of domainGetDirtyRateInfo API
On 10/27/20 9:47 AM, Hao Wang wrote:
Introduce DomainGetDirtyRateInfo API for domain's memory dirty
rate
calculation and query.
Signed-off-by: Hao Wang <wanghao232(a)huawei.com>
Signed-off-by: Zhou Yimin <zhouyimin(a)huawei.com>
Reviewed-by: Chuan Zheng <zhengchuan(a)huawei.com>
---
This patch does not compile/test successfully in my env. There are
at least 2 things going wrong here:
- the stub you added in qemu_driver.c is generating compile warnings:
../src/qemu/qemu_driver.c: In function ‘qemuDomainGetDirtyRateInfo’:
../src/qemu/qemu_driver.c:20127:41: error: unused parameter ‘dom’
[-Werror=unused-parameter]
20127 | qemuDomainGetDirtyRateInfo(virDomainPtr dom,
| ~~~~~~~~~~~~~^~~
../src/qemu/qemu_driver.c:20128:54: error: unused parameter ‘info’
[-Werror=unused-parameter]
20128 | virDomainDirtyRateInfoPtr info,
| ~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~
../src/qemu/qemu_driver.c:20129:38: error: unused parameter ‘sec’
[-Werror=unused-parameter]
20129 | long long sec,
| ~~~~~~~~~~^~~
../src/qemu/qemu_driver.c:20130:32: error: unused parameter ‘flags’
[-Werror=unused-parameter]
20130 |
This is the code:
static int
qemuDomainGetDirtyRateInfo(virDomainPtr dom,
virDomainDirtyRateInfoPtr info,
long long sec,
int flags)
{
/* TODO */
return 0;
}
I don't think you need this placeholder here. You're not using the
domainGetDirtyRateInfo
API anywhere in this patch, so just move this code to patch 03 where the
function is implemented.
After fixing it myself and compiling it again I found another issue:
--- command ---
17:56:04 LC_CTYPE='en_US.UTF-8' LC_ALL='' LANG='C'
/usr/bin/python3 /home/danielhb/kvm-project/libvirt/scripts/check-remote-protocol.py
remote_protocol virt_remote_driver
/home/danielhb/kvm-project/libvirt/build/src/remote/libvirt_remote_driver.a
/usr/bin/pdwtags /home/danielhb/kvm-project/libvirt/build/../src/remote_protocol-structs
--- stdout ---
--- /home/danielhb/kvm-project/libvirt/build/../src/remote_protocol-structs 2020-10-23
08:48:53.871557535 -0300
+++ - 2020-10-27 14:56:04.587438336 -0300
@@ -3142,6 +3142,17 @@
struct remote_domain_backup_get_xml_desc_ret {
remote_nonnull_string xml;
};
+struct remote_domain_get_dirty_rate_info_args {
+ remote_nonnull_domain dom;
+ int64_t sec;
+ int flags;
+};
+struct remote_domain_get_dirty_rate_info_ret {
+ int status;
+ int64_t dirtyRate;
+ int64_t startTime;
+ int64_t calcTime;
+};
enum remote_procedure {
REMOTE_PROC_CONNECT_OPEN = 1,
REMOTE_PROC_CONNECT_CLOSE = 2,
@@ -3566,4 +3577,5 @@
REMOTE_PROC_DOMAIN_BACKUP_BEGIN = 421,
REMOTE_PROC_DOMAIN_BACKUP_GET_XML_DESC = 422,
REMOTE_PROC_DOMAIN_EVENT_MEMORY_FAILURE = 423,
+ REMOTE_PROC_DOMAIN_GET_DIRTY_RATE_INFO = 424,
};
-------
152/307 libvirt:syntax-check / sc_flags_usage FAIL
2.75s (exit status 2)
--- command ---
17:56:11 /usr/bin/make -C /home/danielhb/kvm-project/libvirt/build/build-aux
sc_flags_usage
--- stdout ---
make: Entering directory '/home/danielhb/kvm-project/libvirt/build/build-aux'
flags_usage
/home/danielhb/kvm-project/libvirt/include/libvirt/libvirt-domain.h:5126:
int flags);
/home/danielhb/kvm-project/libvirt/src/driver-hypervisor.h:1394:
int flags);
/home/danielhb/kvm-project/libvirt/src/libvirt-domain.c:12778:
int flags)
/home/danielhb/kvm-project/libvirt/src/remote/remote_protocol.x:3785: int flags;
make: Leaving directory '/home/danielhb/kvm-project/libvirt/build/build-aux'
--- stderr ---
build-aux/syntax-check.mk: flags should be unsigned
make: *** [/home/danielhb/kvm-project/libvirt/build-aux/syntax-check.mk:342:
sc_flags_usage] Error 1
-------
From the error message I believe it has to do with 'flags' being an int
instead of unsigned int. This changes goes back to patch 1, where you introduced
the virDomainDirtyRateInfo. You'll need to change the flag type to unsigned
int in both patches 1 and 2, regenerated the protocol files and see if you
get the tests passed.
And for the record, what I'm doing to compile/test the patches is
$ ninja -C build test
Thanks,
DHB
include/libvirt/libvirt-domain.h | 5 ++++
src/driver-hypervisor.h | 7 +++++
src/libvirt-domain.c | 46 ++++++++++++++++++++++++++++++++
src/libvirt_public.syms | 5 ++++
src/qemu/qemu_driver.c | 12 +++++++++
src/remote/remote_driver.c | 1 +
src/remote/remote_protocol.x | 21 ++++++++++++++-
7 files changed, 96 insertions(+), 1 deletion(-)
diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h
index 145f517068..1c63191baa 100644
--- a/include/libvirt/libvirt-domain.h
+++ b/include/libvirt/libvirt-domain.h
@@ -5120,4 +5120,9 @@ struct _virDomainDirtyRateInfo {
typedef virDomainDirtyRateInfo *virDomainDirtyRateInfoPtr;
+int virDomainGetDirtyRateInfo(virDomainPtr domain,
+ virDomainDirtyRateInfoPtr info,
+ long long sec,
+ int flags);
+
#endif /* LIBVIRT_DOMAIN_H */
diff --git a/src/driver-hypervisor.h b/src/driver-hypervisor.h
index bce023017d..dc2aefa910 100644
--- a/src/driver-hypervisor.h
+++ b/src/driver-hypervisor.h
@@ -1387,6 +1387,12 @@ typedef char *
(*virDrvDomainBackupGetXMLDesc)(virDomainPtr domain,
unsigned int flags);
+typedef int
+(*virDrvDomainGetDirtyRateInfo)(virDomainPtr domain,
+ virDomainDirtyRateInfoPtr info,
+ long long sec,
+ int flags);
+
typedef struct _virHypervisorDriver virHypervisorDriver;
typedef virHypervisorDriver *virHypervisorDriverPtr;
@@ -1650,4 +1656,5 @@ struct _virHypervisorDriver {
virDrvDomainAgentSetResponseTimeout domainAgentSetResponseTimeout;
virDrvDomainBackupBegin domainBackupBegin;
virDrvDomainBackupGetXMLDesc domainBackupGetXMLDesc;
+ virDrvDomainGetDirtyRateInfo domainGetDirtyRateInfo;
};
diff --git a/src/libvirt-domain.c b/src/libvirt-domain.c
index 3c5f55176a..8714c1ca93 100644
--- a/src/libvirt-domain.c
+++ b/src/libvirt-domain.c
@@ -12758,3 +12758,49 @@ virDomainBackupGetXMLDesc(virDomainPtr domain,
virDispatchError(conn);
return NULL;
}
+
+
+/**
+ * virDomainGetDirtyRateInfo:
+ * @domain: a domain object.
+ * @info: return value of current domain's memory dirty rate info.
+ * @sec: show dirty rate within specified seconds.
+ * @flags: the flags of getdirtyrate action -- calculate and/or query.
+ *
+ * Get the current domain's memory dirty rate (in MB/s).
+ *
+ * Returns 0 in case of success, -1 otherwise.
+ */
+int
+virDomainGetDirtyRateInfo(virDomainPtr domain,
+ virDomainDirtyRateInfoPtr info,
+ long long sec,
+ int flags)
+{
+ virConnectPtr conn;
+
+ VIR_DOMAIN_DEBUG(domain, "info = %p, seconds=%lld", info, sec);
+
+ virResetLastError();
+
+ virCheckDomainReturn(domain, -1);
+ conn = domain->conn;
+
+ virCheckNonNullArgGoto(info, error);
+ virCheckReadOnlyGoto(conn->flags, error);
+
+ if (info)
+ memset(info, 0, sizeof(*info));
+
+ if (conn->driver->domainGetDirtyRateInfo) {
+ if (conn->driver->domainGetDirtyRateInfo(domain, info, sec, flags) <
0)
+ goto error;
+ VIR_DOMAIN_DEBUG(domain, "info = %p, seconds=%lld", info, sec);
+ return 0;
+ }
+
+ virReportUnsupportedError();
+ error:
+ virDispatchError(conn);
+ return -1;
+}
diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms
index 539d2e3943..11864f48b1 100644
--- a/src/libvirt_public.syms
+++ b/src/libvirt_public.syms
@@ -873,4 +873,9 @@ LIBVIRT_6.0.0 {
virDomainBackupGetXMLDesc;
} LIBVIRT_5.10.0;
+LIBVIRT_6.9.0 {
+ global:
+ virDomainGetDirtyRateInfo;
+} LIBVIRT_6.0.0;
+
# .... define new API here using predicted next version number ....
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index f1191c1210..513290c934 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -20123,6 +20123,17 @@ qemuDomainAgentSetResponseTimeout(virDomainPtr dom,
}
+static int
+qemuDomainGetDirtyRateInfo(virDomainPtr dom,
+ virDomainDirtyRateInfoPtr info,
+ long long sec,
+ int flags)
+{
+ /* TODO */
+ return 0;
+}
+
+
static virHypervisorDriver qemuHypervisorDriver = {
.name = QEMU_DRIVER_NAME,
.connectURIProbe = qemuConnectURIProbe,
@@ -20362,6 +20373,7 @@ static virHypervisorDriver qemuHypervisorDriver = {
.domainAgentSetResponseTimeout = qemuDomainAgentSetResponseTimeout, /* 5.10.0 */
.domainBackupBegin = qemuDomainBackupBegin, /* 6.0.0 */
.domainBackupGetXMLDesc = qemuDomainBackupGetXMLDesc, /* 6.0.0 */
+ .domainGetDirtyRateInfo = qemuDomainGetDirtyRateInfo, /* 6.9.0 */
};
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 9cd2fd36ae..325968a22b 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -8458,6 +8458,7 @@ static virHypervisorDriver hypervisor_driver = {
.domainAgentSetResponseTimeout = remoteDomainAgentSetResponseTimeout, /* 5.10.0 */
.domainBackupBegin = remoteDomainBackupBegin, /* 6.0.0 */
.domainBackupGetXMLDesc = remoteDomainBackupGetXMLDesc, /* 6.0.0 */
+ .domainGetDirtyRateInfo = remoteDomainGetDirtyRateInfo, /* 6.9.0 */
};
static virNetworkDriver network_driver = {
diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index 5e5e781e76..3838383bc9 100644
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -3779,6 +3779,19 @@ struct remote_domain_backup_get_xml_desc_ret {
remote_nonnull_string xml;
};
+struct remote_domain_get_dirty_rate_info_args {
+ remote_nonnull_domain dom;
+ hyper sec;
+ int flags;
+};
+
+struct remote_domain_get_dirty_rate_info_ret { /* insert@1 */
+ int status;
+ hyper dirtyRate;
+ hyper startTime;
+ hyper calcTime;
+};
+
/*----- Protocol. -----*/
/* Define the program number, protocol version and procedure numbers here. */
@@ -6682,5 +6695,11 @@ enum remote_procedure {
* @generate: both
* @acl: none
*/
- REMOTE_PROC_DOMAIN_EVENT_MEMORY_FAILURE = 423
+ REMOTE_PROC_DOMAIN_EVENT_MEMORY_FAILURE = 423,
+
+ /**
+ * @generate: both
+ * @acl: domain:read
+ */
+ REMOTE_PROC_DOMAIN_GET_DIRTY_RATE_INFO = 424
};
8:50 p.m.
New subject: [PATCH v3 2/7] migration/dirtyrate: set up framwork of domainGetDirtyRateInfo API
Greate thanks for your suggestions, Daniel. I'll fix that and update my patchset
later.
BR,
Hao
On 2020/10/28 3:14, Daniel Henrique Barboza wrote:
This patch does not compile/test successfully in my env. There are
at least 2 things going wrong here:
7:47 a.m.
New subject: [PATCH v3 3/7] migration/dirtyrate: Implement qemuDomainGetDirtyRateInfo
Implement qemuDomainGetDirtyRateInfo:
using flags to control behaviors -- calculate and/or query dirtyrate.
Signed-off-by: Hao Wang <wanghao232(a)huawei.com>
Reviewed-by: Chuan Zheng <zhengchuan(a)huawei.com>
---
include/libvirt/libvirt-domain.h | 11 +++++++
src/qemu/qemu_driver.c | 51 ++++++++++++++++++++++++++++++--
2 files changed, 60 insertions(+), 2 deletions(-)
diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h
index 1c63191baa..5801ca0f86 100644
--- a/include/libvirt/libvirt-domain.h
+++ b/include/libvirt/libvirt-domain.h
@@ -5096,6 +5096,17 @@ int virDomainBackupBegin(virDomainPtr domain,
char *virDomainBackupGetXMLDesc(virDomainPtr domain,
unsigned int flags);
+/**
+ * virDomainDirtyRateFlags:
+ *
+ * Details on the flags used by getdirtyrate api.
+ */
+
+typedef enum {
+ VIR_DOMAIN_DIRTYRATE_CALC = 1 << 0, /* calculate domain's dirtyrate */
+ VIR_DOMAIN_DIRTYRATE_QUERY = 1 << 1, /* query domain's dirtyrate */
+} virDomainDirtyRateFlags;
+
/**
* virDomainDirtyRateInfo:
*
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 513290c934..a93f99f28a 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -20123,14 +20123,61 @@ qemuDomainAgentSetResponseTimeout(virDomainPtr dom,
}
+#define MIN_DIRTYRATE_CALCULATION_PERIOD 1 /* 1s */
+#define MAX_DIRTYRATE_CALCULATION_PERIOD 60 /* 60s */
+
static int
qemuDomainGetDirtyRateInfo(virDomainPtr dom,
virDomainDirtyRateInfoPtr info,
long long sec,
int flags)
{
- /* TODO */
- return 0;
+ virDomainObjPtr vm = NULL;
+ virQEMUDriverPtr driver = dom->conn->privateData;
+ int ret = -1;
+
+ if (!(vm = qemuDomainObjFromDomain(dom)))
+ return ret;
+
+ if (virDomainGetDirtyRateInfoEnsureACL(dom->conn, vm->def) < 0)
+ goto cleanup;
+
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0)
+ goto cleanup;
+
+ if (!qemuMigrationSrcIsAllowed(driver, vm, false, 0))
+ goto endjob;
+
+ if (flags & VIR_DOMAIN_DIRTYRATE_CALC) {
+ if (sec < MIN_DIRTYRATE_CALCULATION_PERIOD || sec >
MAX_DIRTYRATE_CALCULATION_PERIOD) {
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+ "seconds=%lld is invalid, please choose value within [1,
60].", sec);
+ goto endjob;
+ }
+
+ /* TODO: call calc-dirty-rate for dirtyrate calculating */
+ }
+
+ if (flags & VIR_DOMAIN_DIRTYRATE_QUERY) {
+ if (flags & VIR_DOMAIN_DIRTYRATE_CALC) {
+ struct timespec ts = { .tv_sec = sec, .tv_nsec = 50 * 1000 * 1000ull };
+
+ virObjectUnlock(vm);
+ nanosleep(&ts, NULL);
+ virObjectLock(vm);
+ }
+
+ /* TODO: call query-dirty-rate for dirtyrate querying */
+ }
+
+ ret = 0;
+
+ endjob:
+ qemuDomainObjEndJob(driver, vm);
+
+ cleanup:
+ virDomainObjEndAPI(&vm);
+ return ret;
}
--
2.23.0
7:47 a.m.
New subject: [PATCH v3 4/7] migration/dirtyrate: Implement qemuDomainCalculateDirtyRate
Implement qemuDomainCalculateDirtyRate which calculates domain's memory
dirty rate calling qmp "calc-dirty-rate".
Signed-off-by: Hao Wang <wanghao232(a)huawei.com>
Signed-off-by: Zhou Yimin <zhouyimin(a)huawei.com>
Reviewed-by: Chuan Zheng <zhengchuan(a)huawei.com>
---
src/qemu/qemu_driver.c | 6 +++++-
src/qemu/qemu_migration.c | 28 ++++++++++++++++++++++++++++
src/qemu/qemu_migration.h | 5 +++++
src/qemu/qemu_monitor.c | 12 ++++++++++++
src/qemu/qemu_monitor.h | 4 ++++
src/qemu/qemu_monitor_json.c | 22 ++++++++++++++++++++++
src/qemu/qemu_monitor_json.h | 4 ++++
7 files changed, 80 insertions(+), 1 deletion(-)
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index a93f99f28a..c84bd17b73 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -20155,7 +20155,11 @@ qemuDomainGetDirtyRateInfo(virDomainPtr dom,
goto endjob;
}
- /* TODO: call calc-dirty-rate for dirtyrate calculating */
+ if (qemuDomainCalculateDirtyRate(dom, vm, sec) < 0) {
+ virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+ _("can't calculate domain's dirty rate"));
+ goto endjob;
+ }
}
if (flags & VIR_DOMAIN_DIRTYRATE_QUERY) {
diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index 6f764b0c73..8029e24415 100644
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -5836,3 +5836,31 @@ qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver,
virHashFree(blockinfo);
return 0;
}
+
+
+int
+qemuDomainCalculateDirtyRate(virDomainPtr dom,
+ virDomainObjPtr vm,
+ long long sec)
+{
+ virQEMUDriverPtr driver = dom->conn->privateData;
+ qemuDomainObjPrivatePtr priv;
+ int ret = -1;
+
+ if (!virDomainObjIsActive(vm)) {
+ virReportError(VIR_ERR_OPERATION_INVALID,
+ "%s", _("domain is not running"));
+ return ret;
+ }
+
+ priv = vm->privateData;
+
+ VIR_DEBUG("Calculate dirty rate during %lld seconds", sec);
+ qemuDomainObjEnterMonitor(driver, vm);
+
+ ret = qemuMonitorCalculateDirtyRate(priv->mon, sec);
+ if (qemuDomainObjExitMonitor(driver, vm) < 0)
+ ret = -1;
+
+ return ret;
+}
diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h
index fd9eb7cab0..0522b375c0 100644
--- a/src/qemu/qemu_migration.h
+++ b/src/qemu/qemu_migration.h
@@ -258,3 +258,8 @@ qemuMigrationSrcFetchMirrorStats(virQEMUDriverPtr driver,
virDomainObjPtr vm,
qemuDomainAsyncJob asyncJob,
qemuDomainJobInfoPtr jobInfo);
+
+int
+qemuDomainCalculateDirtyRate(virDomainPtr dom,
+ virDomainObjPtr vm,
+ long long sec);
diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
index 5481bd99a0..06603b8691 100644
--- a/src/qemu/qemu_monitor.c
+++ b/src/qemu/qemu_monitor.c
@@ -4769,3 +4769,15 @@ qemuMonitorTransactionBackup(virJSONValuePtr actions,
return qemuMonitorJSONTransactionBackup(actions, device, jobname, target,
bitmap, syncmode);
}
+
+
+int
+qemuMonitorCalculateDirtyRate(qemuMonitorPtr mon,
+ long long sec)
+{
+ VIR_DEBUG("seconds=%lld", sec);
+
+ QEMU_CHECK_MONITOR(mon);
+
+ return qemuMonitorJSONCalculateDirtyRate(mon, sec);
+}
diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h
index 54fbb41ef7..afb97780cf 100644
--- a/src/qemu/qemu_monitor.h
+++ b/src/qemu/qemu_monitor.h
@@ -1527,3 +1527,7 @@ qemuMonitorTransactionBackup(virJSONValuePtr actions,
const char *target,
const char *bitmap,
qemuMonitorTransactionBackupSyncMode syncmode);
+
+int
+qemuMonitorCalculateDirtyRate(qemuMonitorPtr mon,
+ long long sec);
diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
index 843a555952..65691522fb 100644
--- a/src/qemu/qemu_monitor_json.c
+++ b/src/qemu/qemu_monitor_json.c
@@ -9635,3 +9635,25 @@ qemuMonitorJSONGetCPUMigratable(qemuMonitorPtr mon,
return virJSONValueGetBoolean(virJSONValueObjectGet(reply, "return"),
migratable);
}
+
+
+int
+qemuMonitorJSONCalculateDirtyRate(qemuMonitorPtr mon,
+ long long sec)
+{
+ g_autoptr(virJSONValue) cmd = NULL;
+ g_autoptr(virJSONValue) reply = NULL;
+
+ if (!(cmd = qemuMonitorJSONMakeCommand("calc-dirty-rate",
+ "I:calc-time", (long)sec,
+ NULL)))
+ return -1;
+
+ if (qemuMonitorJSONCommand(mon, cmd, &reply) < 0)
+ return -1;
+
+ if (qemuMonitorJSONCheckError(cmd, reply) < 0)
+ return -1;
+
+ return 0;
+}
diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h
index 38e23ef3c5..c9556fc19a 100644
--- a/src/qemu/qemu_monitor_json.h
+++ b/src/qemu/qemu_monitor_json.h
@@ -710,3 +710,7 @@ int qemuMonitorJSONSetDBusVMStateIdList(qemuMonitorPtr mon,
int
qemuMonitorJSONGetCPUMigratable(qemuMonitorPtr mon,
bool *migratable);
+
+int
+qemuMonitorJSONCalculateDirtyRate(qemuMonitorPtr mon,
+ long long sec);
--
2.23.0
7:47 a.m.
New subject: [PATCH v3 5/7] migration/dirtyrate: Implement qemuDomainCalculateDirtyRate
Implement qemuDomainCalculateDirtyRate which calculates domain's memory
dirty rate calling qmp "calc-dirty-rate".
Signed-off-by: Hao Wang <wanghao232(a)huawei.com>
Signed-off-by: Zhou Yimin <zhouyimin(a)huawei.com>
Reviewed-by: Chuan Zheng <zhengchuan(a)huawei.com>
---
src/qemu/qemu_driver.c | 6 +++++-
src/qemu/qemu_migration.c | 31 +++++++++++++++++++++++++++++++
src/qemu/qemu_migration.h | 5 +++++
src/qemu/qemu_monitor.c | 12 ++++++++++++
src/qemu/qemu_monitor.h | 4 ++++
src/qemu/qemu_monitor_json.c | 21 +++++++++++++++++++++
src/qemu/qemu_monitor_json.h | 4 ++++
7 files changed, 82 insertions(+), 1 deletion(-)
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index c84bd17b73..3d2a18a21f 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -20171,7 +20171,11 @@ qemuDomainGetDirtyRateInfo(virDomainPtr dom,
virObjectLock(vm);
}
- /* TODO: call query-dirty-rate for dirtyrate querying */
+ if (qemuDomainQueryDirtyRate(dom, vm, info) < 0) {
+ virReportError(VIR_ERR_OPERATION_FAILED, "%s",
+ _("can't query domain's dirty rate"));
+ goto endjob;
+ }
}
ret = 0;
diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index 8029e24415..3d07ba3ac4 100644
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -5864,3 +5864,34 @@ qemuDomainCalculateDirtyRate(virDomainPtr dom,
return ret;
}
+
+
+int
+qemuDomainQueryDirtyRate(virDomainPtr dom,
+ virDomainObjPtr vm,
+ virDomainDirtyRateInfoPtr info)
+{
+ virQEMUDriverPtr driver = dom->conn->privateData;
+ qemuDomainObjPrivatePtr priv;
+ int ret = -1;
+
+ if (!virDomainObjIsActive(vm)) {
+ virReportError(VIR_ERR_OPERATION_INVALID,
+ "%s", _("domain is not running"));
+ return ret;
+ }
+
+ priv = vm->privateData;
+
+ qemuDomainObjEnterMonitor(driver, vm);
+
+ ret = qemuMonitorQueryDirtyRate(priv->mon, info);
+ if (ret < 0) {
+ virReportError(VIR_ERR_OPERATION_FAILED,
+ "%s", _("get vm's dirty rate failed."));
+ }
+ if (qemuDomainObjExitMonitor(driver, vm) < 0)
+ ret = -1;
+
+ return ret;
+}
diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h
index 0522b375c0..8baae512b7 100644
--- a/src/qemu/qemu_migration.h
+++ b/src/qemu/qemu_migration.h
@@ -263,3 +263,8 @@ int
qemuDomainCalculateDirtyRate(virDomainPtr dom,
virDomainObjPtr vm,
long long sec);
+
+int
+qemuDomainQueryDirtyRate(virDomainPtr dom,
+ virDomainObjPtr vm,
+ virDomainDirtyRateInfoPtr info);
diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
index 06603b8691..2fa6879467 100644
--- a/src/qemu/qemu_monitor.c
+++ b/src/qemu/qemu_monitor.c
@@ -4781,3 +4781,15 @@ qemuMonitorCalculateDirtyRate(qemuMonitorPtr mon,
return qemuMonitorJSONCalculateDirtyRate(mon, sec);
}
+
+
+int
+qemuMonitorQueryDirtyRate(qemuMonitorPtr mon,
+ virDomainDirtyRateInfoPtr info)
+{
+ VIR_DEBUG("info=%p", info);
+
+ QEMU_CHECK_MONITOR(mon);
+
+ return qemuMonitorJSONQueryDirtyRate(mon, info);
+}
diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h
index afb97780cf..25105c3ad9 100644
--- a/src/qemu/qemu_monitor.h
+++ b/src/qemu/qemu_monitor.h
@@ -1531,3 +1531,7 @@ qemuMonitorTransactionBackup(virJSONValuePtr actions,
int
qemuMonitorCalculateDirtyRate(qemuMonitorPtr mon,
long long sec);
+
+int
+qemuMonitorQueryDirtyRate(qemuMonitorPtr mon,
+ virDomainDirtyRateInfoPtr info);
diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
index 65691522fb..a0616eae2c 100644
--- a/src/qemu/qemu_monitor_json.c
+++ b/src/qemu/qemu_monitor_json.c
@@ -9657,3 +9657,24 @@ qemuMonitorJSONCalculateDirtyRate(qemuMonitorPtr mon,
return 0;
}
+
+
+int
+qemuMonitorJSONQueryDirtyRate(qemuMonitorPtr mon,
+ virDomainDirtyRateInfoPtr info)
+{
+ g_autoptr(virJSONValue) cmd = NULL;
+ g_autoptr(virJSONValue) reply = NULL;
+
+ if (!(cmd = qemuMonitorJSONMakeCommand("query-dirty-rate", NULL)))
+ return -1;
+
+ if (qemuMonitorJSONCommand(mon, cmd, &reply) < 0)
+ return -1;
+
+ if (qemuMonitorJSONCheckError(cmd, reply) < 0)
+ return -1;
+
+ /* TODO: extract dirtyrate data from reply and store in virDomainDirtyRateInfoPtr */
+ return 0;
+}
diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h
index c9556fc19a..487f2e6e58 100644
--- a/src/qemu/qemu_monitor_json.h
+++ b/src/qemu/qemu_monitor_json.h
@@ -714,3 +714,7 @@ qemuMonitorJSONGetCPUMigratable(qemuMonitorPtr mon,
int
qemuMonitorJSONCalculateDirtyRate(qemuMonitorPtr mon,
long long sec);
+
+int
+qemuMonitorJSONQueryDirtyRate(qemuMonitorPtr mon,
+ virDomainDirtyRateInfoPtr info);
--
2.23.0
7:47 a.m.
New subject: [PATCH v3 6/7] migration/dirtyrate: Implement qemuMonitorJSONExtractDirtyRateInfo
Implement qemuMonitorJSONExtractDirtyRateInfo to deal with the return from
qmp "query-dirty-rate", and store them in virDomainDirtyRateInfo.
Signed-off-by: Hao Wang <wanghao232(a)huawei.com>
Reviewed-by: Chuan Zheng <zhengchuan(a)huawei.com>
---
include/libvirt/libvirt-domain.h | 16 +++++++++
src/qemu/qemu_monitor_json.c | 58 ++++++++++++++++++++++++++++++--
2 files changed, 72 insertions(+), 2 deletions(-)
diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h
index 5801ca0f86..ad5755cfed 100644
--- a/include/libvirt/libvirt-domain.h
+++ b/include/libvirt/libvirt-domain.h
@@ -5107,6 +5107,22 @@ typedef enum {
VIR_DOMAIN_DIRTYRATE_QUERY = 1 << 1, /* query domain's dirtyrate */
} virDomainDirtyRateFlags;
+/**
+ * virDomainDirtyRateStatus:
+ *
+ * Details on the cause of a dirtyrate calculation status.
+ */
+
+typedef enum {
+ VIR_DOMAIN_DIRTYRATE_UNSTARTED = 0, /* the dirtyrate calculation has not been started
*/
+ VIR_DOMAIN_DIRTYRATE_MEASURING = 1, /* the dirtyrate calculation is measuring */
+ VIR_DOMAIN_DIRTYRATE_MEASURED = 2, /* the dirtyrate calculation is completed */
+
+# ifdef VIR_ENUM_SENTINELS
+ VIR_DOMAIN_DIRTYRATE_LAST
+# endif
+} virDomainDirtyRateStatus;
+
/**
* virDomainDirtyRateInfo:
*
diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
index a0616eae2c..ca7d8d23c0 100644
--- a/src/qemu/qemu_monitor_json.c
+++ b/src/qemu/qemu_monitor_json.c
@@ -9659,12 +9659,61 @@ qemuMonitorJSONCalculateDirtyRate(qemuMonitorPtr mon,
}
+VIR_ENUM_DECL(qemuDomainDirtyRateStatus);
+VIR_ENUM_IMPL(qemuDomainDirtyRateStatus,
+ VIR_DOMAIN_DIRTYRATE_LAST,
+ "unstarted",
+ "measuring",
+ "measured");
+
+static int
+qemuMonitorJSONExtractDirtyRateInfo(virJSONValuePtr data,
+ virDomainDirtyRateInfoPtr info)
+{
+ const char *status;
+ int statusID;
+
+ if (!(status = virJSONValueObjectGetString(data, "status"))) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("query-dirty-rate reply was missing 'status'
data"));
+ return -1;
+ }
+
+ if ((statusID = qemuDomainDirtyRateStatusTypeFromString(status)) < 0) {
+ return -1;
+ }
+ info->status = statusID;
+
+ if ((info->status == VIR_DOMAIN_DIRTYRATE_MEASURED) &&
+ (virJSONValueObjectGetNumberLong(data, "dirty-rate",
&(info->dirtyRate)) < 0)) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("query-dirty-rate reply was missing 'dirty-rate'
data"));
+ return -1;
+ }
+
+ if (virJSONValueObjectGetNumberLong(data, "start-time",
&(info->startTime)) < 0) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("query-dirty-rate reply was missing 'start-time'
data"));
+ return -1;
+ }
+
+ if (virJSONValueObjectGetNumberLong(data, "calc-time",
&(info->calcTime)) < 0) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("query-dirty-rate reply was missing 'calc-time'
data"));
+ return -1;
+ }
+
+ return 0;
+}
+
+
int
qemuMonitorJSONQueryDirtyRate(qemuMonitorPtr mon,
virDomainDirtyRateInfoPtr info)
{
g_autoptr(virJSONValue) cmd = NULL;
g_autoptr(virJSONValue) reply = NULL;
+ virJSONValuePtr data = NULL;
if (!(cmd = qemuMonitorJSONMakeCommand("query-dirty-rate", NULL)))
return -1;
@@ -9675,6 +9724,11 @@ qemuMonitorJSONQueryDirtyRate(qemuMonitorPtr mon,
if (qemuMonitorJSONCheckError(cmd, reply) < 0)
return -1;
- /* TODO: extract dirtyrate data from reply and store in virDomainDirtyRateInfoPtr */
- return 0;
+ if (!(data = virJSONValueObjectGetObject(reply, "return"))) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("query-dirty-rate reply was missing 'return'
data"));
+ return -1;
+ }
+
+ return qemuMonitorJSONExtractDirtyRateInfo(data, info);
}
--
2.23.0
7:47 a.m.
New subject: [PATCH v3 7/7] migration/dirtyrate: Introduce getdirtyrate virsh api
Signed-off-by: Hao Wang <wanghao232(a)huawei.com>
Signed-off-by: Zhou Yimin <zhouyimin(a)huawei.com>
Reviewed-by: Chuan Zheng <zhengchuan(a)huawei.com>
---
tools/virsh-domain.c | 112 +++++++++++++++++++++++++++++++++++++++++++
1 file changed, 112 insertions(+)
diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c
index ef347585e8..c1361ea6a9 100644
--- a/tools/virsh-domain.c
+++ b/tools/virsh-domain.c
@@ -14374,6 +14374,112 @@ cmdGuestInfo(vshControl *ctl, const vshCmd *cmd)
return ret;
}
+/*
+ * "querydirtyrate" command
+ */
+static const vshCmdInfo info_getdirtyrate[] = {
+ {.name = "help",
+ .data = N_("Get a vm's memory dirty rate")
+ },
+ {.name = "desc",
+ .data = N_("Get memory dirty rate of a domain in order to decide"
+ " whether it's proper to be migrated out or not.")
+ },
+ {.name = NULL}
+};
+
+static const vshCmdOptDef opts_getdirtyrate[] = {
+ VIRSH_COMMON_OPT_DOMAIN_FULL(0),
+ {.name = "seconds",
+ .type = VSH_OT_INT,
+ .help = N_("calculate memory dirty rate within specified seconds,"
+ " a valid range of values is [1, 60], and would default to
1s.")
+ },
+ {.name = "calculate",
+ .type = VSH_OT_BOOL,
+ .help = N_("calculate dirty rate only, can be used together with
--query,"
+ " either or both is expected, otherwise would default to
both.")
+ },
+ {.name = "query",
+ .type = VSH_OT_BOOL,
+ .help = N_("query dirty rate only, can be used together with
--calculate,"
+ " either or both is expected, otherwise would default to
both.")
+ },
+ {.name = NULL}
+};
+
+static bool
+cmdGetDirtyRateInfo(vshControl *ctl, const vshCmd *cmd)
+{
+ virDomainPtr dom = NULL;
+ virDomainDirtyRateInfo info;
+ long long sec = 0;
+ const char *status = NULL;
+ unsigned int flags = 0;
+ int rc;
+ bool ret = false;
+ bool calc = vshCommandOptBool(cmd, "calculate");
+ bool query = vshCommandOptBool(cmd, "query");
+
+ if (calc)
+ flags |= VIR_DOMAIN_DIRTYRATE_CALC;
+ if (query)
+ flags |= VIR_DOMAIN_DIRTYRATE_QUERY;
+
+ /* if flag option is missing, default to both --calculate and --query */
+ if (!calc && !query)
+ flags |= VIR_DOMAIN_DIRTYRATE_CALC | VIR_DOMAIN_DIRTYRATE_QUERY;
+
+ if (!(dom = virshCommandOptDomain(ctl, cmd, NULL)))
+ return false;
+
+ rc = vshCommandOptLongLong(ctl, cmd, "seconds", &sec);
+ if (rc < 0)
+ goto done;
+
+ /* if --seconds option is missing, default to 1s */
+ if (!rc)
+ sec = 1;
+
+ if (virDomainGetDirtyRateInfo(dom, &info, sec, flags) < 0) {
+ vshError(ctl, "%s", _("Get memory dirty-rate failed."));
+ goto done;
+ }
+
+ if (flags & VIR_DOMAIN_DIRTYRATE_QUERY) {
+ switch (info.status) {
+ case VIR_DOMAIN_DIRTYRATE_UNSTARTED:
+ status = _("unstarted");
+ break;
+ case VIR_DOMAIN_DIRTYRATE_MEASURING:
+ status = _("measuring");
+ break;
+ case VIR_DOMAIN_DIRTYRATE_MEASURED:
+ status = _("measured");
+ break;
+ default:
+ status = _("unknown");
+ }
+
+ vshPrint(ctl, _("status: %s\n"), status);
+ vshPrint(ctl, _("start time: %lld\n"), info.startTime);
+ vshPrint(ctl, _("calc time: %lld s\n"), info.calcTime);
+
+ if (info.status == VIR_DOMAIN_DIRTYRATE_MEASURED)
+ vshPrint(ctl, _("dirty rate: %lld MB/s\n"), info.dirtyRate);
+ else
+ vshPrint(ctl, _("dirty rate: the calculation is %s, please query
results later\n"),
+ status);
+ } else {
+ vshPrint(ctl, _("Memory dirty rate is calculating, use --query option to
display results.\n"));
+ }
+
+ ret = true;
+ done:
+ virDomainFree(dom);
+ return ret;
+}
+
const vshCmdDef domManagementCmds[] = {
{.name = "attach-device",
.handler = cmdAttachDevice,
@@ -15001,5 +15107,11 @@ const vshCmdDef domManagementCmds[] = {
.info = info_guestinfo,
.flags = 0
},
+ {.name = "getdirtyrate",
+ .handler = cmdGetDirtyRateInfo,
+ .opts = opts_getdirtyrate,
+ .info = info_getdirtyrate,
+ .flags = 0
+ },
{.name = NULL}
};
--
2.23.0
1487
days inactive
1488
days old
9 comments
2 participants
participants (2)
-
Daniel Henrique Barboza -
Hao Wang