cpuacct cgroup provides per cpu cputime. Add an interface for that. Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu(a)jp.fujitsu.com&gt; --- src/libvirt_private.syms | 1 + src/util/cgroup.c | 27 +++++++++++++++++++++++++++ src/util/cgroup.h | 2 ++ 3 files changed, 30 insertions(+), 0 deletions(-) diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index ba7739d..f7a1ee7 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -70,6 +70,7 @@ virCgroupFree; virCgroupGetBlkioWeight; virCgroupGetCpuShares; virCgroupGetCpuacctUsage; +virCgroupGetCpuacctUsagePercpu; virCgroupGetFreezerState; virCgroupGetMemoryHardLimit; virCgroupGetMemorySoftLimit; diff --git a/src/util/cgroup.c b/src/util/cgroup.c index afe8731..58ea805 100644 --- a/src/util/cgroup.c +++ b/src/util/cgroup.c @@ -1329,6 +1329,33 @@ int virCgroupGetCpuacctUsage(virCgroupPtr group, unsigned long long *usage) "cpuacct.usage", usage); } +int virCgroupGetCpuacctUsagePercpu(virCgroupPtr group, + int nr, unsigned long long *usage) +{ + int i, rc; + char *strval = NULL; + char *startp, *endp; + unsigned long long int value; + + memset(usage, 0, sizeof(unsigned long long) * nr); + + rc = virCgroupGetValueStr(group, VIR_CGROUP_CONTROLLER_CPUACCT, + "cpuacct.usage_percpu", &strval); + if (rc) + goto out; + + for (i = 0, startp = strval; i < nr; i++) { + if (virStrToLong_ull(startp, &endp, 10, &value)) + break; + startp = endp; + usage[i] = value; + } + rc = i; +out: + VIR_FREE(strval); + return rc; +} + int virCgroupSetFreezerState(virCgroupPtr group, const char *state) { return virCgroupSetValueStr(group, diff --git a/src/util/cgroup.h b/src/util/cgroup.h index 8ae756d..31cbcba 100644 --- a/src/util/cgroup.h +++ b/src/util/cgroup.h @@ -100,6 +100,8 @@ int virCgroupSetCpuShares(virCgroupPtr group, unsigned long long shares); int virCgroupGetCpuShares(virCgroupPtr group, unsigned long long *shares); int virCgroupGetCpuacctUsage(virCgroupPtr group, unsigned long long *usage); +int virCgroupGetCpuacctUsagePercpu(virCgroupPtr group, + int nr, unsigned long long *usage); int virCgroupSetFreezerState(virCgroupPtr group, const char *state); int virCgroupGetFreezerState(virCgroupPtr group, char **state); -- 1.7.4.1

2011/4/15 KAMEZAWA Hiroyuki <kamezawa.hiroyu(a)jp.fujitsu.com&gt;: NACK to adding another public struct to the API. It's not expendable. As a stylistic nit pleas don't use the term PCPU as this looks like "Physical CPU". Just call it virDomainPerVcpuStat at least. Also do you really need the absolute CPU time? As noted elsewhere, this is in fact not implementable for ESX. But ESX can provide the virtual CPU utilization in MHz and percent. See the virNodeGetCpuTime series [1] for a better approach. [1] https://www.redhat.com/archives/libvir-list/2011-April/msg00702.html Matthias

On Fri, Apr 15, 2011 at 04:43:03PM +0900, KAMEZAWA Hiroyuki wrote: I don't think that is correct. What virt-top ultimately displays to the end user is a % utilization. So it would be happy to get data in either % util & display that directly, or get absolute CPU time and calculate deltas to display % util. I wonder if we could provide an API that could be used to provide either per-VCPU or per-PCPU statistics in one go, so that we can finally have an API for cpu time that works well for VMWare. eg typedef struct _virDomainCPUTime virDomainCPUTime; typedef virDomainCPUTime *virDomainCPUTimePtr; #define VIR_DOMAIN_CPUTIME_ABS "abs" #define VIR_DOMAIN_CPUTIME_UTIL "util" ...define more stats later if desired... struct _virDomainCPUTime { char field[VIR_DOMAIN_CPU_TIME_FIELD_LENGTH]; unsigned long long value; }; typedef enum { VIR_DOMAIN_CPU_TIME_VIRTUAL = 0, VIR_DOMAIN_CPU_TIME_PHYSICAL = 1, } virDomainCPUTimeFlags; int virDomainGetCPUTime(virDomainPtr dom, virDomainCPUTimePtr stats, int *nstats, unsigned int flags); When querying per-virtual CPU time, nstats would be the number of virtual CPUs in the guest. eg virDomainInfo info; virDomainGetInfo(dom, &info); virDomainCPUTimePtr stats; stats = malloc(sizeof(*stats)*info.nrVirtCPU); virDomainGetCPUTime(dom, stats, info.nrVirtCPU, VIR_DOMAIN_CPU_TIME_VIRTUAL); Or to get the break down per physical CPU, use the VIR_NODEINFO_MAX_CPUS macro virNodeInfo info; virNodeGetInfo(conn, &info); virDomainCPUTimePtr stats; stats = malloc(sizeof(*stats)*VIR_NODEINFO_MAX_CPUS(info)) virDomainGetCPUTime(dom, stats, VIR_NODEINFO_MAX_CPUS(info), VIR_DOMAIN_CPU_TIME_PHYSICAL); We could also allow 'nstats' to be 0, in which case the API would simply populate 'nstats' with the required number and return. The caller can then re-invoke with correct nstats and allocated memory. Daniel -- |: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :| |: http://libvirt.org -o- http://virt-manager.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|

Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu(a)jp.fujitsu.com&gt; --- daemon/remote.c | 61 +++++++++++++++++++++++++++++++++++ daemon/remote_dispatch_args.h | 1 + daemon/remote_dispatch_prototypes.h | 8 ++++ daemon/remote_dispatch_ret.h | 1 + daemon/remote_dispatch_table.h | 5 +++ src/remote/remote_driver.c | 39 +++++++++++++++++++++- src/remote/remote_protocol.c | 31 ++++++++++++++++++ src/remote/remote_protocol.h | 27 +++++++++++++++ src/remote/remote_protocol.x | 18 ++++++++++- 9 files changed, 189 insertions(+), 2 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index 5de1055..9757f13 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -1138,6 +1138,67 @@ remoteDispatchDomainMemoryStats(struct qemud_server *server ATTRIBUTE_UNUSED, } static int +remoteDispatchDomainPcpuStats(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_pcpu_stats_args *args, + remote_domain_pcpu_stats_ret *ret) +{ + virDomainPtr dom; + struct _virDomainPcpuStat *stats; + unsigned int nr_stats, i; + + if (!conn) { + remoteDispatchFormatError(rerr, "%s", _("connection not open")); + return -1; + } + + if (args->nr_stats > REMOTE_DOMAIN_PCPU_STATS_MAX) { + remoteDispatchFormatError(rerr, "%s", + _("nr_stats > REMOTE_DOMAIN_PCPU_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->nr_stats) < 0) { + virDomainFree(dom); + remoteDispatchOOMError(rerr); + return -1; + } + + nr_stats = virDomainPcpuStats(dom, stats, args->nr_stats, 0); + if (nr_stats == -1) { + VIR_FREE(stats); + remoteDispatchConnError(rerr, conn); + virDomainFree(dom); + return -1; + } + virDomainFree(dom); + + /* Allocate return buffer */ + if (VIR_ALLOC_N(ret->stats.stats_val, nr_stats) < 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.stats_val[i].val = stats[i].cpuTime; + ret->stats.stats_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/daemon/remote_dispatch_args.h b/daemon/remote_dispatch_args.h index f9537d7..42fc7b2 100644 --- a/daemon/remote_dispatch_args.h +++ b/daemon/remote_dispatch_args.h @@ -178,3 +178,4 @@ remote_domain_migrate_set_max_speed_args val_remote_domain_migrate_set_max_speed_args; remote_storage_vol_upload_args val_remote_storage_vol_upload_args; remote_storage_vol_download_args val_remote_storage_vol_download_args; + remote_domain_pcpu_stats_args val_remote_domain_pcpu_stats_args; diff --git a/daemon/remote_dispatch_prototypes.h b/daemon/remote_dispatch_prototypes.h index 18bf41d..5dece04 100644 --- a/daemon/remote_dispatch_prototypes.h +++ b/daemon/remote_dispatch_prototypes.h @@ -498,6 +498,14 @@ static int remoteDispatchDomainOpenConsole( remote_error *err, remote_domain_open_console_args *args, void *ret); +static int remoteDispatchDomainPcpuStats( + struct qemud_server *server, + struct qemud_client *client, + virConnectPtr conn, + remote_message_header *hdr, + remote_error *err, + remote_domain_pcpu_stats_args *args, + remote_domain_pcpu_stats_ret *ret); static int remoteDispatchDomainPinVcpu( struct qemud_server *server, struct qemud_client *client, diff --git a/daemon/remote_dispatch_ret.h b/daemon/remote_dispatch_ret.h index 114e832..4c0b66d 100644 --- a/daemon/remote_dispatch_ret.h +++ b/daemon/remote_dispatch_ret.h @@ -140,3 +140,4 @@ remote_domain_is_updated_ret val_remote_domain_is_updated_ret; remote_get_sysinfo_ret val_remote_get_sysinfo_ret; remote_domain_get_blkio_parameters_ret val_remote_domain_get_blkio_parameters_ret; + remote_domain_pcpu_stats_ret val_remote_domain_pcpu_stats_ret; diff --git a/daemon/remote_dispatch_table.h b/daemon/remote_dispatch_table.h index b39f7c2..cb1fa05 100644 --- a/daemon/remote_dispatch_table.h +++ b/daemon/remote_dispatch_table.h @@ -1052,3 +1052,8 @@ .args_filter = (xdrproc_t) xdr_remote_storage_vol_download_args, .ret_filter = (xdrproc_t) xdr_void, }, +{ /* DomainPcpuStats => 210 */ + .fn = (dispatch_fn) remoteDispatchDomainPcpuStats, + .args_filter = (xdrproc_t) xdr_remote_domain_pcpu_stats_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_pcpu_stats_ret, +}, diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index d00b9ee..6f7c2e7 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -4172,6 +4172,43 @@ done: return rv; } + +static int +remoteDomainPcpuStats (virDomainPtr domain, + struct _virDomainPcpuStat *stats, + unsigned int nr_stats) +{ + int rv = -1; + remote_domain_pcpu_stats_args args; + remote_domain_pcpu_stats_ret ret; + struct private_data *priv = domain->conn->privateData; + unsigned int i; + + remoteDriverLock(priv); + + make_nonnull_domain (&args.dom, domain); + args.nr_stats = nr_stats; + + memset (&ret, 0, sizeof ret); + + if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_PCPU_STATS, + (xdrproc_t) xdr_remote_domain_pcpu_stats_args, + (char *) &args, + (xdrproc_t) xdr_remote_domain_pcpu_stats_ret, + (char *) &ret) == -1) + goto done; + + for (i = 0; i < ret.stats.stats_len; i++) + stats[i].cpuTime = ret.stats.stats_val[i].val; + rv = ret.stats.stats_len; + xdr_free((xdrproc_t) xdr_remote_domain_pcpu_stats_ret, (char *) &ret); + + done: + remoteDriverUnlock(priv); + return rv; +} + + static int remoteDomainBlockPeek (virDomainPtr domain, const char *path, @@ -11261,7 +11298,7 @@ static virDriver remote_driver = { remoteDomainBlockStats, /* domainBlockStats */ remoteDomainInterfaceStats, /* domainInterfaceStats */ remoteDomainMemoryStats, /* domainMemoryStats */ - NULL, /* domainPcpuStats */ + remoteDomainPcpuStats, /* domainPcpuStats */ remoteDomainBlockPeek, /* domainBlockPeek */ remoteDomainMemoryPeek, /* domainMemoryPeek */ remoteDomainGetBlockInfo, /* domainGetBlockInfo */ diff --git a/src/remote/remote_protocol.c b/src/remote/remote_protocol.c index 5604371..53825ea 100644 --- a/src/remote/remote_protocol.c +++ b/src/remote/remote_protocol.c @@ -872,6 +872,37 @@ xdr_remote_domain_memory_stats_ret (XDR *xdrs, remote_domain_memory_stats_ret *o } bool_t +xdr_remote_domain_pcpu_stats_args (XDR *xdrs, remote_domain_pcpu_stats_args *objp) +{ + + if (!xdr_remote_nonnull_domain (xdrs, &objp->dom)) + return FALSE; + if (!xdr_u_int (xdrs, &objp->nr_stats)) + return FALSE; + return TRUE; +} + +bool_t +xdr_remote_domain_pcpu_stat (XDR *xdrs, remote_domain_pcpu_stat *objp) +{ + + if (!xdr_uint64_t (xdrs, &objp->val)) + return FALSE; + return TRUE; +} + +bool_t +xdr_remote_domain_pcpu_stats_ret (XDR *xdrs, remote_domain_pcpu_stats_ret *objp) +{ + char **objp_cpp0 = (char **) (void *) &objp->stats.stats_val; + + if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->stats.stats_len, REMOTE_DOMAIN_PCPU_STATS_MAX, + sizeof (remote_domain_pcpu_stat), (xdrproc_t) xdr_remote_domain_pcpu_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 d9bf151..f220de9 100644 --- a/src/remote/remote_protocol.h +++ b/src/remote/remote_protocol.h @@ -59,6 +59,7 @@ typedef remote_nonnull_string *remote_string; #define REMOTE_AUTH_SASL_DATA_MAX 65536 #define REMOTE_AUTH_TYPE_LIST_MAX 20 #define REMOTE_DOMAIN_MEMORY_STATS_MAX 1024 +#define REMOTE_DOMAIN_PCPU_STATS_MAX 1024 #define REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX 1024 #define REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX 65536 #define REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX 65536 @@ -463,6 +464,25 @@ struct remote_domain_memory_stats_ret { }; typedef struct remote_domain_memory_stats_ret remote_domain_memory_stats_ret; +struct remote_domain_pcpu_stats_args { + remote_nonnull_domain dom; + u_int nr_stats; +}; +typedef struct remote_domain_pcpu_stats_args remote_domain_pcpu_stats_args; + +struct remote_domain_pcpu_stat { + uint64_t val; +}; +typedef struct remote_domain_pcpu_stat remote_domain_pcpu_stat; + +struct remote_domain_pcpu_stats_ret { + struct { + u_int stats_len; + remote_domain_pcpu_stat *stats_val; + } stats; +}; +typedef struct remote_domain_pcpu_stats_ret remote_domain_pcpu_stats_ret; + struct remote_domain_block_peek_args { remote_nonnull_domain dom; remote_nonnull_string path; @@ -2413,6 +2433,7 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED = 207, REMOTE_PROC_STORAGE_VOL_UPLOAD = 208, REMOTE_PROC_STORAGE_VOL_DOWNLOAD = 209, + REMOTE_PROC_DOMAIN_PCPU_STATS = 210, }; typedef enum remote_procedure remote_procedure; @@ -2507,6 +2528,9 @@ extern bool_t xdr_remote_domain_interface_stats_ret (XDR *, remote_domain_inter extern bool_t xdr_remote_domain_memory_stats_args (XDR *, remote_domain_memory_stats_args*); extern bool_t xdr_remote_domain_memory_stat (XDR *, remote_domain_memory_stat*); extern bool_t xdr_remote_domain_memory_stats_ret (XDR *, remote_domain_memory_stats_ret*); +extern bool_t xdr_remote_domain_pcpu_stats_args (XDR *, remote_domain_pcpu_stats_args*); +extern bool_t xdr_remote_domain_pcpu_stat (XDR *, remote_domain_pcpu_stat*); +extern bool_t xdr_remote_domain_pcpu_stats_ret (XDR *, remote_domain_pcpu_stats_ret*); 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*); @@ -2864,6 +2888,9 @@ 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_stat (); extern bool_t xdr_remote_domain_memory_stats_ret (); +extern bool_t xdr_remote_domain_pcpu_stats_args (); +extern bool_t xdr_remote_domain_pcpu_stat (); +extern bool_t xdr_remote_domain_pcpu_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 675eccd..7ab7704 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -146,6 +146,9 @@ const REMOTE_AUTH_TYPE_LIST_MAX = 20; /* Upper limit on list of memory stats */ const REMOTE_DOMAIN_MEMORY_STATS_MAX = 1024; +/* Upper limit on list of pcpu stats */ +const REMOTE_DOMAIN_PCPU_STATS_MAX = 1024; + /* Upper limit on lists of domain snapshots. */ const REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX = 1024; @@ -554,6 +557,18 @@ struct remote_domain_memory_stats_ret { remote_domain_memory_stat stats<REMOTE_DOMAIN_MEMORY_STATS_MAX>; }; +struct remote_domain_pcpu_stats_args { + remote_nonnull_domain dom; + u_int nr_stats; +}; + +struct remote_domain_pcpu_stat { + unsigned hyper val; +}; +struct remote_domain_pcpu_stats_ret { + remote_domain_pcpu_stat stats<REMOTE_DOMAIN_PCPU_STATS_MAX>; +}; + struct remote_domain_block_peek_args { remote_nonnull_domain dom; remote_nonnull_string path; @@ -2176,7 +2191,8 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_GET_BLKIO_PARAMETERS = 206, REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED = 207, REMOTE_PROC_STORAGE_VOL_UPLOAD = 208, - REMOTE_PROC_STORAGE_VOL_DOWNLOAD = 209 + REMOTE_PROC_STORAGE_VOL_DOWNLOAD = 209, + REMOTE_PROC_DOMAIN_PCPU_STATS = 210 /* * Notice how the entries are grouped in sets of 10 ? -- 1.7.4.1

Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu(a)jp.fujitsu.com&gt; --- src/qemu/qemu_conf.c | 1 + src/qemu/qemu_driver.c | 71 +++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 71 insertions(+), 1 deletions(-) diff --git a/src/qemu/qemu_conf.c b/src/qemu/qemu_conf.c index bb5421b..89c5b4c 100644 --- a/src/qemu/qemu_conf.c +++ b/src/qemu/qemu_conf.c @@ -302,6 +302,7 @@ int qemudLoadDriverConfig(struct qemud_driver *driver, } else { driver->cgroupControllers = (1 << VIR_CGROUP_CONTROLLER_CPU) | + (1 << VIR_CGROUP_CONTROLLER_CPUACCT) | (1 << VIR_CGROUP_CONTROLLER_DEVICES) | (1 << VIR_CGROUP_CONTROLLER_MEMORY) | (1 << VIR_CGROUP_CONTROLLER_BLKIO); diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 0a78a70..6db4f8a 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -5011,6 +5011,75 @@ cleanup: } static int +qemuDomainPcpuStats (virDomainPtr dom, + struct _virDomainPcpuStat *stats, + unsigned int nr_stats) +{ + struct qemud_driver *driver = dom->conn->privateData; + virDomainObjPtr vm = NULL; + virCgroupPtr group = NULL; + int ret = -1; + unsigned long long *array = NULL; + int i; + + + qemuDriverLock(driver); + if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPUACCT)) { + qemuDriverUnlock(driver); + qemuReportError(VIR_ERR_OPERATION_INVALID, + "%s", _("cgroup CPUACCT controller is not mounted")); + goto cleanup; + } + + vm = virDomainFindByUUID(&driver->domains, dom->uuid); + qemuDriverUnlock(driver); + + if (!vm) { + char uuidstr[VIR_UUID_STRING_BUFLEN]; + virUUIDFormat(dom->uuid, uuidstr); + qemuReportError(VIR_ERR_NO_DOMAIN, + _("no domain with matching uuid '%s'"), uuidstr); + goto cleanup; + } + + if (VIR_ALLOC_N(array, nr_stats) < 0) { + virReportOOMError(); + goto cleanup; + } + + if (!virDomainObjIsActive(vm)) { + qemuReportError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + goto cleanup; + } + + if (virCgroupForDomain(driver->cgroup, vm->def->name, &group, 0) != 0) { + qemuReportError(VIR_ERR_INTERNAL_ERROR, + _("cannot find cgroup for domain %s"), vm->def->name); + goto cleanup; + } + + ret = virCgroupGetCpuacctUsagePercpu(group, nr_stats, array); + if (ret <= 0) { + ret = -1; + goto cleanup; + } + + for (i = 0; i < ret; i++) + stats[i].cpuTime = array[i]; + +cleanup: + if (group) + virCgroupFree(&group); + VIR_FREE(array); + if (vm) + virDomainObjUnlock(vm); + return ret; +} + + + +static int qemudDomainBlockPeek (virDomainPtr dom, const char *path, unsigned long long offset, size_t size, @@ -6981,7 +7050,7 @@ static virDriver qemuDriver = { qemudDomainBlockStats, /* domainBlockStats */ qemudDomainInterfaceStats, /* domainInterfaceStats */ qemudDomainMemoryStats, /* domainMemoryStats */ - NULL, /* domainPcpuStats */ + qemuDomainPcpuStats, /* domainPcpuStats */ qemudDomainBlockPeek, /* domainBlockPeek */ qemudDomainMemoryPeek, /* domainMemoryPeek */ qemuDomainGetBlockInfo, /* domainGetBlockInfo */ -- 1.7.4.1