9:42 a.m.
v1:
https://www.redhat.com/archives/libvir-list/2012-September/msg00517.html
v1 - v2:
* Rename virNode{Get,Set}SharedMemoryParameters to
virNode{Get,Set}MemoryParameters, in case of we could add more
node memory tunables in future.
v2 - v3:
* Add prefix "shm_" to the shared memory parameter field.
* Change REMOTE_NODE_MEMORY_PARAMETERS_MAX from 16 to 64.
* Helper fucntions for internal APIs (node{Get,Set}MemoryParameters)
* Add "shm" prefix for the virsh options.
As a result of RFC:
https://www.redhat.com/archives/libvir-list/2012-August/msg01998.html,
this adds two new APIs (virNode{Get,Set}MemoryParameters) to get
and set the host shared memory tunables (ksm under linux).
Osier Yang (6):
node_memory: Define the APIs to get/set memory parameters
node_memory: Wire up the RPC protocol
node_memory: Implement the internal APIs
node_memory: Support get/set memory parameters for drivers
node_memory: Expose the APIs to virsh
node_memory: Expose the APIs to Python bindings
daemon/remote.c | 59 +++++++++
include/libvirt/libvirt.h.in | 63 ++++++++++
python/generator.py | 2 +
python/libvirt-override-api.xml | 13 ++
python/libvirt-override.c | 125 ++++++++++++++++++++
src/driver.h | 14 ++
src/libvirt.c | 121 +++++++++++++++++++
src/libvirt_private.syms | 2 +
src/libvirt_public.syms | 2 +
src/lxc/lxc_driver.c | 2 +
src/nodeinfo.c | 249 +++++++++++++++++++++++++++++++++++++++
src/nodeinfo.h | 10 ++
src/qemu/qemu_driver.c | 2 +
src/remote/remote_driver.c | 50 ++++++++
src/remote/remote_protocol.x | 24 ++++-
src/remote_protocol-structs | 20 +++
src/rpc/gendispatch.pl | 3 +
src/uml/uml_driver.c | 2 +
src/xen/xen_driver.c | 3 +
tools/virsh-host.c | 116 ++++++++++++++++++
tools/virsh.pod | 8 ++
21 files changed, 889 insertions(+), 1 deletions(-)
--
1.7.7.3
9:42 a.m.
New subject: [libvirt] [PATCH 1/6] node_memory: Define the APIs to get/set memory parameters
* include/libvirt/libvirt.h.in: (Add macros for the param fields,
declare the APIs).
* src/driver.h: (New methods for the driver struct)
* src/libvirt.c: (Implement the public APIs)
* src/libvirt_public.syms: (Export the public symbols)
---
include/libvirt/libvirt.h.in | 63 ++++++++++++++++++++++
python/generator.py | 2 +
src/driver.h | 14 +++++
src/libvirt.c | 121 ++++++++++++++++++++++++++++++++++++++++++
src/libvirt_public.syms | 2 +
5 files changed, 202 insertions(+), 0 deletions(-)
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index ca04f6c..db61820 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -4305,6 +4305,69 @@ typedef struct _virTypedParameter virMemoryParameter;
*/
typedef virMemoryParameter *virMemoryParameterPtr;
+/*
+ * VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN:
+ *
+ * Macro for typed parameter that represents how many present pages
+ * to scan before the shared memory service goes to sleep.
+ */
+# define VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN "shm_pages_to_scan"
+
+/*
+ * VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS:
+ *
+ * Macro for typed parameter that represents how many milliseconds
+ * the shared memory service should sleep before next scan.
+ */
+# define VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS "shm_sleep_millisecs"
+
+/*
+ * VIR_NODE_MEMORY_SHARED_PAGES_SHARED:
+ *
+ * Macro for typed parameter that represents how many the shared
+ * mmeory pages are being used.
+ */
+# define VIR_NODE_MEMORY_SHARED_PAGES_SHARED "shm_pages_shared"
+
+/*
+ * VIR_NODE_MEMORY_SHARED_PAGES_SHARING:
+ *
+ * Macro for typed parameter that represents how many sites are
+ * sharing the pages i.e. how much saved.
+ */
+# define VIR_NODE_MEMORY_SHARED_PAGES_SHARING "shm_pages_sharing"
+
+/* VIR_NODE_MEMORY_SHARED_PAGES_UNSHARED:
+ *
+ * Macro for typed parameter that represents how many pages unique
+ * but repeatedly checked for merging.
+ */
+# define VIR_NODE_MEMORY_SHARED_PAGES_UNSHARED "shm_pages_unshared"
+
+/* VIR_NODE_MEMORY_SHARED_PAGES_VOLATILE:
+ *
+ * Macro for typed parameter that represents how many pages changing
+ * too fast to be placed in a tree.
+ */
+# define VIR_NODE_MEMORY_SHARED_PAGES_VOLATILE "shm_pages_volatile"
+
+/* VIR_NODE_MEMORY_SHARED_FULL_SCAN:
+ *
+ * Macro for typed parameter that represents how many times all
+ * mergeable areas have been scanned.
+ */
+# define VIR_NODE_MEMORY_SHARED_FULL_SCANS "shm_full_scans"
+
+int virNodeGetMemoryParameters(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags);
+
+int virNodeSetMemoryParameters(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int nparams,
+ unsigned int flags);
+
#ifdef __cplusplus
}
#endif
diff --git a/python/generator.py b/python/generator.py
index 8f6e455..8a73a9f 100755
--- a/python/generator.py
+++ b/python/generator.py
@@ -427,6 +427,8 @@ skip_impl = (
'virDomainGetDiskErrors',
'virConnectUnregisterCloseCallback',
'virConnectRegisterCloseCallback',
+ 'virNodeGetMemoryParameters',
+ 'virNodeSetMemoryParameters',
)
qemu_skip_impl = (
diff --git a/src/driver.h b/src/driver.h
index 518e9d4..0eae601 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -882,6 +882,18 @@ typedef char *
const char *uri,
unsigned int flags);
+typedef int
+ (*virDrvNodeGetMemoryParameters)(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags);
+
+typedef int
+ (*virDrvNodeSetMemoryParameters)(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int nparams,
+ unsigned int flags);
+
/**
* _virDriver:
*
@@ -1068,6 +1080,8 @@ struct _virDriver {
virDrvDomainGetDiskErrors domainGetDiskErrors;
virDrvDomainSetMetadata domainSetMetadata;
virDrvDomainGetMetadata domainGetMetadata;
+ virDrvNodeGetMemoryParameters nodeGetMemoryParameters;
+ virDrvNodeSetMemoryParameters nodeSetMemoryParameters;
};
typedef int
diff --git a/src/libvirt.c b/src/libvirt.c
index 6e25baf..d451ec8 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -6720,6 +6720,127 @@ error:
return -1;
}
+/*
+ * virNodeGetMemoryParameters:
+ * @conn: pointer to the hypervisor connection
+ * @params: pointer to memory parameter object
+ * (return value, allocated by the caller)
+ * @nparams: pointer to number of memory parameters; input and output
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * Get all node memory parameters. On input, @nparams gives the size
+ * of the @params array; on output, @nparams gives how many slots were
+ * filled with parameter information, which might be less but will
+ * not exceed the input value.
+ *
+ * As a special case, calling with @params as NULL and @nparams as 0 on
+ * input will cause @nparams on output to contain the number of parameters
+ * supported by the hypervisor. The caller should then allocate @params
+ * array, i.e. (sizeof(@virTypedParameter) * @nparams) bytes and call the API
+ * again. See virDomainGetMemoryParameters() for an equivalent usage
+ * example.
+ *
+ * Returns 0 in case of success, and -1 in case of failure.
+ */
+int
+virNodeGetMemoryParameters(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags)
+{
+ VIR_DEBUG("conn=%p, params=%p, nparams=%p, flags=%x",
+ conn, params, nparams, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECT(conn)) {
+ virLibConnError(VIR_ERR_INVALID_CONN, __FUNCTION__);
+ virDispatchError(NULL);
+ return -1;
+ }
+
+ virCheckNonNullArgGoto(nparams, error);
+ virCheckNonNegativeArgGoto(*nparams, error);
+ if (*nparams != 0)
+ virCheckNonNullArgGoto(params, error);
+
+ if (VIR_DRV_SUPPORTS_FEATURE(conn->driver, conn,
+ VIR_DRV_FEATURE_TYPED_PARAM_STRING))
+ flags |= VIR_TYPED_PARAM_STRING_OKAY;
+
+ if (conn->driver->nodeGetMemoryParameters) {
+ int ret;
+ ret = conn->driver->nodeGetMemoryParameters(conn, params,
+ nparams, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ virDispatchError(conn);
+ return -1;
+}
+
+/*
+ * virNodeSetMemoryParameters:
+ * @conn: pointer to the hypervisor connection
+ * @params: pointer to scheduler parameter objects
+ * @nparams: number of scheduler parameter objects
+ * (this value can be the same or less than the returned
+ * value nparams of virDomainGetSchedulerType)
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * Change all or a subset of the node memory tunables.
+ * This function may require privileged access to the hypervisor.
+ *
+ * Returns 0 in case of success, -1 in case of failure.
+ */
+int
+virNodeSetMemoryParameters(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int nparams,
+ unsigned int flags)
+{
+ VIR_DEBUG("conn=%p, params=%p, nparams=%d, flags=%x",
+ conn, params, nparams, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECT(conn)) {
+ virLibConnError(VIR_ERR_INVALID_CONN, __FUNCTION__);
+ virDispatchError(NULL);
+ return -1;
+ }
+
+ if (conn->flags & VIR_CONNECT_RO) {
+ virLibConnError(VIR_ERR_OPERATION_DENIED, __FUNCTION__);
+ goto error;
+ }
+
+ virCheckNonNullArgGoto(params, error);
+ virCheckNonNegativeArgGoto(nparams, error);
+
+ if (virTypedParameterValidateSet(conn, params, nparams) < 0)
+ goto error;
+
+ if (conn->driver->nodeSetMemoryParameters) {
+ int ret;
+ ret = conn->driver->nodeSetMemoryParameters(conn, params,
+ nparams, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ virDispatchError(conn);
+ return -1;
+}
/**
* virDomainGetSchedulerType:
diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms
index 8dda48b..7ec1177 100644
--- a/src/libvirt_public.syms
+++ b/src/libvirt_public.syms
@@ -559,6 +559,8 @@ LIBVIRT_0.10.2 {
virConnectListAllInterfaces;
virConnectListAllNetworks;
virConnectListAllStoragePools;
+ virNodeGetMemoryParameters;
+ virNodeSetMemoryParameters;
virStoragePoolListAllVolumes;
} LIBVIRT_0.10.0;
--
1.7.7.3
9:42 a.m.
New subject: [libvirt] [PATCH 2/6] node_memory: Wire up the RPC protocol
* src/rpc/gendispatch.pl: (virNodeSetMemoryParameters is the
the special one which needs a connection object as the first
argument, improve the generator to support it).
* daemon/remote.c: (Implement the server side handler for
virDomainGetMemoryParameters)
* src/remote/remote_driver.c: (Implement the client side handler
for virDomainGetMemoryParameters)
* src/remote/remote_protocol.x: (New RPC procedures for the two
new APIs and structs to represent the args and ret for it)
* src/remote_protocol-structs: Likewise
---
daemon/remote.c | 59 ++++++++++++++++++++++++++++++++++++++++++
src/remote/remote_driver.c | 50 +++++++++++++++++++++++++++++++++++
src/remote/remote_protocol.x | 24 ++++++++++++++++-
src/remote_protocol-structs | 20 ++++++++++++++
src/rpc/gendispatch.pl | 3 ++
5 files changed, 155 insertions(+), 1 deletions(-)
diff --git a/daemon/remote.c b/daemon/remote.c
index 12cd25c..337acd8 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -4321,6 +4321,65 @@ cleanup:
return rv;
}
+static int
+remoteDispatchNodeGetMemoryParameters(virNetServerPtr server ATTRIBUTE_UNUSED,
+ virNetServerClientPtr client ATTRIBUTE_UNUSED,
+ virNetMessagePtr msg ATTRIBUTE_UNUSED,
+ virNetMessageErrorPtr rerr,
+ remote_node_get_memory_parameters_args *args,
+ remote_node_get_memory_parameters_ret *ret)
+{
+ virTypedParameterPtr params = NULL;
+ int nparams = args->nparams;
+ unsigned int flags;
+ int rv = -1;
+ struct daemonClientPrivate *priv =
+ virNetServerClientGetPrivateData(client);
+
+ if (!priv->conn) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not
open"));
+ goto cleanup;
+ }
+
+ flags = args->flags;
+
+ if (nparams > REMOTE_NODE_MEMORY_PARAMETERS_MAX) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("nparams too
large"));
+ goto cleanup;
+ }
+ if (nparams && VIR_ALLOC_N(params, nparams) < 0) {
+ virReportOOMError();
+ goto cleanup;
+ }
+
+
+ if (virNodeGetMemoryParameters(priv->conn, params, &nparams, flags) < 0)
+ goto cleanup;
+
+ /* In this case, we need to send back the number of parameters
+ * supported
+ */
+ if (args->nparams == 0) {
+ ret->nparams = nparams;
+ goto success;
+ }
+
+ if (remoteSerializeTypedParameters(params, nparams,
+ &ret->params.params_val,
+ &ret->params.params_len,
+ args->flags) < 0)
+ goto cleanup;
+
+success:
+ rv = 0;
+
+cleanup:
+ if (rv < 0)
+ virNetMessageSaveError(rerr);
+ virTypedParameterArrayClear(params, nparams);
+ VIR_FREE(params);
+ return rv;
+}
/*----- Helpers. -----*/
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index f47b06c..c16fc4a 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -5510,6 +5510,54 @@ done:
return rv;
}
+static int
+remoteNodeGetMemoryParameters(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags)
+{
+ int rv = -1;
+ remote_node_get_memory_parameters_args args;
+ remote_node_get_memory_parameters_ret ret;
+ struct private_data *priv = conn->privateData;
+
+ remoteDriverLock(priv);
+
+ args.nparams = *nparams;
+ args.flags = flags;
+
+ memset (&ret, 0, sizeof(ret));
+ if (call (conn, priv, 0, REMOTE_PROC_NODE_GET_MEMORY_PARAMETERS,
+ (xdrproc_t) xdr_remote_node_get_memory_parameters_args, (char *)
&args,
+ (xdrproc_t) xdr_remote_node_get_memory_parameters_ret, (char *) &ret)
== -1)
+ goto done;
+
+ /* Handle the case when the caller does not know the number of parameters
+ * and is asking for the number of parameters supported
+ */
+ if (*nparams == 0) {
+ *nparams = ret.nparams;
+ rv = 0;
+ goto cleanup;
+ }
+
+ if (remoteDeserializeTypedParameters(ret.params.params_val,
+ ret.params.params_len,
+ REMOTE_NODE_MEMORY_PARAMETERS_MAX,
+ params,
+ nparams) < 0)
+ goto cleanup;
+
+ rv = 0;
+
+cleanup:
+ xdr_free ((xdrproc_t) xdr_remote_node_get_memory_parameters_ret,
+ (char *) &ret);
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
static void
remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event)
{
@@ -5821,6 +5869,8 @@ static virDriver remote_driver = {
.domainSetMetadata = remoteDomainSetMetadata, /* 0.9.10 */
.domainGetMetadata = remoteDomainGetMetadata, /* 0.9.10 */
.domainGetHostname = remoteDomainGetHostname, /* 0.10.0 */
+ .nodeSetMemoryParameters = remoteNodeSetMemoryParameters, /* 0.10.2 */
+ .nodeGetMemoryParameters = remoteNodeGetMemoryParameters, /* 0.10.2 */
};
static virNetworkDriver network_driver = {
diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index 54054af..a7aaf58 100644
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -229,6 +229,11 @@ const REMOTE_DOMAIN_GET_CPU_STATS_MAX = 2048;
*/
const REMOTE_DOMAIN_DISK_ERRORS_MAX = 256;
+/*
+ * Upper limit on number of memory parameters
+ */
+const REMOTE_NODE_MEMORY_PARAMETERS_MAX = 64;
+
/* UUID. VIR_UUID_BUFLEN definition comes from libvirt.h */
typedef opaque remote_uuid[VIR_UUID_BUFLEN];
@@ -2599,6 +2604,21 @@ struct remote_connect_list_all_interfaces_ret {
unsigned int ret;
};
+struct remote_node_set_memory_parameters_args {
+ remote_typed_param params<REMOTE_NODE_MEMORY_PARAMETERS_MAX>;
+ unsigned int flags;
+};
+
+struct remote_node_get_memory_parameters_args {
+ int nparams;
+ unsigned int flags;
+};
+
+struct remote_node_get_memory_parameters_ret {
+ remote_typed_param params<REMOTE_NODE_MEMORY_PARAMETERS_MAX>;
+ int nparams;
+};
+
/*----- Protocol. -----*/
/* Define the program number, protocol version and procedure numbers here. */
@@ -2933,7 +2953,9 @@ enum remote_procedure {
REMOTE_PROC_CONNECT_LIST_ALL_STORAGE_POOLS = 281, /* skipgen skipgen priority:high
*/
REMOTE_PROC_STORAGE_POOL_LIST_ALL_VOLUMES = 282, /* skipgen skipgen priority:high */
REMOTE_PROC_CONNECT_LIST_ALL_NETWORKS = 283, /* skipgen skipgen priority:high */
- REMOTE_PROC_CONNECT_LIST_ALL_INTERFACES = 284 /* skipgen skipgen priority:high */
+ REMOTE_PROC_CONNECT_LIST_ALL_INTERFACES = 284, /* skipgen skipgen priority:high */
+ REMOTE_PROC_NODE_SET_MEMORY_PARAMETERS = 285, /* autogen autogen */
+ REMOTE_PROC_NODE_GET_MEMORY_PARAMETERS = 286 /* skipgen skipgen */
/*
* Notice how the entries are grouped in sets of 10 ?
diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs
index 2a33039..7fc3e25 100644
--- a/src/remote_protocol-structs
+++ b/src/remote_protocol-structs
@@ -2056,6 +2056,24 @@ struct remote_connect_list_all_interfaces_ret {
} ifaces;
u_int ret;
};
+struct remote_node_set_memory_parameters_args {
+ struct {
+ u_int params_len;
+ remote_typed_param * params_val;
+ } params;
+ u_int flags;
+};
+struct remote_node_get_memory_parameters_args {
+ int nparams;
+ u_int flags;
+};
+struct remote_node_get_memory_parameters_ret {
+ struct {
+ u_int params_len;
+ remote_typed_param * params_val;
+ } params;
+ int nparams;
+};
enum remote_procedure {
REMOTE_PROC_OPEN = 1,
REMOTE_PROC_CLOSE = 2,
@@ -2341,4 +2359,6 @@ enum remote_procedure {
REMOTE_PROC_STORAGE_POOL_LIST_ALL_VOLUMES = 282,
REMOTE_PROC_CONNECT_LIST_ALL_NETWORKS = 283,
REMOTE_PROC_CONNECT_LIST_ALL_INTERFACES = 284,
+ REMOTE_PROC_NODE_SET_MEMORY_PARAMETERS = 285,
+ REMOTE_PROC_NODE_GET_MEMORY_PARAMETERS = 286,
};
diff --git a/src/rpc/gendispatch.pl b/src/rpc/gendispatch.pl
index 12023e9..774977d 100755
--- a/src/rpc/gendispatch.pl
+++ b/src/rpc/gendispatch.pl
@@ -478,6 +478,9 @@ elsif ($opt_b) {
} elsif ($args_member =~ m/^remote_typed_param (\S+)<(\S+)>;/) {
push(@vars_list, "virTypedParameterPtr $1 = NULL");
push(@vars_list, "int n$1");
+ if ($call->{ProcName} eq "NodeSetMemoryParameters") {
+ push(@args_list, "priv->conn");
+ }
push(@args_list, "$1");
push(@args_list, "n$1");
push(@getters_list, " if (($1 =
remoteDeserializeTypedParameters(args->$1.$1_val,\n" .
--
1.7.7.3
9:42 a.m.
New subject: [libvirt] [PATCH 3/6] node_memory: Implement the internal APIs
Only implemented for linux platform.
* src/nodeinfo.h: (Declare node{Get,Set}MemoryParameters)
* src/nodeinfo.c: (Implement node{Get,Set}MemoryParameters)
* src/libvirt_private.syms: (Export those two new internal APIs to
private symbols)
---
src/libvirt_private.syms | 2 +
src/nodeinfo.c | 249 ++++++++++++++++++++++++++++++++++++++++++++++
src/nodeinfo.h | 10 ++
3 files changed, 261 insertions(+), 0 deletions(-)
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 064e2a6..1fcaa25 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -881,7 +881,9 @@ nodeGetCPUStats;
nodeGetCellsFreeMemory;
nodeGetFreeMemory;
nodeGetInfo;
+nodeGetMemoryParameters;
nodeGetMemoryStats;
+nodeSetMemoryParameters;
# nwfilter_conf.h
diff --git a/src/nodeinfo.c b/src/nodeinfo.c
index e3d4a24..7af6512 100644
--- a/src/nodeinfo.c
+++ b/src/nodeinfo.c
@@ -48,6 +48,7 @@
#include "count-one-bits.h"
#include "intprops.h"
#include "virfile.h"
+#include "virtypedparam.h"
#define VIR_FROM_THIS VIR_FROM_NONE
@@ -57,6 +58,7 @@
# define SYSFS_SYSTEM_PATH "/sys/devices/system"
# define PROCSTAT_PATH "/proc/stat"
# define MEMINFO_PATH "/proc/meminfo"
+# define SYSFS_MEMORY_SHARED_PATH "/sys/kernel/mm/ksm"
# define LINUX_NB_CPU_STATS 4
# define LINUX_NB_MEMORY_STATS_ALL 4
@@ -933,6 +935,253 @@ nodeGetCPUmap(virConnectPtr conn ATTRIBUTE_UNUSED,
#endif
}
+static int
+nodeSetMemoryParameterValue(const char *field,
+ virTypedParameterPtr param)
+{
+ char *path = NULL;
+ char *strval = NULL;
+ int ret = -1;
+ int rc = -1;
+
+ if (virAsprintf(&path, "%s/%s",
+ SYSFS_MEMORY_SHARED_PATH, field) < 0) {
+ virReportOOMError();
+ ret = -2;
+ goto cleanup;
+ }
+
+ if (virAsprintf(&strval, "%u", param->value.ui) == -1) {
+ virReportOOMError();
+ ret = -2;
+ goto cleanup;
+ }
+
+ if ((rc = virFileWriteStr(path, strval, 0)) < 0) {
+ virReportSystemError(-rc, _("failed to set %s"), field);
+ goto cleanup;
+ }
+
+ ret = 0;
+cleanup:
+ VIR_FREE(path);
+ VIR_FREE(strval);
+ return ret;
+}
+
+int
+nodeSetMemoryParameters(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virTypedParameterPtr params,
+ int nparams,
+ unsigned int flags)
+{
+ virCheckFlags(0, -1);
+
+#ifdef __linux__
+ int ret = 0;
+ int i;
+
+ if (virTypedParameterArrayValidate(params, nparams,
+ VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN,
+ VIR_TYPED_PARAM_UINT,
+ VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS,
+ VIR_TYPED_PARAM_UINT,
+ NULL) < 0)
+ return -1;
+
+ for (i = 0; i < nparams; i++) {
+ virTypedParameterPtr param = ¶ms[i];
+
+ if (STREQ(param->field,
+ VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN)) {
+ ret = nodeSetMemoryParameterValue("pages_to_scan", param);
+
+ /* Out of memory */
+ if (ret == -2)
+ return -1;
+ } else if (STREQ(param->field,
+ VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS)) {
+ ret = nodeSetMemoryParameterValue("sleep_millisecs", param);
+
+ /* Out of memory */
+ if (ret == -2)
+ return -1;
+ }
+ }
+
+ return ret;
+#else
+ virReportError(VIR_ERR_NO_SUPPORT, "%s",
+ _("node set memory parameters not implemented"
+ " on this platform"));
+ return -1;
+#endif
+}
+
+static int
+nodeGetMemoryParameterValue(const char *field,
+ void *value)
+{
+ char *path = NULL;
+ char *buf = NULL;
+ char *tmp = NULL;
+ int ret = -1;
+ int rc = -1;
+
+ if (virAsprintf(&path, "%s/%s",
+ SYSFS_MEMORY_SHARED_PATH, field) < 0) {
+ virReportOOMError();
+ goto cleanup;
+ }
+
+ if (virFileReadAll(path, 1024, &buf) < 0)
+ goto cleanup;
+
+ if ((tmp = strchr(buf, '\n')))
+ *tmp = '\0';
+
+ if (STREQ(field, "pages_to_scan") ||
+ STREQ(field, "sleep_millisecs"))
+ rc = virStrToLong_ui(buf, NULL, 10, (unsigned int *)value);
+ else if (STREQ(field, "pages_shared") ||
+ STREQ(field, "pages_sharing") ||
+ STREQ(field, "pages_unshared") ||
+ STREQ(field, "pages_volatile") ||
+ STREQ(field, "full_scans"))
+ rc = virStrToLong_ull(buf, NULL, 10, (unsigned long long *)value);
+
+ if (rc < 0) {
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("failed to parse %s"), field);
+ goto cleanup;
+ }
+
+ ret = 0;
+cleanup:
+ VIR_FREE(path);
+ VIR_FREE(buf);
+ return ret;
+}
+
+#define NODE_MEMORY_PARAMETERS_NUM 7
+int
+nodeGetMemoryParameters(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags)
+{
+ virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);
+
+#ifdef __linux__
+ unsigned int pages_to_scan;
+ unsigned int sleep_millisecs;
+ unsigned long long pages_shared;
+ unsigned long long pages_sharing;
+ unsigned long long pages_unshared;
+ unsigned long long pages_volatile;
+ unsigned long long full_scans = 0;
+ int i;
+
+ if ((*nparams) == 0) {
+ *nparams = NODE_MEMORY_PARAMETERS_NUM;
+ return 0;
+ }
+
+ for (i = 0; i < *nparams && i < NODE_MEMORY_PARAMETERS_NUM; i++) {
+ virTypedParameterPtr param = ¶ms[i];
+
+ switch(i) {
+ case 0:
+ if (nodeGetMemoryParameterValue("pages_to_scan",
+ &pages_to_scan) < 0)
+ return -1;
+
+ if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN,
+ VIR_TYPED_PARAM_UINT, pages_to_scan) < 0)
+ return -1;
+
+ break;
+
+ case 1:
+ if (nodeGetMemoryParameterValue("sleep_millisecs",
+ &sleep_millisecs) < 0)
+ return -1;
+
+ if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS,
+ VIR_TYPED_PARAM_UINT, sleep_millisecs) < 0)
+ return -1;
+
+ break;
+
+ case 2:
+ if (nodeGetMemoryParameterValue("pages_shared",
+ &pages_shared) < 0)
+ return -1;
+
+ if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_SHARED,
+ VIR_TYPED_PARAM_ULLONG, pages_shared) < 0)
+ return -1;
+
+ break;
+
+ case 3:
+ if (nodeGetMemoryParameterValue("pages_sharing",
+ &pages_sharing) < 0)
+ return -1;
+
+ if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_SHARING,
+ VIR_TYPED_PARAM_ULLONG, pages_sharing) < 0)
+ return -1;
+
+ break;
+
+ case 4:
+ if (nodeGetMemoryParameterValue("pages_unshared",
+ &pages_unshared) < 0)
+ return -1;
+
+ if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_UNSHARED,
+ VIR_TYPED_PARAM_ULLONG, pages_unshared) < 0)
+ return -1;
+
+ break;
+
+ case 5:
+ if (nodeGetMemoryParameterValue("pages_volatile",
+ &pages_volatile) < 0)
+ return -1;
+
+ if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_PAGES_VOLATILE,
+ VIR_TYPED_PARAM_ULLONG, pages_volatile) < 0)
+ return -1;
+
+ break;
+
+ case 6:
+ if (nodeGetMemoryParameterValue("full_scans",
+ &full_scans) < 0)
+ return -1;
+
+ if (virTypedParameterAssign(param, VIR_NODE_MEMORY_SHARED_FULL_SCANS,
+ VIR_TYPED_PARAM_ULLONG, full_scans) < 0)
+ return -1;
+
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ return 0;
+#else
+ virReportError(VIR_ERR_NO_SUPPORT, "%s",
+ _("node get memory parameters not implemented"
+ " on this platform"));
+ return -1;
+#endif
+}
+
#if HAVE_NUMACTL
# if LIBNUMA_API_VERSION <= 1
# define NUMA_MAX_N_CPUS 4096
diff --git a/src/nodeinfo.h b/src/nodeinfo.h
index 12090e2..25ad0dd 100644
--- a/src/nodeinfo.h
+++ b/src/nodeinfo.h
@@ -49,4 +49,14 @@ unsigned long long nodeGetFreeMemory(virConnectPtr conn);
char *nodeGetCPUmap(virConnectPtr conn,
int *max_id,
const char *mapname);
+
+int nodeGetMemoryParameters(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags);
+
+int nodeSetMemoryParameters(virConnectPtr conn,
+ virTypedParameterPtr params,
+ int nparams,
+ unsigned int flags);
#endif /* __VIR_NODEINFO_H__*/
--
1.7.7.3
9:42 a.m.
New subject: [libvirt] [PATCH 4/6] node_memory: Support get/set memory parameters for drivers
Including QEMU, LXC, UML, XEN drivers.
---
src/lxc/lxc_driver.c | 2 ++
src/qemu/qemu_driver.c | 2 ++
src/uml/uml_driver.c | 2 ++
src/xen/xen_driver.c | 3 +++
4 files changed, 9 insertions(+), 0 deletions(-)
diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c
index ff11c2c..62c36e6 100644
--- a/src/lxc/lxc_driver.c
+++ b/src/lxc/lxc_driver.c
@@ -2748,6 +2748,8 @@ static virDriver lxcDriver = {
.domainOpenConsole = lxcDomainOpenConsole, /* 0.8.6 */
.isAlive = lxcIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
+ .nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
+ .nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
};
static virStateDriver lxcStateDriver = {
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 23a7a75..981e6d4 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -14112,6 +14112,8 @@ static virDriver qemuDriver = {
.domainPMSuspendForDuration = qemuDomainPMSuspendForDuration, /* 0.9.11 */
.domainPMWakeup = qemuDomainPMWakeup, /* 0.9.11 */
.domainGetCPUStats = qemuDomainGetCPUStats, /* 0.9.11 */
+ .nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
+ .nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
};
diff --git a/src/uml/uml_driver.c b/src/uml/uml_driver.c
index 26877eb..72d1b0e 100644
--- a/src/uml/uml_driver.c
+++ b/src/uml/uml_driver.c
@@ -2623,6 +2623,8 @@ static virDriver umlDriver = {
.domainOpenConsole = umlDomainOpenConsole, /* 0.8.6 */
.isAlive = umlIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
+ .nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
+ .nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
};
static virStateDriver umlStateDriver = {
diff --git a/src/xen/xen_driver.c b/src/xen/xen_driver.c
index d33737e..3a14d12 100644
--- a/src/xen/xen_driver.c
+++ b/src/xen/xen_driver.c
@@ -64,6 +64,7 @@
#include "viruri.h"
#include "command.h"
#include "virnodesuspend.h"
+#include "nodeinfo.h"
#define VIR_FROM_THIS VIR_FROM_XEN
@@ -2269,6 +2270,8 @@ static virDriver xenUnifiedDriver = {
.domainOpenConsole = xenUnifiedDomainOpenConsole, /* 0.8.6 */
.isAlive = xenUnifiedIsAlive, /* 0.9.8 */
.nodeSuspendForDuration = nodeSuspendForDuration, /* 0.9.8 */
+ .nodeGetMemoryParameters = nodeGetMemoryParameters, /* 0.10.2 */
+ .nodeSetMemoryParameters = nodeSetMemoryParameters, /* 0.10.2 */
};
/**
--
1.7.7.3
9:42 a.m.
New subject: [libvirt] [PATCH 5/6] node_memory: Expose the APIs to virsh
New command node-memory-tune to get/set the node memory parameters,
only two parameters are allowed to set (pages_to_scan, and sleep_millisecs,
see documents in this patch for more details).
Example of node-memory-tune's output:
Shared memory:
pages_to_scan 100
sleep_millisecs 20
pages_shared 0
pages_sharing 0
pages_unshared 0
pages_volatile 0
full_scans 0
---
tools/virsh-host.c | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++++
tools/virsh.pod | 8 ++++
2 files changed, 124 insertions(+), 0 deletions(-)
diff --git a/tools/virsh-host.c b/tools/virsh-host.c
index c46288b..713c003 100644
--- a/tools/virsh-host.c
+++ b/tools/virsh-host.c
@@ -37,6 +37,7 @@
#include "util.h"
#include "virsh-domain.h"
#include "xml.h"
+#include "virtypedparam.h"
/*
* "capabilities" command
@@ -884,12 +885,127 @@ cmdVersion(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
return true;
}
+static const vshCmdInfo info_node_memory_tune[] = {
+ {"help", N_("Get or set node memory parameters")},
+ {"desc", N_("Get or set node memory parameters"
+ " To get the memory parameters, use following command:
\n\n"
+ " virsh # node-memory-tune")},
+ {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_node_memory_tune[] = {
+ {"shm-pages-to-scan", VSH_OT_INT, VSH_OFLAG_NONE,
+ N_("number of pages to scan before the shared memory service "
+ "goes to sleep")},
+ {"shm-sleep-millisecs", VSH_OT_INT, VSH_OFLAG_NONE,
+ N_("number of millisecs the shared memory service should "
+ "sleep before next scan")},
+ {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdNodeMemoryTune(vshControl *ctl, const vshCmd *cmd)
+{
+ virTypedParameterPtr params = NULL;
+ int nparams = 0;
+ unsigned int flags = 0;
+ unsigned int shm_pages_to_scan = 0;
+ unsigned int shm_sleep_millisecs = 0;
+ bool ret = false;
+ int i = 0;
+
+ if (vshCommandOptUInt(cmd, "shm-pages-to-scan",
+ &shm_pages_to_scan) < 0) {
+ vshError(ctl, "%s", _("invalid shm-pages-to-scan number"));
+ return false;
+ }
+
+ if (vshCommandOptUInt(cmd, "shm-sleep-millisecs",
+ &shm_sleep_millisecs) < 0) {
+ vshError(ctl, "%s", _("invalid shm-sleep-millisecs
number"));
+ return false;
+ }
+
+ if (shm_pages_to_scan)
+ nparams++;
+
+ if (shm_sleep_millisecs)
+ nparams++;
+
+ if (nparams == 0) {
+ /* Get the number of memory parameters */
+ if (virNodeGetMemoryParameters(ctl->conn, NULL, &nparams, flags) != 0) {
+ vshError(ctl, "%s",
+ _("Unable to get number of memory parameters"));
+ goto cleanup;
+ }
+
+ if (nparams == 0) {
+ ret = true;
+ goto cleanup;
+ }
+
+ /* Now go get all the memory parameters */
+ params = vshCalloc(ctl, nparams, sizeof(*params));
+ if (virNodeGetMemoryParameters(ctl->conn, params, &nparams, flags) != 0)
{
+ vshError(ctl, "%s", _("Unable to get memory
parameters"));
+ goto cleanup;
+ }
+
+ /* XXX: Need to sort the returned params once new parameter
+ * fields not of shared memory are added.
+ */
+ vshPrint(ctl, _("Shared memory:\n"));
+ for (i = 0; i < nparams; i++) {
+ char *str = vshGetTypedParamValue(ctl, ¶ms[i]);
+ vshPrint(ctl, "\t%-15s %s\n", params[i].field, str);
+ VIR_FREE(str);
+ }
+
+ ret = true;
+ } else {
+ /* Set the memory parameters */
+ params = vshCalloc(ctl, nparams, sizeof(*params));
+
+ if (i < nparams && shm_pages_to_scan) {
+ if (virTypedParameterAssign(¶ms[i++],
+ VIR_NODE_MEMORY_SHARED_PAGES_TO_SCAN,
+ VIR_TYPED_PARAM_UINT,
+ shm_pages_to_scan) < 0)
+ goto error;
+ }
+
+ if (i < nparams && shm_sleep_millisecs) {
+ if (virTypedParameterAssign(¶ms[i++],
+ VIR_NODE_MEMORY_SHARED_SLEEP_MILLISECS,
+ VIR_TYPED_PARAM_UINT,
+ shm_sleep_millisecs) < 0)
+ goto error;
+ }
+
+ if (virNodeSetMemoryParameters(ctl->conn, params, nparams, flags) != 0)
+ goto error;
+ else
+ ret = true;
+ }
+
+cleanup:
+ VIR_FREE(params);
+ return ret;
+
+error:
+ vshError(ctl, "%s", _("Unable to change memory parameters"));
+ goto cleanup;
+}
+
const vshCmdDef hostAndHypervisorCmds[] = {
{"capabilities", cmdCapabilities, NULL, info_capabilities, 0},
{"connect", cmdConnect, opts_connect, info_connect,
VSH_CMD_FLAG_NOCONNECT},
{"freecell", cmdFreecell, opts_freecell, info_freecell, 0},
{"hostname", cmdHostname, NULL, info_hostname, 0},
+ {"node-memory-tune", cmdNodeMemoryTune,
+ opts_node_memory_tune, info_node_memory_tune, 0},
{"nodecpustats", cmdNodeCpuStats, opts_node_cpustats, info_nodecpustats,
0},
{"nodeinfo", cmdNodeinfo, NULL, info_nodeinfo, 0},
{"nodememstats", cmdNodeMemStats, opts_node_memstats, info_nodememstats,
0},
diff --git a/tools/virsh.pod b/tools/virsh.pod
index 559e64d..d1f7068 100644
--- a/tools/virsh.pod
+++ b/tools/virsh.pod
@@ -293,6 +293,14 @@ Real-Time-Clock interrupt to fire (to wake up the node) after a time
delay
specified by the 'duration' parameter. The duration time should be
at least 60 seconds.
+=item B<node-memory-tune> [I<shm-pages-to-scan>]
[I<shm-sleep-millisecs>]
+
+Allows you to display or set the node memory parameters.
+I<shm-pages-to-scan> can be used to set the number of pages to scan
+before the shared memory service goes to sleep; I<shm-sleep-millisecs>
+can be used to set the number of millisecs the shared memory service should
+sleep before next scan.
+
=item B<capabilities>
Print an XML document describing the capabilities of the hypervisor
--
1.7.7.3
9:42 a.m.
New subject: [libvirt] [PATCH 6/6] node_memory: Expose the APIs to Python bindings
* python/libvirt-override-api.xml: (Add document to describe
the APIs).
* python/libvirt-override.c: (Implement the API wrappers manually)
---
python/libvirt-override-api.xml | 13 ++++
python/libvirt-override.c | 125 +++++++++++++++++++++++++++++++++++++++
2 files changed, 138 insertions(+), 0 deletions(-)
diff --git a/python/libvirt-override-api.xml b/python/libvirt-override-api.xml
index ab6f407..abc0b81 100644
--- a/python/libvirt-override-api.xml
+++ b/python/libvirt-override-api.xml
@@ -511,5 +511,18 @@
<arg name='domain' type='virDomainPtr' info='a domain
object'/>
<arg name='flags' type='unsigned int' info='unused, always
pass 0'/>
</function>
+ <function name='virNodeSetMemoryParameters' file='python'>
+ <info>Change the node memory tunables</info>
+ <return type='int' info='-1 in case of error, 0 in case of
success.'/>
+ <arg name='conn' type='virConnectPtr' info='pointer to the
hypervisor connection'/>
+ <arg name='params' type='virTypedParameterPtr' info='pointer
to the memory tunable objects'/>
+ <arg name='flags' type='int' info='unused, always pass
0'/>
+ </function>
+ <function name='virNodeGetMemoryParameters' file='python'>
+ <info>Get the node memory parameters</info>
+ <return type='str *' info='None in case of error, returns a
dictionary of params'/>
+ <arg name='conn' type='virConnectPtr' info='pointer to the
hypervisor connection'/>
+ <arg name='flags' type='int' info='unused, always pass
0'/>
+ </function>
</symbols>
</api>
diff --git a/python/libvirt-override.c b/python/libvirt-override.c
index d07e7cb..ca32f80 100644
--- a/python/libvirt-override.c
+++ b/python/libvirt-override.c
@@ -6005,6 +6005,129 @@ cleanup:
return py_retval;
}
+static PyObject *
+libvirt_virNodeSetMemoryParameters(PyObject *self ATTRIBUTE_UNUSED,
+ PyObject *args)
+{
+ virConnectPtr conn;
+ PyObject *pyobj_conn, *info;
+ PyObject *ret = NULL;
+ int i_retval;
+ int nparams = 0;
+ Py_ssize_t size = 0;
+ unsigned int flags;
+ virTypedParameterPtr params, new_params;
+
+ if (!PyArg_ParseTuple(args,
+ (char *)"OOi:virNodeSetMemoryParameters",
+ &pyobj_conn, &info, &flags))
+ return NULL;
+ conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
+
+ if ((size = PyDict_Size(info)) < 0)
+ return NULL;
+
+ if (size == 0) {
+ PyErr_Format(PyExc_LookupError,
+ "Need non-empty dictionary to set attributes");
+ return NULL;
+ }
+
+ LIBVIRT_BEGIN_ALLOW_THREADS;
+ i_retval = virNodeGetMemoryParameters(conn, NULL, &nparams, flags);
+ LIBVIRT_END_ALLOW_THREADS;
+
+ if (i_retval < 0)
+ return VIR_PY_INT_FAIL;
+
+ if (nparams == 0) {
+ PyErr_Format(PyExc_LookupError,
+ "no settable attributes");
+ return NULL;
+ }
+
+ if (VIR_ALLOC_N(params, nparams) < 0)
+ return PyErr_NoMemory();
+
+ LIBVIRT_BEGIN_ALLOW_THREADS;
+ i_retval = virNodeGetMemoryParameters(conn, params, &nparams, flags);
+ LIBVIRT_END_ALLOW_THREADS;
+
+ if (i_retval < 0) {
+ ret = VIR_PY_INT_FAIL;
+ goto cleanup;
+ }
+
+ new_params = setPyVirTypedParameter(info, params, nparams);
+ if (!new_params)
+ goto cleanup;
+
+ LIBVIRT_BEGIN_ALLOW_THREADS;
+ i_retval = virNodeSetMemoryParameters(conn, new_params, size, flags);
+ LIBVIRT_END_ALLOW_THREADS;
+
+ if (i_retval < 0) {
+ ret = VIR_PY_INT_FAIL;
+ goto cleanup;
+ }
+
+ ret = VIR_PY_INT_SUCCESS;
+
+cleanup:
+ virTypedParameterArrayClear(params, nparams);
+ VIR_FREE(params);
+ VIR_FREE(new_params);
+ return ret;
+}
+
+static PyObject *
+libvirt_virNodeGetMemoryParameters(PyObject *self ATTRIBUTE_UNUSED,
+ PyObject *args)
+{
+ virConnectPtr conn;
+ PyObject *pyobj_conn;
+ PyObject *ret = NULL;
+ int i_retval;
+ int nparams = 0;
+ unsigned int flags;
+ virTypedParameterPtr params;
+
+ if (!PyArg_ParseTuple(args, (char *)"Oi:virNodeGetMemoryParameters",
+ &pyobj_conn, &flags))
+ return NULL;
+ conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
+
+ LIBVIRT_BEGIN_ALLOW_THREADS;
+ i_retval = virNodeGetMemoryParameters(conn, NULL, &nparams, flags);
+ LIBVIRT_END_ALLOW_THREADS;
+
+ if (i_retval < 0)
+ return VIR_PY_NONE;
+
+ if (!nparams)
+ return PyDict_New();
+
+ if (VIR_ALLOC_N(params, nparams) < 0)
+ return PyErr_NoMemory();
+
+ LIBVIRT_BEGIN_ALLOW_THREADS;
+ i_retval = virNodeGetMemoryParameters(conn, params, &nparams, flags);
+ LIBVIRT_END_ALLOW_THREADS;
+
+ if (i_retval < 0) {
+ ret = VIR_PY_NONE;
+ goto cleanup;
+ }
+
+ ret = getPyVirTypedParameter(params, nparams);
+
+cleanup:
+ virTypedParameterArrayClear(params, nparams);
+ VIR_FREE(params);
+ return ret;
+}
+
+
/************************************************************************
* *
* The registration stuff *
@@ -6116,6 +6239,8 @@ static PyMethodDef libvirtMethods[] = {
{(char *) "virDomainBlockPeek", libvirt_virDomainBlockPeek, METH_VARARGS,
NULL},
{(char *) "virDomainMemoryPeek", libvirt_virDomainMemoryPeek, METH_VARARGS,
NULL},
{(char *) "virDomainGetDiskErrors", libvirt_virDomainGetDiskErrors,
METH_VARARGS, NULL},
+ {(char *) "virNodeGetMemoryParameters", libvirt_virNodeGetMemoryParameters,
METH_VARARGS, NULL},
+ {(char *) "virNodeSetMemoryParameters", libvirt_virNodeSetMemoryParameters,
METH_VARARGS, NULL},
{NULL, NULL, 0, NULL}
};
--
1.7.7.3
1:57 a.m.
On Fri, Sep 14, 2012 at 10:42:13PM +0800, Osier Yang wrote:
v1:
https://www.redhat.com/archives/libvir-list/2012-September/msg00517.html
v1 - v2:
* Rename virNode{Get,Set}SharedMemoryParameters to
virNode{Get,Set}MemoryParameters, in case of we could add more
node memory tunables in future.
v2 - v3:
* Add prefix "shm_" to the shared memory parameter field.
* Change REMOTE_NODE_MEMORY_PARAMETERS_MAX from 16 to 64.
* Helper fucntions for internal APIs (node{Get,Set}MemoryParameters)
* Add "shm" prefix for the virsh options.
As a result of RFC:
https://www.redhat.com/archives/libvir-list/2012-August/msg01998.html,
this adds two new APIs (virNode{Get,Set}MemoryParameters) to get
and set the host shared memory tunables (ksm under linux).
Osier Yang (6):
node_memory: Define the APIs to get/set memory parameters
node_memory: Wire up the RPC protocol
node_memory: Implement the internal APIs
node_memory: Support get/set memory parameters for drivers
node_memory: Expose the APIs to virsh
node_memory: Expose the APIs to Python bindings
daemon/remote.c | 59 +++++++++
include/libvirt/libvirt.h.in | 63 ++++++++++
python/generator.py | 2 +
python/libvirt-override-api.xml | 13 ++
python/libvirt-override.c | 125 ++++++++++++++++++++
src/driver.h | 14 ++
src/libvirt.c | 121 +++++++++++++++++++
src/libvirt_private.syms | 2 +
src/libvirt_public.syms | 2 +
src/lxc/lxc_driver.c | 2 +
src/nodeinfo.c | 249 +++++++++++++++++++++++++++++++++++++++
src/nodeinfo.h | 10 ++
src/qemu/qemu_driver.c | 2 +
src/remote/remote_driver.c | 50 ++++++++
src/remote/remote_protocol.x | 24 ++++-
src/remote_protocol-structs | 20 +++
src/rpc/gendispatch.pl | 3 +
src/uml/uml_driver.c | 2 +
src/xen/xen_driver.c | 3 +
tools/virsh-host.c | 116 ++++++++++++++++++
tools/virsh.pod | 8 ++
21 files changed, 889 insertions(+), 1 deletions(-)
ACK to the patch set,
Daniel
--
Daniel Veillard | libxml Gnome XML XSLT toolkit http://xmlsoft.org/
daniel(a)veillard.com | Rpmfind RPM search engine http://rpmfind.net/
http://veillard.com/ | virtualization library http://libvirt.org/
1:11 a.m.
On 2012年09月15日 14:57, Daniel Veillard wrote:
On Fri, Sep 14, 2012 at 10:42:13PM +0800, Osier Yang wrote:
> v1:
>
> https://www.redhat.com/archives/libvir-list/2012-September/msg00517.html
>
> v1 - v2:
> * Rename virNode{Get,Set}SharedMemoryParameters to
> virNode{Get,Set}MemoryParameters, in case of we could add more
> node memory tunables in future.
>
> v2 - v3:
> * Add prefix "shm_" to the shared memory parameter field.
> * Change REMOTE_NODE_MEMORY_PARAMETERS_MAX from 16 to 64.
> * Helper fucntions for internal APIs (node{Get,Set}MemoryParameters)
> * Add "shm" prefix for the virsh options.
>
> As a result of RFC:
> https://www.redhat.com/archives/libvir-list/2012-August/msg01998.html,
> this adds two new APIs (virNode{Get,Set}MemoryParameters) to get
> and set the host shared memory tunables (ksm under linux).
>
> Osier Yang (6):
> node_memory: Define the APIs to get/set memory parameters
> node_memory: Wire up the RPC protocol
> node_memory: Implement the internal APIs
> node_memory: Support get/set memory parameters for drivers
> node_memory: Expose the APIs to virsh
> node_memory: Expose the APIs to Python bindings
>
> daemon/remote.c | 59 +++++++++
> include/libvirt/libvirt.h.in | 63 ++++++++++
> python/generator.py | 2 +
> python/libvirt-override-api.xml | 13 ++
> python/libvirt-override.c | 125 ++++++++++++++++++++
> src/driver.h | 14 ++
> src/libvirt.c | 121 +++++++++++++++++++
> src/libvirt_private.syms | 2 +
> src/libvirt_public.syms | 2 +
> src/lxc/lxc_driver.c | 2 +
> src/nodeinfo.c | 249 +++++++++++++++++++++++++++++++++++++++
> src/nodeinfo.h | 10 ++
> src/qemu/qemu_driver.c | 2 +
> src/remote/remote_driver.c | 50 ++++++++
> src/remote/remote_protocol.x | 24 ++++-
> src/remote_protocol-structs | 20 +++
> src/rpc/gendispatch.pl | 3 +
> src/uml/uml_driver.c | 2 +
> src/xen/xen_driver.c | 3 +
> tools/virsh-host.c | 116 ++++++++++++++++++
> tools/virsh.pod | 8 ++
> 21 files changed, 889 insertions(+), 1 deletions(-)
ACK to the patch set,
Daniel
Rebased on the top, and pushed. Thanks.
Osier
4451
days inactive
4454
days old
8 comments
2 participants
participants (2)
-
Daniel Veillard -
Osier Yang