From 841d50358fe7fdf48f822d7df5dce0fe8039864c Mon Sep 17 00:00:00 2001 From: Adam Litke Date: Sun, 20 Dec 2009 13:43:19 +0100 Subject: [PATCH] Add domainMemoryStats support to remote driver 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. * src/remote/remote_protocol.x: provide defines for the new entry point * src/remote/remote_driver.c daemon/remote.c: implement the client and server side * daemon/remote_dispatch_args.h daemon/remote_dispatch_prototypes.h daemon/remote_dispatch_ret.h daemon/remote_dispatch_table.h src/remote/remote_protocol.c src/remote/remote_protocol.h: generated stubs --- daemon/remote.c | 56 +++++++++++++++++++++++++++++ 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 | 45 ++++++++++++++++++++++- src/remote/remote_protocol.c | 35 ++++++++++++++++++ src/remote/remote_protocol.h | 29 +++++++++++++++ src/remote/remote_protocol.x | 21 ++++++++++- 9 files changed, 199 insertions(+), 2 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index 1b6be424eb..0b30131b2c 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -707,6 +707,62 @@ remoteDispatchDomainInterfaceStats (struct qemud_server *server ATTRIBUTE_UNUSED return 0; } +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.stats_val, 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.stats_val[i].tag = stats[i].tag; + ret->stats.stats_val[i].val = stats[i].val; + } + 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, diff --git a/daemon/remote_dispatch_args.h b/daemon/remote_dispatch_args.h index 82264fcb3b..c1801d0f8b 100644 --- a/daemon/remote_dispatch_args.h +++ b/daemon/remote_dispatch_args.h @@ -134,3 +134,4 @@ remote_storage_pool_is_persistent_args val_remote_storage_pool_is_persistent_args; remote_interface_is_active_args val_remote_interface_is_active_args; remote_cpu_compare_args val_remote_cpu_compare_args; + remote_domain_memory_stats_args val_remote_domain_memory_stats_args; diff --git a/daemon/remote_dispatch_prototypes.h b/daemon/remote_dispatch_prototypes.h index 98f2ef2ee9..1a0f8d8f06 100644 --- a/daemon/remote_dispatch_prototypes.h +++ b/daemon/remote_dispatch_prototypes.h @@ -282,6 +282,14 @@ static int remoteDispatchDomainMemoryPeek( remote_error *err, remote_domain_memory_peek_args *args, remote_domain_memory_peek_ret *ret); +static int remoteDispatchDomainMemoryStats( + struct qemud_server *server, + struct qemud_client *client, + virConnectPtr conn, + remote_message_header *hdr, + remote_error *err, + remote_domain_memory_stats_args *args, + remote_domain_memory_stats_ret *ret); static int remoteDispatchDomainMigrateFinish( struct qemud_server *server, struct qemud_client *client, diff --git a/daemon/remote_dispatch_ret.h b/daemon/remote_dispatch_ret.h index cee29ccd49..d7811deaa6 100644 --- a/daemon/remote_dispatch_ret.h +++ b/daemon/remote_dispatch_ret.h @@ -116,3 +116,4 @@ remote_interface_is_active_ret val_remote_interface_is_active_ret; remote_get_lib_version_ret val_remote_get_lib_version_ret; remote_cpu_compare_ret val_remote_cpu_compare_ret; + remote_domain_memory_stats_ret val_remote_domain_memory_stats_ret; diff --git a/daemon/remote_dispatch_table.h b/daemon/remote_dispatch_table.h index 72b70935de..09ebeeeb05 100644 --- a/daemon/remote_dispatch_table.h +++ b/daemon/remote_dispatch_table.h @@ -797,3 +797,8 @@ .args_filter = (xdrproc_t) xdr_remote_cpu_compare_args, .ret_filter = (xdrproc_t) xdr_remote_cpu_compare_ret, }, +{ /* DomainMemoryStats => 159 */ + .fn = (dispatch_fn) remoteDispatchDomainMemoryStats, + .args_filter = (xdrproc_t) xdr_remote_domain_memory_stats_args, + .ret_filter = (xdrproc_t) xdr_remote_domain_memory_stats_ret, +}, diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 7ed74a5bc5..945fa30fe1 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -3365,6 +3365,49 @@ done: return rv; } +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; + args.flags = 0; + 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.stats.stats_len; i++) { + stats[i].tag = ret.stats.stats_val[i].tag; + stats[i].val = ret.stats.stats_val[i].val; + } + rv = ret.stats.stats_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, @@ -8841,7 +8884,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 07724095d3..834eb6bf66 100644 --- a/src/remote/remote_protocol.c +++ b/src/remote/remote_protocol.c @@ -596,6 +596,41 @@ xdr_remote_domain_interface_stats_ret (XDR *xdrs, remote_domain_interface_stats_ return TRUE; } +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; + if (!xdr_u_int (xdrs, &objp->flags)) + return FALSE; + return TRUE; +} + +bool_t +xdr_remote_domain_memory_stat (XDR *xdrs, remote_domain_memory_stat *objp) +{ + + if (!xdr_int (xdrs, &objp->tag)) + return FALSE; + if (!xdr_uint64_t (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.stats_val; + + if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->stats.stats_len, REMOTE_DOMAIN_MEMORY_STATS_MAX, + sizeof (remote_domain_memory_stat), (xdrproc_t) xdr_remote_domain_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 f8124f1b4e..3f3b5207a8 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,27 @@ 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; + u_int flags; +}; +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 { + struct { + u_int stats_len; + remote_domain_memory_stat *stats_val; + } 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; @@ -1789,6 +1811,7 @@ enum remote_procedure { REMOTE_PROC_INTERFACE_IS_ACTIVE = 156, REMOTE_PROC_GET_LIB_VERSION = 157, REMOTE_PROC_CPU_COMPARE = 158, + REMOTE_PROC_DOMAIN_MEMORY_STATS = 159, }; typedef enum remote_procedure remote_procedure; @@ -1865,6 +1888,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_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_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*); @@ -2138,6 +2164,9 @@ 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_stat (); +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 32820cd0d5..bed3940aa4 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -115,6 +115,9 @@ const REMOTE_AUTH_SASL_DATA_MAX = 65536; /* Maximum number of auth types */ const REMOTE_AUTH_TYPE_LIST_MAX = 20; +/* Upper limit on list of memory stats */ +const REMOTE_DOMAIN_MEMORY_STATS_MAX = 1024; + /* Maximum length of a block peek buffer message. * Note applications need to be aware of this limit and issue multiple * requests for large amounts of data. @@ -405,6 +408,21 @@ struct remote_domain_interface_stats_ret { hyper tx_drop; }; +struct remote_domain_memory_stats_args { + remote_nonnull_domain dom; + u_int maxStats; + u_int flags; +}; + +struct remote_domain_memory_stat { + int tag; + unsigned hyper val; +}; + +struct remote_domain_memory_stats_ret { + remote_domain_memory_stat stats; +}; + struct remote_domain_block_peek_args { remote_nonnull_domain dom; remote_nonnull_string path; @@ -1622,7 +1640,8 @@ enum remote_procedure { REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT = 155, REMOTE_PROC_INTERFACE_IS_ACTIVE = 156, REMOTE_PROC_GET_LIB_VERSION = 157, - REMOTE_PROC_CPU_COMPARE = 158 + REMOTE_PROC_CPU_COMPARE = 158, + REMOTE_PROC_DOMAIN_MEMORY_STATS = 159 /* * Notice how the entries are grouped in sets of 10 ?