4:41 p.m.
Daniel, Daniel, and Matthias: Thanks for your review. This series addresses
almost all of your most recent comments. I am still working on writing a
decent implementation for the test driver but I wanted to get these updates out
right away.
Changes since V2:
* Ported to GIT HEAD for easier merging :)
* Amounts of memory are now reported in kilobytes
* Added flags parameter to API (currently unused)
* Moved to less awkward xdr wire format for remote driver
* Stats 'Free' and 'Total' renamed to 'Unused' and
'Available'
* Various small fixups: constant names, data types, etc
Changes since V1:
* New system for maintaining ABI compatibility and API extensibility:
Rather than passing around a fixed-size stats structure, work with arrays
of stats. An enum of known statistic tags (SWAP_IN, SWAP_OUT, TOTAL_MEM,
etc) is defined. A stat is defined as a tag/value pair. When making a
call to the API, the caller provides an array of stats and the size of the
array. That array is filled with up to the requested number of stats
(depending on hypervisor and guest support). The number of stats provided
is returned.
* Miscellaneous changes:
Changed the API function from virDomainMemStats to virDomainMemoryStats
Added documentation for each memory stat
--
When using ballooning to manage overcommitted memory on a host, a system for
guests to communicate their memory usage to the host can provide information
that will minimize the impact of ballooning on the guests while maximizing
efficient use of host memory.
The design of such a communication channel was recently added to version 0.8.2
of the VirtIO Spec (See Appendix G):
- http://ozlabs.org/~rusty/virtio-spec/virtio-spec-0.8.2.pdf
Host-side and guest-side implementations have been accepted for inclusion in
their respective projects:
- Guest: http://lkml.org/lkml/2009/11/30/274
- Host: http://lists.gnu.org/archive/html/qemu-devel/2009-12/msg00380.html
The following patch series implements a new libvirt interface to expose these
memory statistics. Thank you for your review and comments.
[PATCH 1/6] domMemoryStats: Add domainMemoryStats method to struct _virDriver
[PATCH 2/6] domMemoryStats: Add public symbol to libvirt API
[PATCH 3/6] qemu-driver: Enable domainMemStats in the qemu driver
[PATCH 4/6] remote-driver: Add domainMemoryStats support
[PATCH 5/6] virsh: Enable virDomainMemoryStats as a new command
[PATCH 6/6] python: Add python bindings for virDomainMemoryStats
4:41 p.m.
New subject: [libvirt] [PATCH 1/6] domMemoryStats: Add domainMemoryStats method to struct _virDriver
Set up the types for the domainMemoryStats function and insert it into the
virDriver structure definition. Because of static initializers, update every
driver and set the new field to NULL.
Note: The changes in python/* are to fix compiler errors. The actual python
binding is implemented in a later patch.
Signed-off-by: Adam Litke <agl(a)us.ibm.com>
To: libvirt list <libvir-list(a)redhat.com>
Cc: Daniel Veillard <veillard(a)redhat.com>
Cc: Daniel P. Berrange <berrange(a)redhat.com>
---
include/libvirt/libvirt.h.in | 53 ++++++++++++++++++++++++++++++++++++++++++
python/generator.py | 4 ++-
src/driver.h | 7 +++++
src/esx/esx_driver.c | 1 +
src/lxc/lxc_driver.c | 1 +
src/opennebula/one_driver.c | 1 +
src/openvz/openvz_driver.c | 1 +
src/phyp/phyp_driver.c | 1 +
src/qemu/qemu_driver.c | 1 +
src/remote/remote_driver.c | 1 +
src/test/test_driver.c | 1 +
src/uml/uml_driver.c | 1 +
src/vbox/vbox_tmpl.c | 1 +
src/xen/xen_driver.c | 1 +
14 files changed, 74 insertions(+), 1 deletions(-)
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index 6c3aded..17e3532 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -333,6 +333,55 @@ struct _virDomainInterfaceStats {
*/
typedef virDomainInterfaceStatsStruct *virDomainInterfaceStatsPtr;
+/**
+ * Memory Statistics Tags:
+ */
+typedef enum {
+ /* The total amount of data read from swap space (in kB). */
+ VIR_DOMAIN_MEMORY_STAT_SWAP_IN = 0,
+ /* The total amount of memory written out to swap space (in kB). */
+ VIR_DOMAIN_MEMORY_STAT_SWAP_OUT = 1,
+
+ /*
+ * Page faults occur when a process makes a valid access to virtual memory
+ * that is not available. When servicing the page fault, if disk IO is
+ * required, it is considered a major fault. If not, it is a minor fault.
+ * These are expressed as the number of faults that have occurred.
+ */
+ VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT = 2,
+ VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT = 3,
+
+ /*
+ * The amount of memory left completely unused by the system. Memory that
+ * is available but used for reclaimable caches should NOT be reported as
+ * free. This value is expressed in kB.
+ */
+ VIR_DOMAIN_MEMORY_STAT_UNUSED = 4,
+
+ /*
+ * The total amount of usable memory as seen by the domain. This value
+ * may be less than the amount of memory assigned to the domain if a
+ * balloon driver is in use or if the guest OS does not initialize all
+ * assigned pages. This value is expressed in kB.
+ */
+ VIR_DOMAIN_MEMORY_STAT_AVAILABLE = 5,
+
+ /*
+ * The number of statistics supported by this version of the interface.
+ * To add new statistics, add them to the enum and increase this value.
+ */
+ VIR_DOMAIN_MEMORY_STAT_NR_STATS = 6,
+} virDomainMemoryStatTags;
+
+typedef struct _virDomainMemoryStat virDomainMemoryStatStruct;
+
+struct _virDomainMemoryStat {
+ int tag;
+ unsigned long long val;
+};
+
+typedef virDomainMemoryStatStruct *virDomainMemoryStatPtr;
+
/* Domain core dump flags. */
typedef enum {
@@ -644,6 +693,10 @@ int virDomainInterfaceStats (virDomainPtr dom,
const char *path,
virDomainInterfaceStatsPtr stats,
size_t size);
+int virDomainMemoryStats (virDomainPtr dom,
+ virDomainMemoryStatPtr stats,
+ unsigned int nr_stats,
+ unsigned int flags);
int virDomainBlockPeek (virDomainPtr dom,
const char *path,
unsigned long long offset,
diff --git a/python/generator.py b/python/generator.py
index 3fd7f90..06f1ff4 100755
--- a/python/generator.py
+++ b/python/generator.py
@@ -160,7 +160,8 @@ def enum(type, name, value):
functions_failed = []
functions_skipped = [
- "virConnectListDomains"
+ "virConnectListDomains",
+ "virDomainMemoryStats"
]
skipped_modules = {
@@ -170,6 +171,7 @@ skipped_types = {
# 'int *': "usually a return type",
'virConnectDomainEventCallback': "No function types in python",
'virEventAddHandleFunc': "No function types in python",
+ 'virDomainMemoryStatPtr': "Not implemented yet",
}
#######################################################################
diff --git a/src/driver.h b/src/driver.h
index 09ce8e2..6193e47 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -229,6 +229,12 @@ typedef int
struct _virDomainInterfaceStats *stats);
typedef int
+ (*virDrvDomainMemoryStats)
+ (virDomainPtr domain,
+ struct _virDomainMemoryStat *stats,
+ unsigned int nr_stats);
+
+typedef int
(*virDrvDomainBlockPeek)
(virDomainPtr domain,
const char *path,
@@ -419,6 +425,7 @@ struct _virDriver {
virDrvDomainMigrateFinish domainMigrateFinish;
virDrvDomainBlockStats domainBlockStats;
virDrvDomainInterfaceStats domainInterfaceStats;
+ virDrvDomainMemoryStats domainMemoryStats;
virDrvDomainBlockPeek domainBlockPeek;
virDrvDomainMemoryPeek domainMemoryPeek;
virDrvNodeGetCellsFreeMemory nodeGetCellsFreeMemory;
diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c
index ea464a3..2626162 100644
--- a/src/esx/esx_driver.c
+++ b/src/esx/esx_driver.c
@@ -3412,6 +3412,7 @@ static virDriver esxDriver = {
esxDomainMigrateFinish, /* domainMigrateFinish */
NULL, /* domainBlockStats */
NULL, /* domainInterfaceStats */
+ NULL, /* domainMemoryStats */
NULL, /* domainBlockPeek */
NULL, /* domainMemoryPeek */
NULL, /* nodeGetCellsFreeMemory */
diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c
index c8e2dca..ff998c7 100644
--- a/src/lxc/lxc_driver.c
+++ b/src/lxc/lxc_driver.c
@@ -2438,6 +2438,7 @@ static virDriver lxcDriver = {
NULL, /* domainMigrateFinish */
NULL, /* domainBlockStats */
lxcDomainInterfaceStats, /* domainInterfaceStats */
+ NULL, /* domainMemoryStats */
NULL, /* domainBlockPeek */
NULL, /* domainMemoryPeek */
nodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
diff --git a/src/opennebula/one_driver.c b/src/opennebula/one_driver.c
index a30c110..a4ad31e 100644
--- a/src/opennebula/one_driver.c
+++ b/src/opennebula/one_driver.c
@@ -765,6 +765,7 @@ static virDriver oneDriver = {
NULL, /* domainMigrateFinish */
NULL, /* domainBlockStats */
NULL, /* domainInterfaceStats */
+ NULL, /* domainMemoryStats */
NULL, /* domainBlockPeek */
NULL, /* domainMemoryPeek */
NULL, /* nodeGetCellsFreeMemory */
diff --git a/src/openvz/openvz_driver.c b/src/openvz/openvz_driver.c
index 1c0fccc..7acce5b 100644
--- a/src/openvz/openvz_driver.c
+++ b/src/openvz/openvz_driver.c
@@ -1517,6 +1517,7 @@ static virDriver openvzDriver = {
NULL, /* domainMigrateFinish */
NULL, /* domainBlockStats */
NULL, /* domainInterfaceStats */
+ NULL, /* domainMemoryStats */
NULL, /* domainBlockPeek */
NULL, /* domainMemoryPeek */
NULL, /* nodeGetCellsFreeMemory */
diff --git a/src/phyp/phyp_driver.c b/src/phyp/phyp_driver.c
index c4fcfed..07adccb 100644
--- a/src/phyp/phyp_driver.c
+++ b/src/phyp/phyp_driver.c
@@ -1633,6 +1633,7 @@ virDriver phypDriver = {
NULL, /* domainMigrateFinish */
NULL, /* domainBlockStats */
NULL, /* domainInterfaceStats */
+ NULL, /* domainMemoryStats */
NULL, /* domainBlockPeek */
NULL, /* domainMemoryPeek */
NULL, /* nodeGetCellsFreeMemory */
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 9ef6c35..1ddc23e 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -7907,6 +7907,7 @@ static virDriver qemuDriver = {
NULL, /* domainMigrateFinish */
qemudDomainBlockStats, /* domainBlockStats */
qemudDomainInterfaceStats, /* domainInterfaceStats */
+ NULL, /* domainMemoryStats */
qemudDomainBlockPeek, /* domainBlockPeek */
qemudDomainMemoryPeek, /* domainMemoryPeek */
nodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 77962fe..5d32d3b 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -8814,6 +8814,7 @@ static virDriver remote_driver = {
remoteDomainMigrateFinish, /* domainMigrateFinish */
remoteDomainBlockStats, /* domainBlockStats */
remoteDomainInterfaceStats, /* domainInterfaceStats */
+ NULL, /* domainMemoryStats */
remoteDomainBlockPeek, /* domainBlockPeek */
remoteDomainMemoryPeek, /* domainMemoryPeek */
remoteNodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
diff --git a/src/test/test_driver.c b/src/test/test_driver.c
index 7db9a4c..21ea491 100644
--- a/src/test/test_driver.c
+++ b/src/test/test_driver.c
@@ -5220,6 +5220,7 @@ static virDriver testDriver = {
NULL, /* domainMigrateFinish */
testDomainBlockStats, /* domainBlockStats */
testDomainInterfaceStats, /* domainInterfaceStats */
+ NULL, /* domainMemoryStats */
NULL, /* domainBlockPeek */
NULL, /* domainMemoryPeek */
testNodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c
index 48ef103..035ed0c 100644
--- a/src/uml/uml_driver.c
+++ b/src/uml/uml_driver.c
@@ -1906,6 +1906,7 @@ static virDriver umlDriver = {
NULL, /* domainMigrateFinish */
NULL, /* domainBlockStats */
NULL, /* domainInterfaceStats */
+ NULL, /* domainMemoryStats */
umlDomainBlockPeek, /* domainBlockPeek */
NULL, /* domainMemoryPeek */
nodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c
index d6b681c..e2e1ce6 100644
--- a/src/vbox/vbox_tmpl.c
+++ b/src/vbox/vbox_tmpl.c
@@ -7028,6 +7028,7 @@ virDriver NAME(Driver) = {
NULL, /* domainMigrateFinish */
NULL, /* domainBlockStats */
NULL, /* domainInterfaceStats */
+ NULL, /* domainMemoryStats */
NULL, /* domainBlockPeek */
NULL, /* domainMemoryPeek */
nodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c
index ed94bed..e952610 100644
--- a/src/xen/xen_driver.c
+++ b/src/xen/xen_driver.c
@@ -1844,6 +1844,7 @@ static virDriver xenUnifiedDriver = {
xenUnifiedDomainMigrateFinish, /* domainMigrateFinish */
xenUnifiedDomainBlockStats, /* domainBlockStats */
xenUnifiedDomainInterfaceStats, /* domainInterfaceStats */
+ NULL, /* domainMemoryStats */
xenUnifiedDomainBlockPeek, /* domainBlockPeek */
NULL, /* domainMemoryPeek */
xenUnifiedNodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
--
1.6.5
4:41 p.m.
New subject: [libvirt] [PATCH 2/6] domMemoryStats: Add public symbol to libvirt API
Add a new function 'virDomainMemoryStats' to the libvirt API. Export it via
libvirt_public.syms
Signed-off-by: Adam Litke <agl(a)us.ibm.com>
To: libvirt list <libvir-list(a)redhat.com>
Cc: Daniel Veillard <veillard(a)redhat.com>
Cc: Daniel P. Berrange <berrange(a)redhat.com>
---
src/libvirt.c | 71 +++++++++++++++++++++++++++++++++++++++++++++++
src/libvirt_public.syms | 1 +
2 files changed, 72 insertions(+), 0 deletions(-)
diff --git a/src/libvirt.c b/src/libvirt.c
index 103b331..298610d 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -4109,6 +4109,77 @@ error:
}
/**
+ * virDomainMemoryStats:
+ * @dom: pointer to the domain object
+ * @stats: nr_stats-sized array of stat structures (returned)
+ * @nr_stats: number of memory statistics requested
+ * @flags: unused, always pass 0
+ *
+ * This function provides memory statistics for the domain.
+ *
+ * Up to 'nr_stats' elements of 'stats' will be populated with memory
statistics
+ * from the domain. Only statistics supported by the domain, the driver, and
+ * this version of libvirt will be returned.
+ *
+ * Memory Statistics:
+ *
+ * VIR_DOMAIN_MEMORY_STAT_SWAP_IN:
+ * The total amount of data read from swap space (in kb).
+ * VIR_DOMAIN_MEMORY_STAT_SWAP_OUT:
+ * The total amount of memory written out to swap space (in kb).
+ * VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT:
+ * The number of page faults that required disk IO to service.
+ * VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT:
+ * The number of page faults serviced without disk IO.
+ * VIR_DOMAIN_MEMORY_STAT_UNUSED:
+ * The amount of memory which is not being used for any purpose (in kb).
+ * VIR_DOMAIN_MEMORY_STAT_AVAILABLE:
+ * The total amount of memory available to the domain's OS (in kb).
+ *
+ * Returns: The number of stats provided or -1 in case of failure.
+ */
+int virDomainMemoryStats (virDomainPtr dom, virDomainMemoryStatPtr stats,
+ unsigned int nr_stats, unsigned int flags)
+{
+ virConnectPtr conn;
+ unsigned long nr_stats_ret = 0;
+ DEBUG("domain=%p, stats=%p, nr_stats=%u", dom, stats, nr_stats);
+
+ if (flags != 0) {
+ virLibDomainError (dom, VIR_ERR_INVALID_ARG,
+ _("flags must be zero"));
+ goto error;
+ }
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_DOMAIN (dom)) {
+ virLibDomainError (NULL, VIR_ERR_INVALID_DOMAIN, __FUNCTION__);
+ return -1;
+ }
+ if (!stats || nr_stats == 0)
+ return 0;
+
+ if (nr_stats > VIR_DOMAIN_MEMORY_STAT_NR)
+ nr_stats = VIR_DOMAIN_MEMORY_STAT_NR;
+
+ conn = dom->conn;
+ if (conn->driver->domainMemoryStats) {
+ nr_stats_ret = conn->driver->domainMemoryStats (dom, stats, nr_stats);
+ if (nr_stats_ret == -1)
+ goto error;
+ return nr_stats_ret;
+ }
+
+ virLibDomainError (dom, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(dom->conn);
+ return -1;
+}
+
+/**
* virDomainBlockPeek:
* @dom: pointer to the domain object
* @path: path to the block device
diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms
index b4f57e7..c0c3693 100644
--- a/src/libvirt_public.syms
+++ b/src/libvirt_public.syms
@@ -341,6 +341,7 @@ LIBVIRT_0.7.3 {
virStoragePoolIsActive;
virStoragePoolIsPersistent;
virInterfaceIsActive;
+ virDomainMemoryStats;
} LIBVIRT_0.7.2;
# .... define new API here using predicted next version number ....
--
1.6.5
4:41 p.m.
New subject: [libvirt] [PATCH 3/6] qemu-driver: Enable domainMemStats in the qemu driver
Support for memory statistics reporting is accepted for qemu inclusion.
Statistics are reported via the monitor command 'info balloon' as a comma
seprated list:
(qemu) info balloon
balloon:
actual=1024,mem_swapped_in=0,mem_swapped_out=0,major_page_faults=88,minor_page_faults=105535,free_mem=1017065472,total_mem=1045229568
Libvirt, qemu, and the guest operating system may support a subset of the
statistics defined by the virtio spec. Thus, only statistics recognized by
components will be reported.
Signed-off-by: Adam Litke <agl(a)us.ibm.com>
To: libvirt list <libvir-list(a)redhat.com>
Cc: Daniel Veillard <veillard(a)redhat.com>
Cc: Daniel P. Berrange <berrange(a)redhat.com>
---
src/qemu/qemu_driver.c | 39 +++++++++++++++++++-
src/qemu/qemu_monitor_text.c | 83 ++++++++++++++++++++++++++++++++++++++++++
src/qemu/qemu_monitor_text.h | 3 ++
3 files changed, 124 insertions(+), 1 deletions(-)
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 1ddc23e..562a20b 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -6235,6 +6235,43 @@ qemudDomainInterfaceStats (virDomainPtr dom,
#endif
static int
+qemudDomainMemoryStats (virDomainPtr dom,
+ struct _virDomainMemoryStat *stats,
+ unsigned int nr_stats)
+{
+ struct qemud_driver *driver = dom->conn->privateData;
+ virDomainObjPtr vm;
+ unsigned int ret = -1;
+
+ qemuDriverLock(driver);
+ vm = virDomainFindByUUID(&driver->domains, dom->uuid);
+ qemuDriverUnlock(driver);
+
+ if (!vm) {
+ char uuidstr[VIR_UUID_STRING_BUFLEN];
+ virUUIDFormat(dom->uuid, uuidstr);
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_NO_DOMAIN,
+ _("no domain with matching uuid '%s'"),
uuidstr);
+ goto cleanup;
+ }
+
+ if (virDomainObjIsActive(vm)) {
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+ qemuDomainObjEnterMonitor(vm);
+ ret = qemuMonitorTextGetMemoryStats(priv->mon, stats, nr_stats);
+ qemuDomainObjExitMonitor(vm);
+ } else {
+ qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_INVALID,
+ "%s", _("domain is not running"));
+ }
+
+cleanup:
+ if (vm)
+ virDomainObjUnlock(vm);
+ return ret;
+}
+
+static int
qemudDomainBlockPeek (virDomainPtr dom,
const char *path,
unsigned long long offset, size_t size,
@@ -7907,7 +7944,7 @@ static virDriver qemuDriver = {
NULL, /* domainMigrateFinish */
qemudDomainBlockStats, /* domainBlockStats */
qemudDomainInterfaceStats, /* domainInterfaceStats */
- NULL, /* domainMemoryStats */
+ qemudDomainMemoryStats, /* domainMemoryStats */
qemudDomainBlockPeek, /* domainBlockPeek */
qemudDomainMemoryPeek, /* domainMemoryPeek */
nodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
diff --git a/src/qemu/qemu_monitor_text.c b/src/qemu/qemu_monitor_text.c
index 0cb9ea6..ab361c6 100644
--- a/src/qemu/qemu_monitor_text.c
+++ b/src/qemu/qemu_monitor_text.c
@@ -454,6 +454,65 @@ error:
return 0;
}
+static int parseMemoryStat(char **text, unsigned int tag,
+ const char *search, virDomainMemoryStatPtr stat)
+{
+ char *dummy;
+ unsigned long long value;
+
+ if (STRPREFIX (*text, search)) {
+ *text += strlen(search);
+ if (virStrToLong_ull (*text, &dummy, 10, &value)) {
+ DEBUG ("error reading %s: %s", search, *text);
+ return 0;
+ }
+
+ /* Convert bytes to kilobytes for libvirt */
+ switch (tag) {
+ case VIR_DOMAIN_MEMORY_STAT_SWAP_IN:
+ case VIR_DOMAIN_MEMORY_STAT_SWAP_OUT:
+ case VIR_DOMAIN_MEMORY_STAT_UNUSED:
+ case VIR_DOMAIN_MEMORY_STAT_AVAILABLE:
+ value = value >> 10;
+ }
+ stat->tag = tag;
+ stat->val = value;
+ return 1;
+ }
+ return 0;
+}
+
+/* The reply from the 'info balloon' command may contain additional memory
+ * statistics in the form: '[,<tag>=<val>]*'
+ */
+static int qemuMonitorParseExtraBalloonInfo(char *text,
+ virDomainMemoryStatPtr stats,
+ unsigned int nr_stats)
+{
+ char *p = text;
+ unsigned int nr_stats_found = 0;
+
+ while (*p && nr_stats_found < nr_stats) {
+ if (parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_SWAP_IN,
+ ",mem_swapped_in=", &stats[nr_stats_found]) ||
+ parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_SWAP_OUT,
+ ",mem_swapped_out=", &stats[nr_stats_found])
||
+ parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT,
+ ",major_page_faults=", &stats[nr_stats_found])
||
+ parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT,
+ ",minor_page_faults=", &stats[nr_stats_found])
||
+ parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_UNUSED,
+ ",free_mem=", &stats[nr_stats_found]) ||
+ parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_AVAILABLE,
+ ",total_mem=", &stats[nr_stats_found]))
+ nr_stats_found++;
+
+ /* Skip to the next label */
+ p = strchr (p, ',');
+ if (!p) break;
+ }
+ return nr_stats_found;
+}
/* The reply from QEMU contains 'ballon: actual=421' where value is in MB */
@@ -499,6 +558,30 @@ cleanup:
return ret;
}
+int qemuMonitorTextGetMemoryStats(qemuMonitorPtr mon,
+ virDomainMemoryStatPtr stats,
+ unsigned int nr_stats)
+{
+ char *reply = NULL;
+ int ret = 0;
+ char *offset;
+
+ if (qemuMonitorCommand(mon, "info balloon", &reply) < 0) {
+ qemudReportError(NULL, NULL, NULL, VIR_ERR_OPERATION_FAILED,
+ "%s", _("could not query memory balloon
statistics"));
+ return -1;
+ }
+
+ if ((offset = strstr(reply, BALLOON_PREFIX)) != NULL) {
+ if ((offset = strchr(reply, ',')) != NULL) {
+ ret = qemuMonitorParseExtraBalloonInfo(offset, stats, nr_stats);
+ }
+ }
+
+ VIR_FREE(reply);
+ return ret;
+}
+
int qemuMonitorTextGetBlockStatsInfo(qemuMonitorPtr mon,
const char *devname,
diff --git a/src/qemu/qemu_monitor_text.h b/src/qemu/qemu_monitor_text.h
index 519edf4..5897a03 100644
--- a/src/qemu/qemu_monitor_text.h
+++ b/src/qemu/qemu_monitor_text.h
@@ -45,6 +45,9 @@ int qemuMonitorTextGetCPUInfo(qemuMonitorPtr mon,
int **pids);
int qemuMonitorTextGetBalloonInfo(qemuMonitorPtr mon,
unsigned long *currmem);
+int qemuMonitorTextGetMemoryStats(qemuMonitorPtr mon,
+ virDomainMemoryStatPtr stats,
+ unsigned int nr_stats);
int qemuMonitorTextGetBlockStatsInfo(qemuMonitorPtr mon,
const char *devname,
long long *rd_req,
--
1.6.5
4:41 p.m.
New subject: [libvirt] [PATCH 4/6] remote-driver: Add domainMemoryStats support
Use a dynamically sized xdr_array to pass memory stats on the wire. This
supports the addition of future memory stats and reduces the message size since
only supported statistics are returned.
Signed-off-by: Adam Litke <agl(a)us.ibm.com>
To: libvirt list <libvir-list(a)redhat.com>
Cc: Daniel Veillard <veillard(a)redhat.com>
Cc: Daniel P. Berrange <berrange(a)redhat.com>
---
daemon/remote.c | 56 ++++++++++++++++++++++++++++++++++++++++++
src/remote/remote_driver.c | 44 ++++++++++++++++++++++++++++++++-
src/remote/remote_protocol.c | 35 ++++++++++++++++++++++++++
src/remote/remote_protocol.h | 25 ++++++++++++++++++
src/remote/remote_protocol.x | 18 ++++++++++++-
5 files changed, 176 insertions(+), 2 deletions(-)
diff --git a/daemon/remote.c b/daemon/remote.c
index 7a43046..2066c49 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -708,6 +708,62 @@ remoteDispatchDomainInterfaceStats (struct qemud_server *server
ATTRIBUTE_UNUSED
}
static int
+remoteDispatchDomainMemoryStats (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_message_header *hdr ATTRIBUTE_UNUSED,
+ remote_error *rerr,
+ remote_domain_memory_stats_args *args,
+ remote_domain_memory_stats_ret *ret)
+{
+ virDomainPtr dom;
+ struct _virDomainMemoryStat *stats;
+ unsigned int nr_stats, i;
+
+ if (args->maxStats > REMOTE_DOMAIN_MEMORY_STATS_MAX) {
+ remoteDispatchFormatError (rerr, "%s",
+ _("maxStats >
REMOTE_DOMAIN_MEMORY_STATS_MAX"));
+ return -1;
+ }
+
+ dom = get_nonnull_domain (conn, args->dom);
+ if (dom == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* Allocate stats array for making dispatch call */
+ if (VIR_ALLOC_N(stats, args->maxStats) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ nr_stats = virDomainMemoryStats (dom, stats, args->maxStats, 0);
+ virDomainFree (dom);
+ if (nr_stats == -1) {
+ VIR_FREE(stats);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* Allocate return buffer */
+ if (VIR_ALLOC_N(ret->stats, args->maxStats) < 0) {
+ VIR_FREE(stats);
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ /* Copy the stats into the xdr return structure */
+ for (i = 0; i < nr_stats; i++) {
+ ret->stats[i].tag = stats[i].tag;
+ ret->stats[i].val = stats[i].val;
+ }
+ ret->len = nr_stats;
+ VIR_FREE(stats);
+ return 0;
+}
+
+static int
remoteDispatchDomainBlockPeek (struct qemud_server *server ATTRIBUTE_UNUSED,
struct qemud_client *client ATTRIBUTE_UNUSED,
virConnectPtr conn,
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 5d32d3b..384779d 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -3366,6 +3366,48 @@ done:
}
static int
+remoteDomainMemoryStats (virDomainPtr domain,
+ struct _virDomainMemoryStat *stats,
+ unsigned int nr_stats)
+{
+ int rv = -1;
+ remote_domain_memory_stats_args args;
+ remote_domain_memory_stats_ret ret;
+ struct private_data *priv = domain->conn->privateData;
+ unsigned int i;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain (&args.dom, domain);
+ if (nr_stats > REMOTE_DOMAIN_MEMORY_STATS_MAX) {
+ errorf (domain->conn, VIR_ERR_RPC,
+ _("too many memory stats requested: %d > %d"), nr_stats,
+ REMOTE_DOMAIN_MEMORY_STATS_MAX);
+ goto done;
+ }
+ args.maxStats = nr_stats;
+ memset (&ret, 0, sizeof ret);
+
+ if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MEMORY_STATS,
+ (xdrproc_t) xdr_remote_domain_memory_stats_args,
+ (char *) &args,
+ (xdrproc_t) xdr_remote_domain_memory_stats_ret,
+ (char *) &ret) == -1)
+ goto done;
+
+ for (i = 0; i < ret.len; i++) {
+ stats[i].tag = ret.stats[i].tag;
+ stats[i].val = ret.stats[i].val;
+ }
+ rv = ret.len;
+ xdr_free((xdrproc_t) xdr_remote_domain_memory_stats_ret, (char *) &ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
remoteDomainBlockPeek (virDomainPtr domain,
const char *path,
unsigned long long offset,
@@ -8814,7 +8856,7 @@ static virDriver remote_driver = {
remoteDomainMigrateFinish, /* domainMigrateFinish */
remoteDomainBlockStats, /* domainBlockStats */
remoteDomainInterfaceStats, /* domainInterfaceStats */
- NULL, /* domainMemoryStats */
+ remoteDomainMemoryStats, /* domainMemoryStats */
remoteDomainBlockPeek, /* domainBlockPeek */
remoteDomainMemoryPeek, /* domainMemoryPeek */
remoteNodeGetCellsFreeMemory, /* nodeGetCellsFreeMemory */
diff --git a/src/remote/remote_protocol.c b/src/remote/remote_protocol.c
index a10558a..45510ae 100644
--- a/src/remote/remote_protocol.c
+++ b/src/remote/remote_protocol.c
@@ -597,6 +597,41 @@ xdr_remote_domain_interface_stats_ret (XDR *xdrs,
remote_domain_interface_stats_
}
bool_t
+xdr_remote_domain_memory_stats_args (XDR *xdrs, remote_domain_memory_stats_args *objp)
+{
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_u_int (xdrs, &objp->maxStats))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_memory_stat (XDR *xdrs, remote_domain_memory_stat *objp)
+{
+ if (!xdr_int (xdrs, &objp->tag))
+ return FALSE;
+ if (!xdr_u_hyper (xdrs, &objp->val))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_domain_memory_stats_ret (XDR *xdrs, remote_domain_memory_stats_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->stats;
+
+ if (!xdr_u_int (xdrs, &objp->len))
+ return FALSE;
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->len,
+ REMOTE_DOMAIN_MEMORY_STATS_MAX,
+ sizeof (struct remote_domain_memory_stat),
+ (xdrproc_t) xdr_remote_memory_stat))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
xdr_remote_domain_block_peek_args (XDR *xdrs, remote_domain_block_peek_args *objp)
{
diff --git a/src/remote/remote_protocol.h b/src/remote/remote_protocol.h
index 2ba9be4..e7832ff 100644
--- a/src/remote/remote_protocol.h
+++ b/src/remote/remote_protocol.h
@@ -40,6 +40,7 @@ typedef remote_nonnull_string *remote_string;
#define REMOTE_NODE_MAX_CELLS 1024
#define REMOTE_AUTH_SASL_DATA_MAX 65536
#define REMOTE_AUTH_TYPE_LIST_MAX 20
+#define REMOTE_DOMAIN_MEMORY_STATS_MAX 1024
#define REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX 65536
#define REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX 65536
#define REMOTE_SECURITY_MODEL_MAX VIR_SECURITY_MODEL_BUFLEN
@@ -307,6 +308,24 @@ struct remote_domain_interface_stats_ret {
};
typedef struct remote_domain_interface_stats_ret remote_domain_interface_stats_ret;
+struct remote_domain_memory_stats_args {
+ remote_nonnull_domain dom;
+ u_int maxStats;
+};
+typedef struct remote_domain_memory_stats_args remote_domain_memory_stats_args;
+
+struct remote_domain_memory_stat {
+ int tag;
+ uint64_t val;
+};
+typedef struct remote_domain_memory_stat remote_domain_memory_stat;
+
+struct remote_domain_memory_stats_ret {
+ u_int len;
+ struct remote_domain_memory_stat *stats;
+};
+typedef struct remote_domain_memory_stats_ret remote_domain_memory_stats_ret;
+
struct remote_domain_block_peek_args {
remote_nonnull_domain dom;
remote_nonnull_string path;
@@ -1777,6 +1796,7 @@ enum remote_procedure {
REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT = 155,
REMOTE_PROC_INTERFACE_IS_ACTIVE = 156,
REMOTE_PROC_GET_LIB_VERSION = 157,
+ REMOTE_PROC_DOMAIN_MEMORY_STATS = 158,
};
typedef enum remote_procedure remote_procedure;
@@ -1853,6 +1873,9 @@ extern bool_t xdr_remote_domain_block_stats_args (XDR *,
remote_domain_block_st
extern bool_t xdr_remote_domain_block_stats_ret (XDR *,
remote_domain_block_stats_ret*);
extern bool_t xdr_remote_domain_interface_stats_args (XDR *,
remote_domain_interface_stats_args*);
extern bool_t xdr_remote_domain_interface_stats_ret (XDR *,
remote_domain_interface_stats_ret*);
+extern bool_t xdr_remote_domain_memory_stats_args (XDR *,
remote_domain_memory_stats_args*);
+extern bool_t xdr_remote_domain_memory_stats_ret (XDR *,
remote_domain_memory_stats_ret*);
+extern bool_t xdr_remote_memory_stat (XDR *xdrs, remote_domain_memory_stat *objp);
extern bool_t xdr_remote_domain_block_peek_args (XDR *,
remote_domain_block_peek_args*);
extern bool_t xdr_remote_domain_block_peek_ret (XDR *, remote_domain_block_peek_ret*);
extern bool_t xdr_remote_domain_memory_peek_args (XDR *,
remote_domain_memory_peek_args*);
@@ -2124,6 +2147,8 @@ extern bool_t xdr_remote_domain_block_stats_args ();
extern bool_t xdr_remote_domain_block_stats_ret ();
extern bool_t xdr_remote_domain_interface_stats_args ();
extern bool_t xdr_remote_domain_interface_stats_ret ();
+extern bool_t xdr_remote_domain_memory_stats_args ();
+extern bool_t xdr_remote_domain_memory_stats_ret ();
extern bool_t xdr_remote_domain_block_peek_args ();
extern bool_t xdr_remote_domain_block_peek_ret ();
extern bool_t xdr_remote_domain_memory_peek_args ();
diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index 92f7010..36e7f73 100644
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -405,6 +405,21 @@ struct remote_domain_interface_stats_ret {
hyper tx_drop;
};
+struct remote_domain_memory_stats_args {
+ remote_nonnull_domain dom;
+ u_int maxStats;
+};
+
+struct remote_domain_memory_stat {
+ int tag;
+ unsigned hyper val;
+};
+
+struct remote_domain_memory_stats_ret {
+ u_int len;
+ remote_domain_memory_stat<REMOTE_DOMAIN_MEMORY_STATS_MAX>;
+};
+
struct remote_domain_block_peek_args {
remote_nonnull_domain dom;
remote_nonnull_string path;
@@ -1611,7 +1626,8 @@ enum remote_procedure {
REMOTE_PROC_STORAGE_POOL_IS_ACTIVE = 154,
REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT = 155,
REMOTE_PROC_INTERFACE_IS_ACTIVE = 156,
- REMOTE_PROC_GET_LIB_VERSION = 157
+ REMOTE_PROC_GET_LIB_VERSION = 157,
+ REMOTE_PROC_DOMAIN_MEMORY_STATS = 158
/*
* Notice how the entries are grouped in sets of 10 ?
--
1.6.5
4:41 p.m.
New subject: [libvirt] [PATCH 5/6] virsh: Enable virDomainMemoryStats as a new command
Define a new command 'dommemstats' to report domain memory statistics. The
output format is inspired by 'domblkstat' and 'domifstat' and consists of
tag/value pairs, one per line. The command can complete successfully and print
no output if virDomainMemoryStats is supported by the driver, but not the guest
operating system.
Sample output:
swap_in 0
swap_out 0
major_fault 54
minor_fault 58259
unused 487680
available 502472
All stats referring to a quantity of memory (eg. all above except major and
minor faults) represent the quantity in kb.
Signed-off-by: Adam Litke <agl(a)us.ibm.com>
To: libvirt list <libvir-list(a)redhat.com>
Cc: Daniel Veillard <veillard(a)redhat.com>
Cc: Daniel P. Berrange <berrange(a)redhat.com>
---
tools/virsh.c | 55 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 55 insertions(+), 0 deletions(-)
diff --git a/tools/virsh.c b/tools/virsh.c
index 8f96ca8..c2250ba 100644
--- a/tools/virsh.c
+++ b/tools/virsh.c
@@ -885,6 +885,60 @@ cmdDomIfstat (vshControl *ctl, const vshCmd *cmd)
}
/*
+ * "dommemstats" command
+ */
+static const vshCmdInfo info_dommemstats[] = {
+ {"help", gettext_noop("get memory statistics for a domain")},
+ {"desc", gettext_noop("Get memory statistics for a runnng
domain.")},
+ {NULL,NULL}
+};
+
+static const vshCmdOptDef opts_dommemstats[] = {
+ {"domain", VSH_OT_DATA, VSH_OFLAG_REQ, gettext_noop("domain name, id
or uuid")},
+ {NULL, 0, 0, NULL}
+};
+
+static int
+cmdDomMemStats(vshControl *ctl, const vshCmd *cmd)
+{
+ virDomainPtr dom;
+ char *name;
+ struct _virDomainMemoryStat stats[VIR_DOMAIN_MEMORY_STAT_NR];
+ unsigned int nr_stats, i;
+
+ if (!vshConnectionUsability(ctl, ctl->conn, TRUE))
+ return FALSE;
+
+ if (!(dom = vshCommandOptDomain(ctl, cmd, &name)))
+ return FALSE;
+
+ nr_stats = virDomainMemoryStats (dom, stats, VIR_DOMAIN_MEMORY_STAT_NR, 0);
+ if (nr_stats == -1) {
+ vshError(ctl, _("Failed to get memory statistics for domain %s"),
name);
+ virDomainFree(dom);
+ return FALSE;
+ }
+
+ for (i = 0; i < nr_stats; i++) {
+ if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_SWAP_IN)
+ vshPrint (ctl, "swap_in %llu\n", stats[i].val);
+ if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_SWAP_OUT)
+ vshPrint (ctl, "swap_out %llu\n", stats[i].val);
+ if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT)
+ vshPrint (ctl, "major_fault %llu\n", stats[i].val);
+ if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT)
+ vshPrint (ctl, "minor_fault %llu\n", stats[i].val);
+ if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_UNUSED)
+ vshPrint (ctl, "unused %llu\n", stats[i].val);
+ if (stats[i].tag == VIR_DOMAIN_MEMORY_STAT_AVAILABLE)
+ vshPrint (ctl, "available %llu\n", stats[i].val);
+ }
+
+ virDomainFree(dom);
+ return TRUE;
+}
+
+/*
* "suspend" command
*/
static const vshCmdInfo info_suspend[] = {
@@ -7221,6 +7275,7 @@ static const vshCmdDef commands[] = {
{"domstate", cmdDomstate, opts_domstate, info_domstate},
{"domblkstat", cmdDomblkstat, opts_domblkstat, info_domblkstat},
{"domifstat", cmdDomIfstat, opts_domifstat, info_domifstat},
+ {"dommemstats", cmdDomMemStats, opts_dommemstats, info_dommemstats},
{"domxml-from-native", cmdDomXMLFromNative, opts_domxmlfromnative,
info_domxmlfromnative},
{"domxml-to-native", cmdDomXMLToNative, opts_domxmltonative,
info_domxmltonative},
{"dumpxml", cmdDumpXML, opts_dumpxml, info_dumpxml},
--
1.6.5
4:41 p.m.
New subject: [libvirt] [PATCH 6/6] python: Add python bindings for virDomainMemoryStats
Enable virDomainMemoryStats in the python API. dom.memoryStats() will return a
dictionary containing the supported statistics. A dictionary is required
because the meaining of each quantity cannot be inferred from its index in a
list.
Signed-off-by: Adam Litke <agl(a)us.ibm.com>
To: libvirt list <libvir-list(a)redhat.com>
Cc: Daniel Veillard <veillard(a)redhat.com>
Cc: Daniel P. Berrange <berrange(a)redhat.com>
---
python/generator.py | 3 +-
python/libvirt-override-api.xml | 5 ++++
python/libvirt-override.c | 43 +++++++++++++++++++++++++++++++++++++++
3 files changed, 49 insertions(+), 2 deletions(-)
diff --git a/python/generator.py b/python/generator.py
index 06f1ff4..56f8925 100755
--- a/python/generator.py
+++ b/python/generator.py
@@ -161,7 +161,6 @@ def enum(type, name, value):
functions_failed = []
functions_skipped = [
"virConnectListDomains",
- "virDomainMemoryStats"
]
skipped_modules = {
@@ -171,7 +170,6 @@ skipped_types = {
# 'int *': "usually a return type",
'virConnectDomainEventCallback': "No function types in python",
'virEventAddHandleFunc': "No function types in python",
- 'virDomainMemoryStatPtr': "Not implemented yet",
}
#######################################################################
@@ -283,6 +281,7 @@ skip_impl = (
'virNetworkGetAutostart',
'virDomainBlockStats',
'virDomainInterfaceStats',
+ 'virDomainMemoryStats',
'virNodeGetCellsFreeMemory',
'virDomainGetSchedulerType',
'virDomainGetSchedulerParameters',
diff --git a/python/libvirt-override-api.xml b/python/libvirt-override-api.xml
index 96958b5..6ae2742 100644
--- a/python/libvirt-override-api.xml
+++ b/python/libvirt-override-api.xml
@@ -105,6 +105,11 @@
<arg name='domain' type='virDomainPtr' info='a domain
object'/>
<arg name='path' type='char *' info='the path for the
interface device'/>
</function>
+ <function name='virDomainMemoryStats' file='python'>
+ <info>Extracts memory statistics for a domain</info>
+ <return type='virDomainMemoryStats' info='a dictionary of
statistics'/>
+ <arg name='domain' type='virDomainPtr' info='a domain
object'/>
+ </function>
<function name="virNodeGetCellsFreeMemory" file='python'>
<info>Returns the available memory for a list of cells</info>
<arg name='conn' type='virConnectPtr' info='pointer to the
hypervisor connection'/>
diff --git a/python/libvirt-override.c b/python/libvirt-override.c
index 6c1e51b..8aa2dad 100644
--- a/python/libvirt-override.c
+++ b/python/libvirt-override.c
@@ -120,6 +120,48 @@ libvirt_virDomainInterfaceStats(PyObject *self ATTRIBUTE_UNUSED,
PyObject *args)
return(info);
}
+static PyObject *
+libvirt_virDomainMemoryStats(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+ virDomainPtr domain;
+ PyObject *pyobj_domain;
+ unsigned int nr_stats, i;
+ virDomainMemoryStatStruct stats[VIR_MEMSTAT_NR_TAGS];
+ PyObject *info;
+
+ if (!PyArg_ParseTuple(args, (char *)"O:virDomainMemoryStats",
&pyobj_domain))
+ return(NULL);
+ domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
+
+ nr_stats = virDomainMemoryStats(domain, stats, VIR_MEMSTAT_NR_TAGS, 0);
+ if (nr_stats == -1)
+ return VIR_PY_NONE;
+
+ /* convert to a Python dictionary */
+ if ((info = PyDict_New()) == NULL)
+ return VIR_PY_NONE;
+
+ for (i = 0; i < nr_stats; i++) {
+ if (stats[i].tag == VIR_MEMSTAT_SWAP_IN)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("swap_in"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ if (stats[i].tag == VIR_MEMSTAT_SWAP_OUT)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("swap_out"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ if (stats[i].tag == VIR_MEMSTAT_MAJOR_FAULT)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("major_fault"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ if (stats[i].tag == VIR_MEMSTAT_MINOR_FAULT)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("minor_fault"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ if (stats[i].tag == VIR_MEMSTAT_MEM_FREE)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("free_memory"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ if (stats[i].tag == VIR_MEMSTAT_MEM_TOTAL)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("total_memory"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ }
+ return info;
+}
static PyObject *
libvirt_virDomainGetSchedulerType(PyObject *self ATTRIBUTE_UNUSED,
@@ -2635,6 +2677,7 @@ static PyMethodDef libvirtMethods[] = {
{(char *) "virNetworkGetAutostart", libvirt_virNetworkGetAutostart,
METH_VARARGS, NULL},
{(char *) "virDomainBlockStats", libvirt_virDomainBlockStats, METH_VARARGS,
NULL},
{(char *) "virDomainInterfaceStats", libvirt_virDomainInterfaceStats,
METH_VARARGS, NULL},
+ {(char *) "virDomainMemoryStats", libvirt_virDomainMemoryStats,
METH_VARARGS, NULL},
{(char *) "virNodeGetCellsFreeMemory", libvirt_virNodeGetCellsFreeMemory,
METH_VARARGS, NULL},
{(char *) "virDomainGetSchedulerType", libvirt_virDomainGetSchedulerType,
METH_VARARGS, NULL},
{(char *) "virDomainGetSchedulerParameters",
libvirt_virDomainGetSchedulerParameters, METH_VARARGS, NULL},
--
1.6.5
5:41 p.m.
New subject: [libvirt] [PATCH 6/6] python: Add python bindings for virDomainMemoryStats
2009/12/17 Adam Litke <agl(a)us.ibm.com>:
Enable virDomainMemoryStats in the python API. dom.memoryStats()
will return a
dictionary containing the supported statistics. A dictionary is required
because the meaining of each quantity cannot be inferred from its index in a
list.
Signed-off-by: Adam Litke <agl(a)us.ibm.com>
To: libvirt list <libvir-list(a)redhat.com>
Cc: Daniel Veillard <veillard(a)redhat.com>
Cc: Daniel P. Berrange <berrange(a)redhat.com>
---
python/generator.py | 3 +-
python/libvirt-override-api.xml | 5 ++++
python/libvirt-override.c | 43 +++++++++++++++++++++++++++++++++++++++
3 files changed, 49 insertions(+), 2 deletions(-)
diff --git a/python/generator.py b/python/generator.py
index 06f1ff4..56f8925 100755
--- a/python/generator.py
+++ b/python/generator.py
@@ -161,7 +161,6 @@ def enum(type, name, value):
functions_failed = []
functions_skipped = [
"virConnectListDomains",
- "virDomainMemoryStats"
]
skipped_modules = {
@@ -171,7 +170,6 @@ skipped_types = {
# 'int *': "usually a return type",
'virConnectDomainEventCallback': "No function types in python",
'virEventAddHandleFunc': "No function types in python",
- 'virDomainMemoryStatPtr': "Not implemented yet",
}
#######################################################################
@@ -283,6 +281,7 @@ skip_impl = (
'virNetworkGetAutostart',
'virDomainBlockStats',
'virDomainInterfaceStats',
+ 'virDomainMemoryStats',
'virNodeGetCellsFreeMemory',
'virDomainGetSchedulerType',
'virDomainGetSchedulerParameters',
diff --git a/python/libvirt-override-api.xml b/python/libvirt-override-api.xml
index 96958b5..6ae2742 100644
--- a/python/libvirt-override-api.xml
+++ b/python/libvirt-override-api.xml
@@ -105,6 +105,11 @@
<arg name='domain' type='virDomainPtr' info='a domain
object'/>
<arg name='path' type='char *' info='the path for the
interface device'/>
</function>
+ <function name='virDomainMemoryStats' file='python'>
+ <info>Extracts memory statistics for a domain</info>
+ <return type='virDomainMemoryStats' info='a dictionary of
statistics'/>
+ <arg name='domain' type='virDomainPtr' info='a domain
object'/>
+ </function>
<function name="virNodeGetCellsFreeMemory" file='python'>
<info>Returns the available memory for a list of cells</info>
<arg name='conn' type='virConnectPtr' info='pointer to the
hypervisor connection'/>
diff --git a/python/libvirt-override.c b/python/libvirt-override.c
index 6c1e51b..8aa2dad 100644
--- a/python/libvirt-override.c
+++ b/python/libvirt-override.c
@@ -120,6 +120,48 @@ libvirt_virDomainInterfaceStats(PyObject *self ATTRIBUTE_UNUSED,
PyObject *args)
return(info);
}
+static PyObject *
+libvirt_virDomainMemoryStats(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) {
+ virDomainPtr domain;
+ PyObject *pyobj_domain;
+ unsigned int nr_stats, i;
+ virDomainMemoryStatStruct stats[VIR_MEMSTAT_NR_TAGS];
+ PyObject *info;
+
+ if (!PyArg_ParseTuple(args, (char *)"O:virDomainMemoryStats",
&pyobj_domain))
+ return(NULL);
+ domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain);
+
+ nr_stats = virDomainMemoryStats(domain, stats, VIR_MEMSTAT_NR_TAGS, 0);
+ if (nr_stats == -1)
+ return VIR_PY_NONE;
+
+ /* convert to a Python dictionary */
+ if ((info = PyDict_New()) == NULL)
+ return VIR_PY_NONE;
+
+ for (i = 0; i < nr_stats; i++) {
+ if (stats[i].tag == VIR_MEMSTAT_SWAP_IN)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("swap_in"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ if (stats[i].tag == VIR_MEMSTAT_SWAP_OUT)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("swap_out"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ if (stats[i].tag == VIR_MEMSTAT_MAJOR_FAULT)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("major_fault"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ if (stats[i].tag == VIR_MEMSTAT_MINOR_FAULT)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("minor_fault"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ if (stats[i].tag == VIR_MEMSTAT_MEM_FREE)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("free_memory"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ if (stats[i].tag == VIR_MEMSTAT_MEM_TOTAL)
+ PyDict_SetItem(info, libvirt_constcharPtrWrap("total_memory"),
+ PyLong_FromUnsignedLongLong(stats[i].val));
+ }
+ return info;
+}
You're using the old tags (VIR_MEMSTAT_*) and names (free_memory,
total_memory) here.
You could convert the adjacent if blocks into and if/else if block or
a switch block.
You're also silently ignoring unknown tags here, but that should be
handled at the libvirt C API level if it should be handled at all.
Matthias
10:13 a.m.
New subject: [libvirt] [PATCH 6/6] python: Add python bindings for virDomainMemoryStats
On Fri, 2009-12-18 at 00:41 +0100, Matthias Bolte wrote:
You're using the old tags (VIR_MEMSTAT_*) and names
(free_memory,
total_memory) here.
Argh. I forgot to commit my local changes to the python patch :( This
is done and will appear in the next series.
You could convert the adjacent if blocks into and if/else if block
or
a switch block.
Sure. I will play around with it and see if I can spruce the look of
this code up a bit.
You're also silently ignoring unknown tags here, but that should
be
handled at the libvirt C API level if it should be handled at all.
Ignoring unknown tags allows us to inter-operate with a newer remote
libvirt version. So this semantic should be okay.
--
Thanks,
Adam
4:47 p.m.
New subject: [libvirt] Re: [PATCH 4/6] remote-driver: Add domainMemoryStats support
And just now I saw the comment about updating drivers so that flags can
be transmitted over the wire. I am working on this now.
--
Thanks,
Adam
4:30 a.m.
New subject: [libvirt] Re: [PATCH 4/6] remote-driver: Add domainMemoryStats support
On Thu, Dec 17, 2009 at 05:41:45PM -0500, Adam Litke wrote:
Use a dynamically sized xdr_array to pass memory stats on the wire.
This
supports the addition of future memory stats and reduces the message size since
only supported statistics are returned.
Signed-off-by: Adam Litke <agl(a)us.ibm.com>
To: libvirt list <libvir-list(a)redhat.com>
Cc: Daniel Veillard <veillard(a)redhat.com>
Cc: Daniel P. Berrange <berrange(a)redhat.com>
---
daemon/remote.c | 56 ++++++++++++++++++++++++++++++++++++++++++
src/remote/remote_driver.c | 44 ++++++++++++++++++++++++++++++++-
src/remote/remote_protocol.c | 35 ++++++++++++++++++++++++++
src/remote/remote_protocol.h | 25 ++++++++++++++++++
src/remote/remote_protocol.x | 18 ++++++++++++-
5 files changed, 176 insertions(+), 2 deletions(-)
+struct remote_domain_memory_stats_ret {
+ u_int len;
+ struct remote_domain_memory_stat *stats;
+};
+typedef struct remote_domain_memory_stats_ret remote_domain_memory_stats_ret;
+
+struct remote_domain_memory_stats_ret {
+ u_int len;
+ remote_domain_memory_stat<REMOTE_DOMAIN_MEMORY_STATS_MAX>;
+};
Something odd happened in the RPC generated code here, because rpcgen
should create you an explicit length field without you needing one. I
think it is because I forgot the param name on the array in the
example I gave you. Basically it should work just like the existing
'struct remote_domain_get_scheduler_parameters_ret' definition
struct remote_domain_memory_stats_ret {
remote_domain_memory_stat stats<REMOTE_DOMAIN_MEMORY_STATS_MAX>;
};
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
9:36 a.m.
New subject: [libvirt] Re: [PATCH 4/6] remote-driver: Add domainMemoryStats support
On Fri, 2009-12-18 at 10:30 +0000, Daniel P. Berrange wrote:
On Thu, Dec 17, 2009 at 05:41:45PM -0500, Adam Litke wrote:
> Use a dynamically sized xdr_array to pass memory stats on the wire. This
> supports the addition of future memory stats and reduces the message size since
> only supported statistics are returned.
>
> Signed-off-by: Adam Litke <agl(a)us.ibm.com>
> To: libvirt list <libvir-list(a)redhat.com>
> Cc: Daniel Veillard <veillard(a)redhat.com>
> Cc: Daniel P. Berrange <berrange(a)redhat.com>
> ---
> daemon/remote.c | 56 ++++++++++++++++++++++++++++++++++++++++++
> src/remote/remote_driver.c | 44 ++++++++++++++++++++++++++++++++-
> src/remote/remote_protocol.c | 35 ++++++++++++++++++++++++++
> src/remote/remote_protocol.h | 25 ++++++++++++++++++
> src/remote/remote_protocol.x | 18 ++++++++++++-
> 5 files changed, 176 insertions(+), 2 deletions(-)
>
> +struct remote_domain_memory_stats_ret {
> + u_int len;
> + struct remote_domain_memory_stat *stats;
> +};
> +typedef struct remote_domain_memory_stats_ret remote_domain_memory_stats_ret;
> +
> +struct remote_domain_memory_stats_ret {
> + u_int len;
> + remote_domain_memory_stat<REMOTE_DOMAIN_MEMORY_STATS_MAX>;
> +};
Something odd happened in the RPC generated code here, because rpcgen
should create you an explicit length field without you needing one. I
think it is because I forgot the param name on the array in the
example I gave you. Basically it should work just like the existing
'struct remote_domain_get_scheduler_parameters_ret' definition
I explicitly added the len parameter because I need to return the number
of elements actually updated back to the remote caller (see
remoteDomainMemoryStats). Is there another way to extract this data
using xdr without my explicit variable?
struct remote_domain_memory_stats_ret {
remote_domain_memory_stat stats<REMOTE_DOMAIN_MEMORY_STATS_MAX>;
};
Daniel
--
Thanks,
Adam
2:32 p.m.
New subject: [libvirt] Re: [PATCH 4/6] remote-driver: Add domainMemoryStats support
On Fri, Dec 18, 2009 at 09:36:11AM -0600, Adam Litke wrote:
On Fri, 2009-12-18 at 10:30 +0000, Daniel P. Berrange wrote:
> On Thu, Dec 17, 2009 at 05:41:45PM -0500, Adam Litke wrote:
> > Use a dynamically sized xdr_array to pass memory stats on the wire. This
> > supports the addition of future memory stats and reduces the message size
since
> > only supported statistics are returned.
> >
> > Signed-off-by: Adam Litke <agl(a)us.ibm.com>
> > To: libvirt list <libvir-list(a)redhat.com>
> > Cc: Daniel Veillard <veillard(a)redhat.com>
> > Cc: Daniel P. Berrange <berrange(a)redhat.com>
> > ---
> > daemon/remote.c | 56
++++++++++++++++++++++++++++++++++++++++++
> > src/remote/remote_driver.c | 44 ++++++++++++++++++++++++++++++++-
> > src/remote/remote_protocol.c | 35 ++++++++++++++++++++++++++
> > src/remote/remote_protocol.h | 25 ++++++++++++++++++
> > src/remote/remote_protocol.x | 18 ++++++++++++-
> > 5 files changed, 176 insertions(+), 2 deletions(-)
> >
>
>
> > +struct remote_domain_memory_stats_ret {
> > + u_int len;
> > + struct remote_domain_memory_stat *stats;
> > +};
> > +typedef struct remote_domain_memory_stats_ret remote_domain_memory_stats_ret;
>
>
>
> > +
> > +struct remote_domain_memory_stats_ret {
> > + u_int len;
> > + remote_domain_memory_stat<REMOTE_DOMAIN_MEMORY_STATS_MAX>;
> > +};
>
> Something odd happened in the RPC generated code here, because rpcgen
> should create you an explicit length field without you needing one. I
> think it is because I forgot the param name on the array in the
> example I gave you. Basically it should work just like the existing
> 'struct remote_domain_get_scheduler_parameters_ret' definition
I explicitly added the len parameter because I need to return the number
of elements actually updated back to the remote caller (see
remoteDomainMemoryStats). Is there another way to extract this data
using xdr without my explicit variable?
> struct remote_domain_memory_stats_ret {
> remote_domain_memory_stat stats<REMOTE_DOMAIN_MEMORY_STATS_MAX>;
> };
Take a look at the header file generated when you use this style. The
'stats' variable should end up with two fields 'stats_len' and
'stats_val'
The end result is ultimately the same as yours, but this is the explicit
XDR array syntax
Regards,
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
8:25 a.m.
Hi Adam,
thanks for your efforts, for me such an API would be very helpful.
I tried to use it by applying this patch
http://git.kernel.org/?p=linux/kernel/git/rusty/linux-2.6-for-linus.git;a...
against vanilla 2.6.32.2 and using latest libvirt from git, but when I do
$ virsh dommemstat mydomain
I just get an empty line of output, no error message, nothing. Ballooning
works fine, but as I said, no statistics output. I'm also using virtio for
net and blk - did I miss something (additional entry in the dom-config?) or
is there something going wrong?
I'm using qemu-kvm-0.11.0 currently, -0.12 is not working for me. Could that
be the cause?
Thanks for any directions,
kr,tom
8:47 a.m.
Hi Thomas,
To use the memory statistics API with qemu, you will need support in 3
places: libvirt (you're good here), qemu, and linux. The qemu and linux
parts have been accepted but are still staging. If you want to build
your own qemu and linux-kernel, let me know and I can provide you some
patches.
On Wed, 2009-12-23 at 15:25 +0100, Thomas Treutner wrote:
Hi Adam,
thanks for your efforts, for me such an API would be very helpful.
I tried to use it by applying this patch
http://git.kernel.org/?p=linux/kernel/git/rusty/linux-2.6-for-linus.git;a...
against vanilla 2.6.32.2 and using latest libvirt from git, but when I do
$ virsh dommemstat mydomain
I just get an empty line of output, no error message, nothing. Ballooning
works fine, but as I said, no statistics output. I'm also using virtio for
net and blk - did I miss something (additional entry in the dom-config?) or
is there something going wrong?
I'm using qemu-kvm-0.11.0 currently, -0.12 is not working for me. Could that
be the cause?
Thanks for any directions,
kr,tom
--
Thanks,
Adam
8:58 a.m.
Hi Adam,
On Wednesday 23 December 2009 15:47:58 Adam Litke wrote:
To use the memory statistics API with qemu, you will need support in
3
places: libvirt (you're good here), qemu, and linux. The qemu and linux
parts have been accepted but are still staging. If you want to build
your own qemu and linux-kernel, let me know and I can provide you some
patches.
yes, I'd highly appreciate that! I can use any Linux kernel that is stable
enough for dev&testing, with qemu-kvm, I wasn't lucky with all releases newer
than 0.11.0, as my VMs are stuck at boot (SeaBIOS...gPXE, then nothing
happens).
Thx&kr,
tom
5447
days inactive
5453
days old
15 comments
4 participants
participants (4)
-
Adam Litke -
Daniel P. Berrange -
Matthias Bolte -
Thomas Treutner