Introduce a src/libvirt-host.c file to hold all the
methods related to the virConnect type.
---
docs/apibuild.py | 1 +
po/POTFILES.in | 1 +
src/Makefile.am | 2 +
src/libvirt-host.c | 1515 ++++++++++++++++++++++++++++++++++++++++++++++++++++
src/libvirt.c | 1484 --------------------------------------------------
5 files changed, 1519 insertions(+), 1484 deletions(-)
create mode 100644 src/libvirt-host.c
diff --git a/docs/apibuild.py b/docs/apibuild.py
index a96260f..9b5f6d6 100755
--- a/docs/apibuild.py
+++ b/docs/apibuild.py
@@ -26,6 +26,7 @@ included_files = {
"libvirt.c": "Main interfaces for the libvirt library",
"libvirt-domain.c": "Domain interfaces for the libvirt library",
"libvirt-domain-snapshot.c": "Domain snapshot interfaces for the libvirt library",
+ "libvirt-host.c": "Host interfaces for the libvirt library",
"libvirt-interface.c": "Interface interfaces for the libvirt library",
"libvirt-network.c": "Network interfaces for the libvirt library",
"libvirt-nodedev.c": "Node device interfaces for the libvirt library",
diff --git a/po/POTFILES.in b/po/POTFILES.in
index d9c9af7..242cfdb 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -59,6 +59,7 @@ src/internal.h
src/libvirt.c
src/libvirt-domain.c
src/libvirt-domain-snapshot.c
+src/libvirt-host.c
src/libvirt-lxc.c
src/libvirt-network.c
src/libvirt-nwfilter.c
diff --git a/src/Makefile.am b/src/Makefile.am
index 7da9abd..3596c9b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -191,6 +191,7 @@ DRIVER_SOURCES = \
libvirt.c libvirt_internal.h \
libvirt-domain.c \
libvirt-domain-snapshot.c \
+ libvirt-host.c \
libvirt-interface.c \
libvirt-network.c \
libvirt-nodedev.c \
@@ -2197,6 +2198,7 @@ libvirt_setuid_rpc_client_la_SOURCES = \
libvirt.c \
libvirt-domain.c \
libvirt-domain-snapshot.c \
+ libvirt-host.c \
libvirt-interface.c \
libvirt-network.c \
libvirt-nodedev.c \
diff --git a/src/libvirt-host.c b/src/libvirt-host.c
new file mode 100644
index 0000000..afac711
--- /dev/null
+++ b/src/libvirt-host.c
@@ -0,0 +1,1515 @@
+/*
+ * libvirt-host.c: entry points for vir{Connect,Node}Ptr APIs
+ *
+ * Copyright (C) 2006-2014 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <sys/stat.h>
+
+#include "datatypes.h"
+#include "viralloc.h"
+#include "virlog.h"
+#include "virtypedparam.h"
+
+VIR_LOG_INIT("libvirt.host");
+
+#define VIR_FROM_THIS VIR_FROM_NONE
+
+
+/**
+ * virConnectRef:
+ * @conn: the connection to hold a reference on
+ *
+ * Increment the reference count on the connection. For each
+ * additional call to this method, there shall be a corresponding
+ * call to virConnectClose to release the reference count, once
+ * the caller no longer needs the reference to this object.
+ *
+ * This method is typically useful for applications where multiple
+ * threads are using a connection, and it is required that the
+ * connection remain open until all threads have finished using
+ * it. ie, each new thread using a connection would increment
+ * the reference count.
+ *
+ * Returns 0 in case of success, -1 in case of failure
+ */
+int
+virConnectRef(virConnectPtr conn)
+{
+ VIR_DEBUG("conn=%p refs=%d", conn, conn ? conn->object.u.s.refs : 0);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virObjectRef(conn);
+ return 0;
+}
+
+
+/*
+ * Not for public use. This function is part of the internal
+ * implementation of driver features in the remote case.
+ */
+int
+virConnectSupportsFeature(virConnectPtr conn, int feature)
+{
+ int ret;
+ VIR_DEBUG("conn=%p, feature=%d", conn, feature);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+
+ if (!conn->driver->connectSupportsFeature)
+ ret = 0;
+ else
+ ret = conn->driver->connectSupportsFeature(conn, feature);
+
+ if (ret < 0)
+ virDispatchError(conn);
+
+ return ret;
+}
+
+
+/**
+ * virConnectGetType:
+ * @conn: pointer to the hypervisor connection
+ *
+ * Get the name of the Hypervisor driver used. This is merely the driver
+ * name; for example, both KVM and QEMU guests are serviced by the
+ * driver for the qemu:// URI, so a return of "QEMU" does not indicate
+ * whether KVM acceleration is present. For more details about the
+ * hypervisor, use virConnectGetCapabilities().
+ *
+ * Returns NULL in case of error, a static zero terminated string otherwise.
+ *
+ * See also:
+ * http://www.redhat.com/archives/libvir-list/2007-February/msg00096.html
+ */
+const char *
+virConnectGetType(virConnectPtr conn)
+{
+ const char *ret;
+ VIR_DEBUG("conn=%p", conn);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, NULL);
+
+ if (conn->driver->connectGetType) {
+ ret = conn->driver->connectGetType(conn);
+ if (ret) return ret;
+ }
+ return conn->driver->name;
+}
+
+
+/**
+ * virConnectGetVersion:
+ * @conn: pointer to the hypervisor connection
+ * @hvVer: return value for the version of the running hypervisor (OUT)
+ *
+ * Get the version level of the Hypervisor running. This may work only with
+ * hypervisor call, i.e. with privileged access to the hypervisor, not
+ * with a Read-Only connection.
+ *
+ * Returns -1 in case of error, 0 otherwise. if the version can't be
+ * extracted by lack of capacities returns 0 and @hvVer is 0, otherwise
+ * @hvVer value is major * 1,000,000 + minor * 1,000 + release
+ */
+int
+virConnectGetVersion(virConnectPtr conn, unsigned long *hvVer)
+{
+ VIR_DEBUG("conn=%p, hvVer=%p", conn, hvVer);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virCheckNonNullArgGoto(hvVer, error);
+
+ if (conn->driver->connectGetVersion) {
+ int ret = conn->driver->connectGetVersion(conn, hvVer);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virConnectGetLibVersion:
+ * @conn: pointer to the hypervisor connection
+ * @libVer: returns the libvirt library version used on the connection (OUT)
+ *
+ * Provides @libVer, which is the version of libvirt used by the
+ * daemon running on the @conn host
+ *
+ * Returns -1 in case of failure, 0 otherwise, and values for @libVer have
+ * the format major * 1,000,000 + minor * 1,000 + release.
+ */
+int
+virConnectGetLibVersion(virConnectPtr conn, unsigned long *libVer)
+{
+ int ret = -1;
+ VIR_DEBUG("conn=%p, libVir=%p", conn, libVer);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virCheckNonNullArgGoto(libVer, error);
+
+ if (conn->driver->connectGetLibVersion) {
+ ret = conn->driver->connectGetLibVersion(conn, libVer);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ *libVer = LIBVIR_VERSION_NUMBER;
+ return 0;
+
+ error:
+ virDispatchError(conn);
+ return ret;
+}
+
+
+/**
+ * virConnectGetHostname:
+ * @conn: pointer to a hypervisor connection
+ *
+ * This returns a system hostname on which the hypervisor is
+ * running (based on the result of the gethostname system call, but
+ * possibly expanded to a fully-qualified domain name via getaddrinfo).
+ * If we are connected to a remote system, then this returns the
+ * hostname of the remote system.
+ *
+ * Returns the hostname which must be freed by the caller, or
+ * NULL if there was an error.
+ */
+char *
+virConnectGetHostname(virConnectPtr conn)
+{
+ VIR_DEBUG("conn=%p", conn);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, NULL);
+
+ if (conn->driver->connectGetHostname) {
+ char *ret = conn->driver->connectGetHostname(conn);
+ if (!ret)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return NULL;
+}
+
+
+/**
+ * virConnectGetURI:
+ * @conn: pointer to a hypervisor connection
+ *
+ * This returns the URI (name) of the hypervisor connection.
+ * Normally this is the same as or similar to the string passed
+ * to the virConnectOpen/virConnectOpenReadOnly call, but
+ * the driver may make the URI canonical. If name == NULL
+ * was passed to virConnectOpen, then the driver will return
+ * a non-NULL URI which can be used to connect to the same
+ * hypervisor later.
+ *
+ * Returns the URI string which must be freed by the caller, or
+ * NULL if there was an error.
+ */
+char *
+virConnectGetURI(virConnectPtr conn)
+{
+ char *name;
+ VIR_DEBUG("conn=%p", conn);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, NULL);
+
+ if (!(name = virURIFormat(conn->uri)))
+ goto error;
+
+ return name;
+
+ error:
+ virDispatchError(conn);
+ return NULL;
+}
+
+
+/**
+ * virConnectGetSysinfo:
+ * @conn: pointer to a hypervisor connection
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * This returns the XML description of the sysinfo details for the
+ * host on which the hypervisor is running, in the same format as the
+ * <sysinfo> element of a domain XML. This information is generally
+ * available only for hypervisors running with root privileges.
+ *
+ * Returns the XML string which must be freed by the caller, or
+ * NULL if there was an error.
+ */
+char *
+virConnectGetSysinfo(virConnectPtr conn, unsigned int flags)
+{
+ VIR_DEBUG("conn=%p, flags=%x", conn, flags);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, NULL);
+
+ if (conn->driver->connectGetSysinfo) {
+ char *ret = conn->driver->connectGetSysinfo(conn, flags);
+ if (!ret)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return NULL;
+}
+
+
+/**
+ * virConnectGetMaxVcpus:
+ * @conn: pointer to the hypervisor connection
+ * @type: value of the 'type' attribute in the <domain> element
+ *
+ * Provides the maximum number of virtual CPUs supported for a guest VM of a
+ * specific type. The 'type' parameter here corresponds to the 'type'
+ * attribute in the <domain> element of the XML.
+ *
+ * Returns the maximum of virtual CPU or -1 in case of error.
+ */
+int
+virConnectGetMaxVcpus(virConnectPtr conn,
+ const char *type)
+{
+ VIR_DEBUG("conn=%p, type=%s", conn, type);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+
+ if (conn->driver->connectGetMaxVcpus) {
+ int ret = conn->driver->connectGetMaxVcpus(conn, type);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virNodeGetInfo:
+ * @conn: pointer to the hypervisor connection
+ * @info: pointer to a virNodeInfo structure allocated by the user
+ *
+ * Extract hardware information about the node.
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+int
+virNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info)
+{
+ VIR_DEBUG("conn=%p, info=%p", conn, info);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virCheckNonNullArgGoto(info, error);
+
+ if (conn->driver->nodeGetInfo) {
+ int ret;
+ ret = conn->driver->nodeGetInfo(conn, info);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virConnectGetCapabilities:
+ * @conn: pointer to the hypervisor connection
+ *
+ * Provides capabilities of the hypervisor / driver.
+ *
+ * Returns NULL in case of error, or an XML string
+ * defining the capabilities.
+ * The client must free the returned string after use.
+ */
+char *
+virConnectGetCapabilities(virConnectPtr conn)
+{
+ VIR_DEBUG("conn=%p", conn);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, NULL);
+
+ if (conn->driver->connectGetCapabilities) {
+ char *ret;
+ ret = conn->driver->connectGetCapabilities(conn);
+ if (!ret)
+ goto error;
+ VIR_DEBUG("conn=%p ret=%s", conn, ret);
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return NULL;
+}
+
+
+/**
+ * virNodeGetCPUStats:
+ * @conn: pointer to the hypervisor connection.
+ * @cpuNum: number of node cpu. (VIR_NODE_CPU_STATS_ALL_CPUS means total cpu
+ * statistics)
+ * @params: pointer to node cpu time parameter objects
+ * @nparams: number of node cpu time parameter (this value should be same or
+ * less than the number of parameters supported)
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * This function provides individual cpu statistics of the node.
+ * If you want to get total cpu statistics of the node, you must specify
+ * VIR_NODE_CPU_STATS_ALL_CPUS to @cpuNum.
+ * The @params array will be filled with the values equal to the number of
+ * parameters suggested by @nparams
+ *
+ * As the value of @nparams is dynamic, call the API setting @nparams to 0 and
+ * @params as NULL, the API returns the number of parameters supported by the
+ * HV by updating @nparams on SUCCESS. The caller should then allocate @params
+ * array, i.e. (sizeof(@virNodeCPUStats) * @nparams) bytes and call
+ * the API again.
+ *
+ * Here is a sample code snippet:
+ *
+ * if (virNodeGetCPUStats(conn, cpuNum, NULL, &nparams, 0) == 0 &&
+ * nparams != 0) {
+ * if ((params = malloc(sizeof(virNodeCPUStats) * nparams)) == NULL)
+ * goto error;
+ * memset(params, 0, sizeof(virNodeCPUStats) * nparams);
+ * if (virNodeGetCPUStats(conn, cpuNum, params, &nparams, 0))
+ * goto error;
+ * }
+ *
+ * This function doesn't require privileged access to the hypervisor.
+ * This function expects the caller to allocate the @params.
+ *
+ * CPU time Statistics:
+ *
+ * VIR_NODE_CPU_STATS_KERNEL:
+ * The cumulative CPU time which spends by kernel,
+ * when the node booting up.(nanoseconds)
+ * VIR_NODE_CPU_STATS_USER:
+ * The cumulative CPU time which spends by user processes,
+ * when the node booting up.(nanoseconds)
+ * VIR_NODE_CPU_STATS_IDLE:
+ * The cumulative idle CPU time, when the node booting up.(nanoseconds)
+ * VIR_NODE_CPU_STATS_IOWAIT:
+ * The cumulative I/O wait CPU time, when the node booting up.(nanoseconds)
+ * VIR_NODE_CPU_STATS_UTILIZATION:
+ * The CPU utilization. The usage value is in percent and 100%
+ * represents all CPUs on the server.
+ *
+ * Returns -1 in case of error, 0 in case of success.
+ */
+int
+virNodeGetCPUStats(virConnectPtr conn,
+ int cpuNum,
+ virNodeCPUStatsPtr params,
+ int *nparams, unsigned int flags)
+{
+ VIR_DEBUG("conn=%p, cpuNum=%d, params=%p, nparams=%d, flags=%x",
+ conn, cpuNum, params, nparams ? *nparams : -1, flags);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virCheckNonNullArgGoto(nparams, error);
+ virCheckNonNegativeArgGoto(*nparams, error);
+ if (cpuNum < 0 && cpuNum != VIR_NODE_CPU_STATS_ALL_CPUS) {
+ virReportInvalidArg(cpuNum,
+ _("cpuNum in %s only accepts %d as a negative "
+ "value"),
+ __FUNCTION__, VIR_NODE_CPU_STATS_ALL_CPUS);
+ goto error;
+ }
+
+ if (conn->driver->nodeGetCPUStats) {
+ int ret;
+ ret = conn->driver->nodeGetCPUStats(conn, cpuNum, params, nparams, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virNodeGetMemoryStats:
+ * @conn: pointer to the hypervisor connection.
+ * @cellNum: number of node cell. (VIR_NODE_MEMORY_STATS_ALL_CELLS means total
+ * cell statistics)
+ * @params: pointer to node memory stats objects
+ * @nparams: number of node memory stats (this value should be same or
+ * less than the number of stats supported)
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * This function provides memory stats of the node.
+ * If you want to get total memory statistics of the node, you must specify
+ * VIR_NODE_MEMORY_STATS_ALL_CELLS to @cellNum.
+ * The @params array will be filled with the values equal to the number of
+ * stats suggested by @nparams
+ *
+ * As the value of @nparams is dynamic, call the API setting @nparams to 0 and
+ * @params as NULL, the API returns the number of parameters supported by the
+ * HV by updating @nparams on SUCCESS. The caller should then allocate @params
+ * array, i.e. (sizeof(@virNodeMemoryStats) * @nparams) bytes and call
+ * the API again.
+ *
+ * Here is the sample code snippet:
+ *
+ * if (virNodeGetMemoryStats(conn, cellNum, NULL, &nparams, 0) == 0 &&
+ * nparams != 0) {
+ * if ((params = malloc(sizeof(virNodeMemoryStats) * nparams)) == NULL)
+ * goto error;
+ * memset(params, cellNum, 0, sizeof(virNodeMemoryStats) * nparams);
+ * if (virNodeGetMemoryStats(conn, params, &nparams, 0))
+ * goto error;
+ * }
+ *
+ * This function doesn't require privileged access to the hypervisor.
+ * This function expects the caller to allocate the @params.
+ *
+ * Memory Stats:
+ *
+ * VIR_NODE_MEMORY_STATS_TOTAL:
+ * The total memory usage.(KB)
+ * VIR_NODE_MEMORY_STATS_FREE:
+ * The free memory usage.(KB)
+ * On linux, this usage includes buffers and cached.
+ * VIR_NODE_MEMORY_STATS_BUFFERS:
+ * The buffers memory usage.(KB)
+ * VIR_NODE_MEMORY_STATS_CACHED:
+ * The cached memory usage.(KB)
+ *
+ * Returns -1 in case of error, 0 in case of success.
+ */
+int
+virNodeGetMemoryStats(virConnectPtr conn,
+ int cellNum,
+ virNodeMemoryStatsPtr params,
+ int *nparams, unsigned int flags)
+{
+ VIR_DEBUG("conn=%p, cellNum=%d, params=%p, nparams=%d, flags=%x",
+ conn, cellNum, params, nparams ? *nparams : -1, flags);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virCheckNonNullArgGoto(nparams, error);
+ virCheckNonNegativeArgGoto(*nparams, error);
+ if (cellNum < 0 && cellNum != VIR_NODE_MEMORY_STATS_ALL_CELLS) {
+ virReportInvalidArg(cpuNum,
+ _("cellNum in %s only accepts %d as a negative "
+ "value"),
+ __FUNCTION__, VIR_NODE_MEMORY_STATS_ALL_CELLS);
+ goto error;
+ }
+
+ if (conn->driver->nodeGetMemoryStats) {
+ int ret;
+ ret = conn->driver->nodeGetMemoryStats(conn, cellNum, params, nparams, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virNodeGetFreeMemory:
+ * @conn: pointer to the hypervisor connection
+ *
+ * provides the free memory available on the Node
+ * Note: most libvirt APIs provide memory sizes in kibibytes, but in this
+ * function the returned value is in bytes. Divide by 1024 as necessary.
+ *
+ * Returns the available free memory in bytes or 0 in case of error
+ */
+unsigned long long
+virNodeGetFreeMemory(virConnectPtr conn)
+{
+ VIR_DEBUG("conn=%p", conn);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, 0);
+
+ if (conn->driver->nodeGetFreeMemory) {
+ unsigned long long ret;
+ ret = conn->driver->nodeGetFreeMemory(conn);
+ if (ret == 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return 0;
+}
+
+
+/**
+ * virNodeSuspendForDuration:
+ * @conn: pointer to the hypervisor connection
+ * @target: the state to which the host must be suspended to,
+ * such as: VIR_NODE_SUSPEND_TARGET_MEM (Suspend-to-RAM)
+ * VIR_NODE_SUSPEND_TARGET_DISK (Suspend-to-Disk)
+ * VIR_NODE_SUSPEND_TARGET_HYBRID (Hybrid-Suspend,
+ * which is a combination of the former modes).
+ * @duration: the time duration in seconds for which the host
+ * has to be suspended
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * Attempt to suspend the node (host machine) for the given duration of
+ * time in the specified state (Suspend-to-RAM, Suspend-to-Disk or
+ * Hybrid-Suspend). Schedule the node's Real-Time-Clock interrupt to
+ * resume the node after the duration is complete.
+ *
+ * Returns 0 on success (i.e., the node will be suspended after a short
+ * delay), -1 on failure (the operation is not supported, or an attempted
+ * suspend is already underway).
+ */
+int
+virNodeSuspendForDuration(virConnectPtr conn,
+ unsigned int target,
+ unsigned long long duration,
+ unsigned int flags)
+{
+ VIR_DEBUG("conn=%p, target=%d, duration=%lld, flags=%x",
+ conn, target, duration, flags);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virCheckReadOnlyGoto(conn->flags, error);
+
+ if (conn->driver->nodeSuspendForDuration) {
+ int ret;
+ ret = conn->driver->nodeSuspendForDuration(conn, target,
+ duration, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ 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 (parameters unsupported by OS will be
+ * omitted). 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();
+
+ virCheckConnectReturn(conn, -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;
+ }
+
+ virReportUnsupportedError();
+
+ 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. The function
+ * fails if not all of the tunables are supported.
+ *
+ * Note that it's not recommended to use this function while the
+ * outside tuning program is running (such as ksmtuned under Linux),
+ * as they could change the tunables in parallel, which could cause
+ * conflicts.
+ *
+ * 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);
+ VIR_TYPED_PARAMS_DEBUG(params, nparams);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virCheckReadOnlyGoto(conn->flags, 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;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virNodeGetSecurityModel:
+ * @conn: a connection object
+ * @secmodel: pointer to a virSecurityModel structure
+ *
+ * Extract the security model of a hypervisor. The 'model' field
+ * in the @secmodel argument may be initialized to the empty
+ * string if the driver has not activated a security model.
+ *
+ * Returns 0 in case of success, -1 in case of failure
+ */
+int
+virNodeGetSecurityModel(virConnectPtr conn, virSecurityModelPtr secmodel)
+{
+ VIR_DEBUG("conn=%p secmodel=%p", conn, secmodel);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virCheckNonNullArgGoto(secmodel, error);
+
+ if (conn->driver->nodeGetSecurityModel) {
+ int ret;
+ ret = conn->driver->nodeGetSecurityModel(conn, secmodel);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virNodeGetCellsFreeMemory:
+ * @conn: pointer to the hypervisor connection
+ * @freeMems: pointer to the array of unsigned long long
+ * @startCell: index of first cell to return freeMems info on.
+ * @maxCells: Maximum number of cells for which freeMems information can
+ * be returned.
+ *
+ * This call returns the amount of free memory in one or more NUMA cells.
+ * The @freeMems array must be allocated by the caller and will be filled
+ * with the amount of free memory in bytes for each cell requested,
+ * starting with startCell (in freeMems[0]), up to either
+ * (startCell + maxCells), or the number of additional cells in the node,
+ * whichever is smaller.
+ *
+ * Returns the number of entries filled in freeMems, or -1 in case of error.
+ */
+int
+virNodeGetCellsFreeMemory(virConnectPtr conn, unsigned long long *freeMems,
+ int startCell, int maxCells)
+{
+ VIR_DEBUG("conn=%p, freeMems=%p, startCell=%d, maxCells=%d",
+ conn, freeMems, startCell, maxCells);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virCheckNonNullArgGoto(freeMems, error);
+ virCheckPositiveArgGoto(maxCells, error);
+ virCheckNonNegativeArgGoto(startCell, error);
+
+ if (conn->driver->nodeGetCellsFreeMemory) {
+ int ret;
+ ret = conn->driver->nodeGetCellsFreeMemory(conn, freeMems, startCell, maxCells);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virConnectIsEncrypted:
+ * @conn: pointer to the connection object
+ *
+ * Determine if the connection to the hypervisor is encrypted
+ *
+ * Returns 1 if encrypted, 0 if not encrypted, -1 on error
+ */
+int
+virConnectIsEncrypted(virConnectPtr conn)
+{
+ VIR_DEBUG("conn=%p", conn);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ if (conn->driver->connectIsEncrypted) {
+ int ret;
+ ret = conn->driver->connectIsEncrypted(conn);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virConnectIsSecure:
+ * @conn: pointer to the connection object
+ *
+ * Determine if the connection to the hypervisor is secure
+ *
+ * A connection will be classed as secure if it is either
+ * encrypted, or running over a channel which is not exposed
+ * to eavesdropping (eg a UNIX domain socket, or pipe)
+ *
+ * Returns 1 if secure, 0 if not secure, -1 on error
+ */
+int
+virConnectIsSecure(virConnectPtr conn)
+{
+ VIR_DEBUG("conn=%p", conn);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ if (conn->driver->connectIsSecure) {
+ int ret;
+ ret = conn->driver->connectIsSecure(conn);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virConnectCompareCPU:
+ * @conn: virConnect connection
+ * @xmlDesc: XML describing the CPU to compare with host CPU
+ * @flags: bitwise-OR of virConnectCompareCPUFlags
+ *
+ * Compares the given CPU description with the host CPU
+ *
+ * Returns comparison result according to enum virCPUCompareResult. If
+ * VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE is used and @xmlDesc CPU is
+ * incompatible with host CPU, this function will return VIR_CPU_COMPARE_ERROR
+ * (instead of VIR_CPU_COMPARE_INCOMPATIBLE) and the error will use the
+ * VIR_ERR_CPU_INCOMPATIBLE code with a message providing more details about
+ * the incompatibility.
+ */
+int
+virConnectCompareCPU(virConnectPtr conn,
+ const char *xmlDesc,
+ unsigned int flags)
+{
+ VIR_DEBUG("conn=%p, xmlDesc=%s, flags=%x", conn, xmlDesc, flags);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, VIR_CPU_COMPARE_ERROR);
+ virCheckNonNullArgGoto(xmlDesc, error);
+
+ if (conn->driver->connectCompareCPU) {
+ int ret;
+
+ ret = conn->driver->connectCompareCPU(conn, xmlDesc, flags);
+ if (ret == VIR_CPU_COMPARE_ERROR)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return VIR_CPU_COMPARE_ERROR;
+}
+
+
+/**
+ * virConnectGetCPUModelNames:
+ *
+ * @conn: virConnect connection
+ * @arch: Architecture
+ * @models: Pointer to a variable to store the NULL-terminated array of the
+ * CPU models supported for the specified architecture. Each element
+ * and the array itself must be freed by the caller with free. Pass
+ * NULL if only the list length is needed.
+ * @flags: extra flags; not used yet, so callers should always pass 0.
+ *
+ * Get the list of supported CPU models for a specific architecture.
+ *
+ * Returns -1 on error, number of elements in @models on success.
+ */
+int
+virConnectGetCPUModelNames(virConnectPtr conn, const char *arch, char ***models,
+ unsigned int flags)
+{
+ VIR_DEBUG("conn=%p, arch=%s, models=%p, flags=%x",
+ conn, arch, models, flags);
+ virResetLastError();
+
+ if (models)
+ *models = NULL;
+
+ virCheckConnectReturn(conn, -1);
+ virCheckNonNullArgGoto(arch, error);
+
+ if (conn->driver->connectGetCPUModelNames) {
+ int ret;
+
+ ret = conn->driver->connectGetCPUModelNames(conn, arch, models, flags);
+ if (ret < 0)
+ goto error;
+
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virConnectBaselineCPU:
+ *
+ * @conn: virConnect connection
+ * @xmlCPUs: array of XML descriptions of host CPUs
+ * @ncpus: number of CPUs in xmlCPUs
+ * @flags: bitwise-OR of virConnectBaselineCPUFlags
+ *
+ * Computes the most feature-rich CPU which is compatible with all given
+ * host CPUs.
+ *
+ * If @flags includes VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES then libvirt
+ * will explicitly list all CPU features that are part of the host CPU,
+ * without this flag features that are part of the CPU model will not be
+ * listed.
+ *
+ * Returns XML description of the computed CPU (caller frees) or NULL on error.
+ */
+char *
+virConnectBaselineCPU(virConnectPtr conn,
+ const char **xmlCPUs,
+ unsigned int ncpus,
+ unsigned int flags)
+{
+ size_t i;
+
+ VIR_DEBUG("conn=%p, xmlCPUs=%p, ncpus=%u, flags=%x",
+ conn, xmlCPUs, ncpus, flags);
+ if (xmlCPUs) {
+ for (i = 0; i < ncpus; i++)
+ VIR_DEBUG("xmlCPUs[%zu]=%s", i, NULLSTR(xmlCPUs[i]));
+ }
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, NULL);
+ virCheckNonNullArgGoto(xmlCPUs, error);
+
+ if (conn->driver->connectBaselineCPU) {
+ char *cpu;
+
+ cpu = conn->driver->connectBaselineCPU(conn, xmlCPUs, ncpus, flags);
+ if (!cpu)
+ goto error;
+ return cpu;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return NULL;
+}
+
+
+/**
+ * virConnectSetKeepAlive:
+ * @conn: pointer to a hypervisor connection
+ * @interval: number of seconds of inactivity before a keepalive message is sent
+ * @count: number of messages that can be sent in a row
+ *
+ * Start sending keepalive messages after @interval seconds of inactivity and
+ * consider the connection to be broken when no response is received after
+ * @count keepalive messages sent in a row. In other words, sending count + 1
+ * keepalive message results in closing the connection. When @interval is
+ * <= 0, no keepalive messages will be sent. When @count is 0, the connection
+ * will be automatically closed after @interval seconds of inactivity without
+ * sending any keepalive messages.
+ *
+ * Note: The client has to implement and run an event loop with
+ * virEventRegisterImpl() or virEventRegisterDefaultImpl() to be able to
+ * use keepalive messages. Failure to do so may result in connections
+ * being closed unexpectedly.
+ *
+ * Note: This API function controls only keepalive messages sent by the client.
+ * If the server is configured to use keepalive you still need to run the event
+ * loop to respond to them, even if you disable keepalives by this function.
+ *
+ * Returns -1 on error, 0 on success, 1 when remote party doesn't support
+ * keepalive messages.
+ */
+int
+virConnectSetKeepAlive(virConnectPtr conn,
+ int interval,
+ unsigned int count)
+{
+ int ret = -1;
+
+ VIR_DEBUG("conn=%p, interval=%d, count=%u", conn, interval, count);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+
+ if (conn->driver->connectSetKeepAlive) {
+ ret = conn->driver->connectSetKeepAlive(conn, interval, count);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virConnectIsAlive:
+ * @conn: pointer to the connection object
+ *
+ * Determine if the connection to the hypervisor is still alive
+ *
+ * A connection will be classed as alive if it is either local, or running
+ * over a channel (TCP or UNIX socket) which is not closed.
+ *
+ * Returns 1 if alive, 0 if dead, -1 on error
+ */
+int
+virConnectIsAlive(virConnectPtr conn)
+{
+ VIR_DEBUG("conn=%p", conn);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ if (conn->driver->connectIsAlive) {
+ int ret;
+ ret = conn->driver->connectIsAlive(conn);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virConnectRegisterCloseCallback:
+ * @conn: pointer to connection object
+ * @cb: callback to invoke upon close
+ * @opaque: user data to pass to @cb
+ * @freecb: callback to free @opaque
+ *
+ * Registers a callback to be invoked when the connection
+ * is closed. This callback is invoked when there is any
+ * condition that causes the socket connection to the
+ * hypervisor to be closed.
+ *
+ * This function is only applicable to hypervisor drivers
+ * which maintain a persistent open connection. Drivers
+ * which open a new connection for every operation will
+ * not invoke this.
+ *
+ * The @freecb must not invoke any other libvirt public
+ * APIs, since it is not called from a re-entrant safe
+ * context.
+ *
+ * Returns 0 on success, -1 on error
+ */
+int
+virConnectRegisterCloseCallback(virConnectPtr conn,
+ virConnectCloseFunc cb,
+ void *opaque,
+ virFreeCallback freecb)
+{
+ VIR_DEBUG("conn=%p", conn);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+
+ virObjectRef(conn);
+
+ virMutexLock(&conn->lock);
+ virObjectLock(conn->closeCallback);
+
+ virCheckNonNullArgGoto(cb, error);
+
+ if (conn->closeCallback->callback) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("A close callback is already registered"));
+ goto error;
+ }
+
+ conn->closeCallback->conn = conn;
+ conn->closeCallback->callback = cb;
+ conn->closeCallback->opaque = opaque;
+ conn->closeCallback->freeCallback = freecb;
+
+ virObjectUnlock(conn->closeCallback);
+ virMutexUnlock(&conn->lock);
+
+ return 0;
+
+ error:
+ virObjectUnlock(conn->closeCallback);
+ virMutexUnlock(&conn->lock);
+ virDispatchError(conn);
+ virObjectUnref(conn);
+ return -1;
+}
+
+
+/**
+ * virConnectUnregisterCloseCallback:
+ * @conn: pointer to connection object
+ * @cb: pointer to the current registered callback
+ *
+ * Unregisters the callback previously set with the
+ * virConnectRegisterCloseCallback method. The callback
+ * will no longer receive notifications when the connection
+ * closes. If a virFreeCallback was provided at time of
+ * registration, it will be invoked
+ *
+ * Returns 0 on success, -1 on error
+ */
+int
+virConnectUnregisterCloseCallback(virConnectPtr conn,
+ virConnectCloseFunc cb)
+{
+ VIR_DEBUG("conn=%p", conn);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+
+ virMutexLock(&conn->lock);
+ virObjectLock(conn->closeCallback);
+
+ virCheckNonNullArgGoto(cb, error);
+
+ if (conn->closeCallback->callback != cb) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("A different callback was requested"));
+ goto error;
+ }
+
+ conn->closeCallback->callback = NULL;
+ if (conn->closeCallback->freeCallback)
+ conn->closeCallback->freeCallback(conn->closeCallback->opaque);
+ conn->closeCallback->freeCallback = NULL;
+
+ virObjectUnref(conn);
+ virObjectUnlock(conn->closeCallback);
+ virMutexUnlock(&conn->lock);
+
+ return 0;
+
+ error:
+ virObjectUnlock(conn->closeCallback);
+ virMutexUnlock(&conn->lock);
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virNodeGetCPUMap:
+ * @conn: pointer to the hypervisor connection
+ * @cpumap: optional pointer to a bit map of real CPUs on the host node
+ * (in 8-bit bytes) (OUT)
+ * In case of success each bit set to 1 means that corresponding
+ * CPU is online.
+ * Bytes are stored in little-endian order: CPU0-7, 8-15...
+ * In each byte, lowest CPU number is least significant bit.
+ * The bit map is allocated by virNodeGetCPUMap and needs
+ * to be released using free() by the caller.
+ * @online: optional number of online CPUs in cpumap (OUT)
+ * Contains the number of online CPUs if the call was successful.
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * Get CPU map of host node CPUs.
+ *
+ * Returns number of CPUs present on the host node,
+ * or -1 if there was an error.
+ */
+int
+virNodeGetCPUMap(virConnectPtr conn,
+ unsigned char **cpumap,
+ unsigned int *online,
+ unsigned int flags)
+{
+ VIR_DEBUG("conn=%p, cpumap=%p, online=%p, flags=%x",
+ conn, cpumap, online, flags);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+
+ if (conn->driver->nodeGetCPUMap) {
+ int ret = conn->driver->nodeGetCPUMap(conn, cpumap, online, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virNodeGetFreePages:
+ * @conn: pointer to the hypervisor connection
+ * @npages: number of items in the @pages array
+ * @pages: page sizes to query
+ * @startCell: index of first cell to return free pages info on.
+ * @cellCount: maximum number of cells for which free pages
+ * information can be returned.
+ * @counts: returned counts of free pages
+ * @flags: extra flags; not used yet, so callers should always pass 0
+ *
+ * This calls queries the host system on free pages of
+ * specified size. For the input, @pages is expected to be
+ * filled with pages that caller is interested in (the size
+ * unit is kibibytes, so e.g. pass 2048 for 2MB), then @startcell
+ * refers to the first NUMA node that info should be collected
+ * from, and @cellcount tells how many consecutive nodes should
+ * be queried. On the function output, @counts is filled with
+ * desired information, where items are grouped by NUMA node.
+ * So from @counts[0] till @counts[@npages - 1] you'll find count
+ * for the first node (@startcell), then from @counts[@npages]
+ * till @count[2 * @npages - 1] you'll find info for the
+ * (@startcell + 1) node, and so on. It's callers responsibility
+ * to allocate the @counts array.
+ *
+ * Example how to use this API:
+ *
+ * unsigned int pages[] = { 4, 2048, 1048576}
+ * unsigned int npages = ARRAY_CARDINALITY(pages);
+ * int startcell = 0;
+ * unsigned int cellcount = 2;
+ *
+ * unsigned long long counts = malloc(sizeof(long long) * npages * cellcount);
+ *
+ * virNodeGetFreePages(conn, pages, npages,
+ * startcell, cellcount, counts, 0);
+ *
+ * for (i = 0 ; i < cellcount ; i++) {
+ * fprintf(stdout, "Cell %d\n", startcell + i);
+ * for (j = 0 ; j < npages ; j++) {
+ * fprintf(stdout, " Page size=%d count=%d bytes=%llu\n",
+ * pages[j], counts[(i * npages) + j],
+ * pages[j] * counts[(i * npages) + j]);
+ * }
+ * }
+ *
+ * This little code snippet will produce something like this:
+ * Cell 0
+ * Page size=4096 count=300 bytes=1228800
+ * Page size=2097152 count=0 bytes=0
+ * Page size=1073741824 count=1 bytes=1073741824
+ * Cell 1
+ * Page size=4096 count=0 bytes=0
+ * Page size=2097152 count=20 bytes=41943040
+ * Page size=1073741824 count=0 bytes=0
+ *
+ * Returns: the number of entries filled in @counts or -1 in case of error.
+ */
+int
+virNodeGetFreePages(virConnectPtr conn,
+ unsigned int npages,
+ unsigned int *pages,
+ int startCell,
+ unsigned int cellCount,
+ unsigned long long *counts,
+ unsigned int flags)
+{
+ VIR_DEBUG("conn=%p, npages=%u, pages=%p, startCell=%u, "
+ "cellCount=%u, counts=%p, flags=%x",
+ conn, npages, pages, startCell, cellCount, counts, flags);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virCheckNonZeroArgGoto(npages, error);
+ virCheckNonNullArgGoto(pages, error);
+ virCheckNonZeroArgGoto(cellCount, error);
+ virCheckNonNullArgGoto(counts, error);
+
+ if (conn->driver->nodeGetFreePages) {
+ int ret;
+ ret = conn->driver->nodeGetFreePages(conn, npages, pages, startCell,
+ cellCount, counts, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+ error:
+ virDispatchError(conn);
+ return -1;
+}
+
+
+/**
+ * virNodeAllocPages:
+ * @conn: pointer to the hypervisor connection
+ * @npages: number of items in the @pageSizes and
+ * @pageCounts arrays
+ * @pageSizes: which huge page sizes to allocate
+ * @pageCounts: how many pages should be allocated
+ * @startCell: index of first cell to allocate pages on
+ * @cellCount: number of consecutive cells to allocate pages on
+ * @flags: extra flags; binary-OR of virNodeAllocPagesFlags
+ *
+ * Sometimes, when trying to start a new domain, it may be
+ * necessary to reserve some huge pages in the system pool which
+ * can be then allocated by the domain. This API serves that
+ * purpose. On its input, @pageSizes and @pageCounts are arrays
+ * of the same cardinality of @npages. The @pageSizes contains
+ * page sizes which are to be allocated in the system (the size
+ * unit is kibibytes), and @pageCounts then contains the number
+ * of pages to reserve. If @flags is 0
+ * (VIR_NODE_ALLOC_PAGES_ADD), each pool corresponding to
+ * @pageSizes grows by the number of pages specified in the
+ * corresponding @pageCounts. If @flags contains
+ * VIR_NODE_ALLOC_PAGES_SET, each pool mentioned is resized to
+ * the given number of pages. The pages pool can be allocated
+ * over several NUMA nodes at once, just point at @startCell and
+ * tell how many subsequent NUMA nodes should be taken in. As a
+ * special case, if @startCell is equal to negative one, then
+ * kernel is instructed to allocate the pages over all NUMA nodes
+ * proportionally.
+ *
+ * Returns: the number of nodes successfully adjusted or -1 in
+ * case of an error.
+ */
+int
+virNodeAllocPages(virConnectPtr conn,
+ unsigned int npages,
+ unsigned int *pageSizes,
+ unsigned long long *pageCounts,
+ int startCell,
+ unsigned int cellCount,
+ unsigned int flags)
+{
+ VIR_DEBUG("conn=%p npages=%u pageSizes=%p pageCounts=%p "
+ "startCell=%d cellCount=%u flagx=%x",
+ conn, npages, pageSizes, pageCounts, startCell,
+ cellCount, flags);
+
+ virResetLastError();
+
+ virCheckConnectReturn(conn, -1);
+ virCheckReadOnlyGoto(conn->flags, error);
+ virCheckNonZeroArgGoto(npages, error);
+ virCheckNonNullArgGoto(pageSizes, error);
+ virCheckNonNullArgGoto(pageCounts, error);
+ virCheckNonZeroArgGoto(cellCount, error);
+
+ if (conn->driver->nodeAllocPages) {
+ int ret;
+ ret = conn->driver->nodeAllocPages(conn, npages, pageSizes,
+ pageCounts, startCell,
+ cellCount, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virReportUnsupportedError();
+ error:
+ virDispatchError(conn);
+ return -1;
+}
diff --git a/src/libvirt.c b/src/libvirt.c
index ceee342..5594883 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -1443,62 +1443,6 @@ virConnectClose(virConnectPtr conn)
}
-/**
- * virConnectRef:
- * @conn: the connection to hold a reference on
- *
- * Increment the reference count on the connection. For each
- * additional call to this method, there shall be a corresponding
- * call to virConnectClose to release the reference count, once
- * the caller no longer needs the reference to this object.
- *
- * This method is typically useful for applications where multiple
- * threads are using a connection, and it is required that the
- * connection remain open until all threads have finished using
- * it. ie, each new thread using a connection would increment
- * the reference count.
- *
- * Returns 0 in case of success, -1 in case of failure
- */
-int
-virConnectRef(virConnectPtr conn)
-{
- VIR_DEBUG("conn=%p refs=%d", conn, conn ? conn->object.u.s.refs : 0);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virObjectRef(conn);
- return 0;
-}
-
-
-/*
- * Not for public use. This function is part of the internal
- * implementation of driver features in the remote case.
- */
-int
-virConnectSupportsFeature(virConnectPtr conn, int feature)
-{
- int ret;
- VIR_DEBUG("conn=%p, feature=%d", conn, feature);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
-
- if (!conn->driver->connectSupportsFeature)
- ret = 0;
- else
- ret = conn->driver->connectSupportsFeature(conn, feature);
-
- if (ret < 0)
- virDispatchError(conn);
-
- return ret;
-}
-
-
/* Helper function called to validate incoming client array on any
* interface that sets typed parameters in the hypervisor. */
int
@@ -1539,1431 +1483,3 @@ virTypedParameterValidateSet(virConnectPtr conn,
}
return 0;
}
-
-
-/**
- * virConnectGetType:
- * @conn: pointer to the hypervisor connection
- *
- * Get the name of the Hypervisor driver used. This is merely the driver
- * name; for example, both KVM and QEMU guests are serviced by the
- * driver for the qemu:// URI, so a return of "QEMU" does not indicate
- * whether KVM acceleration is present. For more details about the
- * hypervisor, use virConnectGetCapabilities().
- *
- * Returns NULL in case of error, a static zero terminated string otherwise.
- *
- * See also:
- * http://www.redhat.com/archives/libvir-list/2007-February/msg00096.html
- */
-const char *
-virConnectGetType(virConnectPtr conn)
-{
- const char *ret;
- VIR_DEBUG("conn=%p", conn);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, NULL);
-
- if (conn->driver->connectGetType) {
- ret = conn->driver->connectGetType(conn);
- if (ret) return ret;
- }
- return conn->driver->name;
-}
-
-
-/**
- * virConnectGetVersion:
- * @conn: pointer to the hypervisor connection
- * @hvVer: return value for the version of the running hypervisor (OUT)
- *
- * Get the version level of the Hypervisor running. This may work only with
- * hypervisor call, i.e. with privileged access to the hypervisor, not
- * with a Read-Only connection.
- *
- * Returns -1 in case of error, 0 otherwise. if the version can't be
- * extracted by lack of capacities returns 0 and @hvVer is 0, otherwise
- * @hvVer value is major * 1,000,000 + minor * 1,000 + release
- */
-int
-virConnectGetVersion(virConnectPtr conn, unsigned long *hvVer)
-{
- VIR_DEBUG("conn=%p, hvVer=%p", conn, hvVer);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virCheckNonNullArgGoto(hvVer, error);
-
- if (conn->driver->connectGetVersion) {
- int ret = conn->driver->connectGetVersion(conn, hvVer);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virConnectGetLibVersion:
- * @conn: pointer to the hypervisor connection
- * @libVer: returns the libvirt library version used on the connection (OUT)
- *
- * Provides @libVer, which is the version of libvirt used by the
- * daemon running on the @conn host
- *
- * Returns -1 in case of failure, 0 otherwise, and values for @libVer have
- * the format major * 1,000,000 + minor * 1,000 + release.
- */
-int
-virConnectGetLibVersion(virConnectPtr conn, unsigned long *libVer)
-{
- int ret = -1;
- VIR_DEBUG("conn=%p, libVir=%p", conn, libVer);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virCheckNonNullArgGoto(libVer, error);
-
- if (conn->driver->connectGetLibVersion) {
- ret = conn->driver->connectGetLibVersion(conn, libVer);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- *libVer = LIBVIR_VERSION_NUMBER;
- return 0;
-
- error:
- virDispatchError(conn);
- return ret;
-}
-
-
-/**
- * virConnectGetHostname:
- * @conn: pointer to a hypervisor connection
- *
- * This returns a system hostname on which the hypervisor is
- * running (based on the result of the gethostname system call, but
- * possibly expanded to a fully-qualified domain name via getaddrinfo).
- * If we are connected to a remote system, then this returns the
- * hostname of the remote system.
- *
- * Returns the hostname which must be freed by the caller, or
- * NULL if there was an error.
- */
-char *
-virConnectGetHostname(virConnectPtr conn)
-{
- VIR_DEBUG("conn=%p", conn);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, NULL);
-
- if (conn->driver->connectGetHostname) {
- char *ret = conn->driver->connectGetHostname(conn);
- if (!ret)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return NULL;
-}
-
-
-/**
- * virConnectGetURI:
- * @conn: pointer to a hypervisor connection
- *
- * This returns the URI (name) of the hypervisor connection.
- * Normally this is the same as or similar to the string passed
- * to the virConnectOpen/virConnectOpenReadOnly call, but
- * the driver may make the URI canonical. If name == NULL
- * was passed to virConnectOpen, then the driver will return
- * a non-NULL URI which can be used to connect to the same
- * hypervisor later.
- *
- * Returns the URI string which must be freed by the caller, or
- * NULL if there was an error.
- */
-char *
-virConnectGetURI(virConnectPtr conn)
-{
- char *name;
- VIR_DEBUG("conn=%p", conn);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, NULL);
-
- if (!(name = virURIFormat(conn->uri)))
- goto error;
-
- return name;
-
- error:
- virDispatchError(conn);
- return NULL;
-}
-
-
-/**
- * virConnectGetSysinfo:
- * @conn: pointer to a hypervisor connection
- * @flags: extra flags; not used yet, so callers should always pass 0
- *
- * This returns the XML description of the sysinfo details for the
- * host on which the hypervisor is running, in the same format as the
- * <sysinfo> element of a domain XML. This information is generally
- * available only for hypervisors running with root privileges.
- *
- * Returns the XML string which must be freed by the caller, or
- * NULL if there was an error.
- */
-char *
-virConnectGetSysinfo(virConnectPtr conn, unsigned int flags)
-{
- VIR_DEBUG("conn=%p, flags=%x", conn, flags);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, NULL);
-
- if (conn->driver->connectGetSysinfo) {
- char *ret = conn->driver->connectGetSysinfo(conn, flags);
- if (!ret)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return NULL;
-}
-
-
-/**
- * virConnectGetMaxVcpus:
- * @conn: pointer to the hypervisor connection
- * @type: value of the 'type' attribute in the <domain> element
- *
- * Provides the maximum number of virtual CPUs supported for a guest VM of a
- * specific type. The 'type' parameter here corresponds to the 'type'
- * attribute in the <domain> element of the XML.
- *
- * Returns the maximum of virtual CPU or -1 in case of error.
- */
-int
-virConnectGetMaxVcpus(virConnectPtr conn,
- const char *type)
-{
- VIR_DEBUG("conn=%p, type=%s", conn, type);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
-
- if (conn->driver->connectGetMaxVcpus) {
- int ret = conn->driver->connectGetMaxVcpus(conn, type);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virNodeGetInfo:
- * @conn: pointer to the hypervisor connection
- * @info: pointer to a virNodeInfo structure allocated by the user
- *
- * Extract hardware information about the node.
- *
- * Returns 0 in case of success and -1 in case of failure.
- */
-int
-virNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info)
-{
- VIR_DEBUG("conn=%p, info=%p", conn, info);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virCheckNonNullArgGoto(info, error);
-
- if (conn->driver->nodeGetInfo) {
- int ret;
- ret = conn->driver->nodeGetInfo(conn, info);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virConnectGetCapabilities:
- * @conn: pointer to the hypervisor connection
- *
- * Provides capabilities of the hypervisor / driver.
- *
- * Returns NULL in case of error, or an XML string
- * defining the capabilities.
- * The client must free the returned string after use.
- */
-char *
-virConnectGetCapabilities(virConnectPtr conn)
-{
- VIR_DEBUG("conn=%p", conn);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, NULL);
-
- if (conn->driver->connectGetCapabilities) {
- char *ret;
- ret = conn->driver->connectGetCapabilities(conn);
- if (!ret)
- goto error;
- VIR_DEBUG("conn=%p ret=%s", conn, ret);
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return NULL;
-}
-
-
-/**
- * virNodeGetCPUStats:
- * @conn: pointer to the hypervisor connection.
- * @cpuNum: number of node cpu. (VIR_NODE_CPU_STATS_ALL_CPUS means total cpu
- * statistics)
- * @params: pointer to node cpu time parameter objects
- * @nparams: number of node cpu time parameter (this value should be same or
- * less than the number of parameters supported)
- * @flags: extra flags; not used yet, so callers should always pass 0
- *
- * This function provides individual cpu statistics of the node.
- * If you want to get total cpu statistics of the node, you must specify
- * VIR_NODE_CPU_STATS_ALL_CPUS to @cpuNum.
- * The @params array will be filled with the values equal to the number of
- * parameters suggested by @nparams
- *
- * As the value of @nparams is dynamic, call the API setting @nparams to 0 and
- * @params as NULL, the API returns the number of parameters supported by the
- * HV by updating @nparams on SUCCESS. The caller should then allocate @params
- * array, i.e. (sizeof(@virNodeCPUStats) * @nparams) bytes and call
- * the API again.
- *
- * Here is a sample code snippet:
- *
- * if (virNodeGetCPUStats(conn, cpuNum, NULL, &nparams, 0) == 0 &&
- * nparams != 0) {
- * if ((params = malloc(sizeof(virNodeCPUStats) * nparams)) == NULL)
- * goto error;
- * memset(params, 0, sizeof(virNodeCPUStats) * nparams);
- * if (virNodeGetCPUStats(conn, cpuNum, params, &nparams, 0))
- * goto error;
- * }
- *
- * This function doesn't require privileged access to the hypervisor.
- * This function expects the caller to allocate the @params.
- *
- * CPU time Statistics:
- *
- * VIR_NODE_CPU_STATS_KERNEL:
- * The cumulative CPU time which spends by kernel,
- * when the node booting up.(nanoseconds)
- * VIR_NODE_CPU_STATS_USER:
- * The cumulative CPU time which spends by user processes,
- * when the node booting up.(nanoseconds)
- * VIR_NODE_CPU_STATS_IDLE:
- * The cumulative idle CPU time, when the node booting up.(nanoseconds)
- * VIR_NODE_CPU_STATS_IOWAIT:
- * The cumulative I/O wait CPU time, when the node booting up.(nanoseconds)
- * VIR_NODE_CPU_STATS_UTILIZATION:
- * The CPU utilization. The usage value is in percent and 100%
- * represents all CPUs on the server.
- *
- * Returns -1 in case of error, 0 in case of success.
- */
-int
-virNodeGetCPUStats(virConnectPtr conn,
- int cpuNum,
- virNodeCPUStatsPtr params,
- int *nparams, unsigned int flags)
-{
- VIR_DEBUG("conn=%p, cpuNum=%d, params=%p, nparams=%d, flags=%x",
- conn, cpuNum, params, nparams ? *nparams : -1, flags);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virCheckNonNullArgGoto(nparams, error);
- virCheckNonNegativeArgGoto(*nparams, error);
- if (cpuNum < 0 && cpuNum != VIR_NODE_CPU_STATS_ALL_CPUS) {
- virReportInvalidArg(cpuNum,
- _("cpuNum in %s only accepts %d as a negative "
- "value"),
- __FUNCTION__, VIR_NODE_CPU_STATS_ALL_CPUS);
- goto error;
- }
-
- if (conn->driver->nodeGetCPUStats) {
- int ret;
- ret = conn->driver->nodeGetCPUStats(conn, cpuNum, params, nparams, flags);
- if (ret < 0)
- goto error;
- return ret;
- }
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virNodeGetMemoryStats:
- * @conn: pointer to the hypervisor connection.
- * @cellNum: number of node cell. (VIR_NODE_MEMORY_STATS_ALL_CELLS means total
- * cell statistics)
- * @params: pointer to node memory stats objects
- * @nparams: number of node memory stats (this value should be same or
- * less than the number of stats supported)
- * @flags: extra flags; not used yet, so callers should always pass 0
- *
- * This function provides memory stats of the node.
- * If you want to get total memory statistics of the node, you must specify
- * VIR_NODE_MEMORY_STATS_ALL_CELLS to @cellNum.
- * The @params array will be filled with the values equal to the number of
- * stats suggested by @nparams
- *
- * As the value of @nparams is dynamic, call the API setting @nparams to 0 and
- * @params as NULL, the API returns the number of parameters supported by the
- * HV by updating @nparams on SUCCESS. The caller should then allocate @params
- * array, i.e. (sizeof(@virNodeMemoryStats) * @nparams) bytes and call
- * the API again.
- *
- * Here is the sample code snippet:
- *
- * if (virNodeGetMemoryStats(conn, cellNum, NULL, &nparams, 0) == 0 &&
- * nparams != 0) {
- * if ((params = malloc(sizeof(virNodeMemoryStats) * nparams)) == NULL)
- * goto error;
- * memset(params, cellNum, 0, sizeof(virNodeMemoryStats) * nparams);
- * if (virNodeGetMemoryStats(conn, params, &nparams, 0))
- * goto error;
- * }
- *
- * This function doesn't require privileged access to the hypervisor.
- * This function expects the caller to allocate the @params.
- *
- * Memory Stats:
- *
- * VIR_NODE_MEMORY_STATS_TOTAL:
- * The total memory usage.(KB)
- * VIR_NODE_MEMORY_STATS_FREE:
- * The free memory usage.(KB)
- * On linux, this usage includes buffers and cached.
- * VIR_NODE_MEMORY_STATS_BUFFERS:
- * The buffers memory usage.(KB)
- * VIR_NODE_MEMORY_STATS_CACHED:
- * The cached memory usage.(KB)
- *
- * Returns -1 in case of error, 0 in case of success.
- */
-int
-virNodeGetMemoryStats(virConnectPtr conn,
- int cellNum,
- virNodeMemoryStatsPtr params,
- int *nparams, unsigned int flags)
-{
- VIR_DEBUG("conn=%p, cellNum=%d, params=%p, nparams=%d, flags=%x",
- conn, cellNum, params, nparams ? *nparams : -1, flags);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virCheckNonNullArgGoto(nparams, error);
- virCheckNonNegativeArgGoto(*nparams, error);
- if (cellNum < 0 && cellNum != VIR_NODE_MEMORY_STATS_ALL_CELLS) {
- virReportInvalidArg(cpuNum,
- _("cellNum in %s only accepts %d as a negative "
- "value"),
- __FUNCTION__, VIR_NODE_MEMORY_STATS_ALL_CELLS);
- goto error;
- }
-
- if (conn->driver->nodeGetMemoryStats) {
- int ret;
- ret = conn->driver->nodeGetMemoryStats(conn, cellNum, params, nparams, flags);
- if (ret < 0)
- goto error;
- return ret;
- }
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virNodeGetFreeMemory:
- * @conn: pointer to the hypervisor connection
- *
- * provides the free memory available on the Node
- * Note: most libvirt APIs provide memory sizes in kibibytes, but in this
- * function the returned value is in bytes. Divide by 1024 as necessary.
- *
- * Returns the available free memory in bytes or 0 in case of error
- */
-unsigned long long
-virNodeGetFreeMemory(virConnectPtr conn)
-{
- VIR_DEBUG("conn=%p", conn);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, 0);
-
- if (conn->driver->nodeGetFreeMemory) {
- unsigned long long ret;
- ret = conn->driver->nodeGetFreeMemory(conn);
- if (ret == 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return 0;
-}
-
-
-/**
- * virNodeSuspendForDuration:
- * @conn: pointer to the hypervisor connection
- * @target: the state to which the host must be suspended to,
- * such as: VIR_NODE_SUSPEND_TARGET_MEM (Suspend-to-RAM)
- * VIR_NODE_SUSPEND_TARGET_DISK (Suspend-to-Disk)
- * VIR_NODE_SUSPEND_TARGET_HYBRID (Hybrid-Suspend,
- * which is a combination of the former modes).
- * @duration: the time duration in seconds for which the host
- * has to be suspended
- * @flags: extra flags; not used yet, so callers should always pass 0
- *
- * Attempt to suspend the node (host machine) for the given duration of
- * time in the specified state (Suspend-to-RAM, Suspend-to-Disk or
- * Hybrid-Suspend). Schedule the node's Real-Time-Clock interrupt to
- * resume the node after the duration is complete.
- *
- * Returns 0 on success (i.e., the node will be suspended after a short
- * delay), -1 on failure (the operation is not supported, or an attempted
- * suspend is already underway).
- */
-int
-virNodeSuspendForDuration(virConnectPtr conn,
- unsigned int target,
- unsigned long long duration,
- unsigned int flags)
-{
- VIR_DEBUG("conn=%p, target=%d, duration=%lld, flags=%x",
- conn, target, duration, flags);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virCheckReadOnlyGoto(conn->flags, error);
-
- if (conn->driver->nodeSuspendForDuration) {
- int ret;
- ret = conn->driver->nodeSuspendForDuration(conn, target,
- duration, flags);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- 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 (parameters unsupported by OS will be
- * omitted). 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();
-
- virCheckConnectReturn(conn, -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;
- }
-
- virReportUnsupportedError();
-
- 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. The function
- * fails if not all of the tunables are supported.
- *
- * Note that it's not recommended to use this function while the
- * outside tuning program is running (such as ksmtuned under Linux),
- * as they could change the tunables in parallel, which could cause
- * conflicts.
- *
- * 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);
- VIR_TYPED_PARAMS_DEBUG(params, nparams);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virCheckReadOnlyGoto(conn->flags, 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;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virNodeGetSecurityModel:
- * @conn: a connection object
- * @secmodel: pointer to a virSecurityModel structure
- *
- * Extract the security model of a hypervisor. The 'model' field
- * in the @secmodel argument may be initialized to the empty
- * string if the driver has not activated a security model.
- *
- * Returns 0 in case of success, -1 in case of failure
- */
-int
-virNodeGetSecurityModel(virConnectPtr conn, virSecurityModelPtr secmodel)
-{
- VIR_DEBUG("conn=%p secmodel=%p", conn, secmodel);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virCheckNonNullArgGoto(secmodel, error);
-
- if (conn->driver->nodeGetSecurityModel) {
- int ret;
- ret = conn->driver->nodeGetSecurityModel(conn, secmodel);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virNodeGetCellsFreeMemory:
- * @conn: pointer to the hypervisor connection
- * @freeMems: pointer to the array of unsigned long long
- * @startCell: index of first cell to return freeMems info on.
- * @maxCells: Maximum number of cells for which freeMems information can
- * be returned.
- *
- * This call returns the amount of free memory in one or more NUMA cells.
- * The @freeMems array must be allocated by the caller and will be filled
- * with the amount of free memory in bytes for each cell requested,
- * starting with startCell (in freeMems[0]), up to either
- * (startCell + maxCells), or the number of additional cells in the node,
- * whichever is smaller.
- *
- * Returns the number of entries filled in freeMems, or -1 in case of error.
- */
-int
-virNodeGetCellsFreeMemory(virConnectPtr conn, unsigned long long *freeMems,
- int startCell, int maxCells)
-{
- VIR_DEBUG("conn=%p, freeMems=%p, startCell=%d, maxCells=%d",
- conn, freeMems, startCell, maxCells);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virCheckNonNullArgGoto(freeMems, error);
- virCheckPositiveArgGoto(maxCells, error);
- virCheckNonNegativeArgGoto(startCell, error);
-
- if (conn->driver->nodeGetCellsFreeMemory) {
- int ret;
- ret = conn->driver->nodeGetCellsFreeMemory(conn, freeMems, startCell, maxCells);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virConnectIsEncrypted:
- * @conn: pointer to the connection object
- *
- * Determine if the connection to the hypervisor is encrypted
- *
- * Returns 1 if encrypted, 0 if not encrypted, -1 on error
- */
-int
-virConnectIsEncrypted(virConnectPtr conn)
-{
- VIR_DEBUG("conn=%p", conn);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- if (conn->driver->connectIsEncrypted) {
- int ret;
- ret = conn->driver->connectIsEncrypted(conn);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virConnectIsSecure:
- * @conn: pointer to the connection object
- *
- * Determine if the connection to the hypervisor is secure
- *
- * A connection will be classed as secure if it is either
- * encrypted, or running over a channel which is not exposed
- * to eavesdropping (eg a UNIX domain socket, or pipe)
- *
- * Returns 1 if secure, 0 if not secure, -1 on error
- */
-int
-virConnectIsSecure(virConnectPtr conn)
-{
- VIR_DEBUG("conn=%p", conn);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- if (conn->driver->connectIsSecure) {
- int ret;
- ret = conn->driver->connectIsSecure(conn);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virConnectCompareCPU:
- * @conn: virConnect connection
- * @xmlDesc: XML describing the CPU to compare with host CPU
- * @flags: bitwise-OR of virConnectCompareCPUFlags
- *
- * Compares the given CPU description with the host CPU
- *
- * Returns comparison result according to enum virCPUCompareResult. If
- * VIR_CONNECT_COMPARE_CPU_FAIL_INCOMPATIBLE is used and @xmlDesc CPU is
- * incompatible with host CPU, this function will return VIR_CPU_COMPARE_ERROR
- * (instead of VIR_CPU_COMPARE_INCOMPATIBLE) and the error will use the
- * VIR_ERR_CPU_INCOMPATIBLE code with a message providing more details about
- * the incompatibility.
- */
-int
-virConnectCompareCPU(virConnectPtr conn,
- const char *xmlDesc,
- unsigned int flags)
-{
- VIR_DEBUG("conn=%p, xmlDesc=%s, flags=%x", conn, xmlDesc, flags);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, VIR_CPU_COMPARE_ERROR);
- virCheckNonNullArgGoto(xmlDesc, error);
-
- if (conn->driver->connectCompareCPU) {
- int ret;
-
- ret = conn->driver->connectCompareCPU(conn, xmlDesc, flags);
- if (ret == VIR_CPU_COMPARE_ERROR)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return VIR_CPU_COMPARE_ERROR;
-}
-
-
-/**
- * virConnectGetCPUModelNames:
- *
- * @conn: virConnect connection
- * @arch: Architecture
- * @models: Pointer to a variable to store the NULL-terminated array of the
- * CPU models supported for the specified architecture. Each element
- * and the array itself must be freed by the caller with free. Pass
- * NULL if only the list length is needed.
- * @flags: extra flags; not used yet, so callers should always pass 0.
- *
- * Get the list of supported CPU models for a specific architecture.
- *
- * Returns -1 on error, number of elements in @models on success.
- */
-int
-virConnectGetCPUModelNames(virConnectPtr conn, const char *arch, char ***models,
- unsigned int flags)
-{
- VIR_DEBUG("conn=%p, arch=%s, models=%p, flags=%x",
- conn, arch, models, flags);
- virResetLastError();
-
- if (models)
- *models = NULL;
-
- virCheckConnectReturn(conn, -1);
- virCheckNonNullArgGoto(arch, error);
-
- if (conn->driver->connectGetCPUModelNames) {
- int ret;
-
- ret = conn->driver->connectGetCPUModelNames(conn, arch, models, flags);
- if (ret < 0)
- goto error;
-
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virConnectBaselineCPU:
- *
- * @conn: virConnect connection
- * @xmlCPUs: array of XML descriptions of host CPUs
- * @ncpus: number of CPUs in xmlCPUs
- * @flags: bitwise-OR of virConnectBaselineCPUFlags
- *
- * Computes the most feature-rich CPU which is compatible with all given
- * host CPUs.
- *
- * If @flags includes VIR_CONNECT_BASELINE_CPU_EXPAND_FEATURES then libvirt
- * will explicitly list all CPU features that are part of the host CPU,
- * without this flag features that are part of the CPU model will not be
- * listed.
- *
- * Returns XML description of the computed CPU (caller frees) or NULL on error.
- */
-char *
-virConnectBaselineCPU(virConnectPtr conn,
- const char **xmlCPUs,
- unsigned int ncpus,
- unsigned int flags)
-{
- size_t i;
-
- VIR_DEBUG("conn=%p, xmlCPUs=%p, ncpus=%u, flags=%x",
- conn, xmlCPUs, ncpus, flags);
- if (xmlCPUs) {
- for (i = 0; i < ncpus; i++)
- VIR_DEBUG("xmlCPUs[%zu]=%s", i, NULLSTR(xmlCPUs[i]));
- }
-
- virResetLastError();
-
- virCheckConnectReturn(conn, NULL);
- virCheckNonNullArgGoto(xmlCPUs, error);
-
- if (conn->driver->connectBaselineCPU) {
- char *cpu;
-
- cpu = conn->driver->connectBaselineCPU(conn, xmlCPUs, ncpus, flags);
- if (!cpu)
- goto error;
- return cpu;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return NULL;
-}
-
-
-/**
- * virConnectSetKeepAlive:
- * @conn: pointer to a hypervisor connection
- * @interval: number of seconds of inactivity before a keepalive message is sent
- * @count: number of messages that can be sent in a row
- *
- * Start sending keepalive messages after @interval seconds of inactivity and
- * consider the connection to be broken when no response is received after
- * @count keepalive messages sent in a row. In other words, sending count + 1
- * keepalive message results in closing the connection. When @interval is
- * <= 0, no keepalive messages will be sent. When @count is 0, the connection
- * will be automatically closed after @interval seconds of inactivity without
- * sending any keepalive messages.
- *
- * Note: The client has to implement and run an event loop with
- * virEventRegisterImpl() or virEventRegisterDefaultImpl() to be able to
- * use keepalive messages. Failure to do so may result in connections
- * being closed unexpectedly.
- *
- * Note: This API function controls only keepalive messages sent by the client.
- * If the server is configured to use keepalive you still need to run the event
- * loop to respond to them, even if you disable keepalives by this function.
- *
- * Returns -1 on error, 0 on success, 1 when remote party doesn't support
- * keepalive messages.
- */
-int
-virConnectSetKeepAlive(virConnectPtr conn,
- int interval,
- unsigned int count)
-{
- int ret = -1;
-
- VIR_DEBUG("conn=%p, interval=%d, count=%u", conn, interval, count);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
-
- if (conn->driver->connectSetKeepAlive) {
- ret = conn->driver->connectSetKeepAlive(conn, interval, count);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virConnectIsAlive:
- * @conn: pointer to the connection object
- *
- * Determine if the connection to the hypervisor is still alive
- *
- * A connection will be classed as alive if it is either local, or running
- * over a channel (TCP or UNIX socket) which is not closed.
- *
- * Returns 1 if alive, 0 if dead, -1 on error
- */
-int
-virConnectIsAlive(virConnectPtr conn)
-{
- VIR_DEBUG("conn=%p", conn);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- if (conn->driver->connectIsAlive) {
- int ret;
- ret = conn->driver->connectIsAlive(conn);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virConnectRegisterCloseCallback:
- * @conn: pointer to connection object
- * @cb: callback to invoke upon close
- * @opaque: user data to pass to @cb
- * @freecb: callback to free @opaque
- *
- * Registers a callback to be invoked when the connection
- * is closed. This callback is invoked when there is any
- * condition that causes the socket connection to the
- * hypervisor to be closed.
- *
- * This function is only applicable to hypervisor drivers
- * which maintain a persistent open connection. Drivers
- * which open a new connection for every operation will
- * not invoke this.
- *
- * The @freecb must not invoke any other libvirt public
- * APIs, since it is not called from a re-entrant safe
- * context.
- *
- * Returns 0 on success, -1 on error
- */
-int
-virConnectRegisterCloseCallback(virConnectPtr conn,
- virConnectCloseFunc cb,
- void *opaque,
- virFreeCallback freecb)
-{
- VIR_DEBUG("conn=%p", conn);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
-
- virObjectRef(conn);
-
- virMutexLock(&conn->lock);
- virObjectLock(conn->closeCallback);
-
- virCheckNonNullArgGoto(cb, error);
-
- if (conn->closeCallback->callback) {
- virReportError(VIR_ERR_OPERATION_INVALID, "%s",
- _("A close callback is already registered"));
- goto error;
- }
-
- conn->closeCallback->conn = conn;
- conn->closeCallback->callback = cb;
- conn->closeCallback->opaque = opaque;
- conn->closeCallback->freeCallback = freecb;
-
- virObjectUnlock(conn->closeCallback);
- virMutexUnlock(&conn->lock);
-
- return 0;
-
- error:
- virObjectUnlock(conn->closeCallback);
- virMutexUnlock(&conn->lock);
- virDispatchError(conn);
- virObjectUnref(conn);
- return -1;
-}
-
-
-/**
- * virConnectUnregisterCloseCallback:
- * @conn: pointer to connection object
- * @cb: pointer to the current registered callback
- *
- * Unregisters the callback previously set with the
- * virConnectRegisterCloseCallback method. The callback
- * will no longer receive notifications when the connection
- * closes. If a virFreeCallback was provided at time of
- * registration, it will be invoked
- *
- * Returns 0 on success, -1 on error
- */
-int
-virConnectUnregisterCloseCallback(virConnectPtr conn,
- virConnectCloseFunc cb)
-{
- VIR_DEBUG("conn=%p", conn);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
-
- virMutexLock(&conn->lock);
- virObjectLock(conn->closeCallback);
-
- virCheckNonNullArgGoto(cb, error);
-
- if (conn->closeCallback->callback != cb) {
- virReportError(VIR_ERR_OPERATION_INVALID, "%s",
- _("A different callback was requested"));
- goto error;
- }
-
- conn->closeCallback->callback = NULL;
- if (conn->closeCallback->freeCallback)
- conn->closeCallback->freeCallback(conn->closeCallback->opaque);
- conn->closeCallback->freeCallback = NULL;
-
- virObjectUnref(conn);
- virObjectUnlock(conn->closeCallback);
- virMutexUnlock(&conn->lock);
-
- return 0;
-
- error:
- virObjectUnlock(conn->closeCallback);
- virMutexUnlock(&conn->lock);
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virNodeGetCPUMap:
- * @conn: pointer to the hypervisor connection
- * @cpumap: optional pointer to a bit map of real CPUs on the host node
- * (in 8-bit bytes) (OUT)
- * In case of success each bit set to 1 means that corresponding
- * CPU is online.
- * Bytes are stored in little-endian order: CPU0-7, 8-15...
- * In each byte, lowest CPU number is least significant bit.
- * The bit map is allocated by virNodeGetCPUMap and needs
- * to be released using free() by the caller.
- * @online: optional number of online CPUs in cpumap (OUT)
- * Contains the number of online CPUs if the call was successful.
- * @flags: extra flags; not used yet, so callers should always pass 0
- *
- * Get CPU map of host node CPUs.
- *
- * Returns number of CPUs present on the host node,
- * or -1 if there was an error.
- */
-int
-virNodeGetCPUMap(virConnectPtr conn,
- unsigned char **cpumap,
- unsigned int *online,
- unsigned int flags)
-{
- VIR_DEBUG("conn=%p, cpumap=%p, online=%p, flags=%x",
- conn, cpumap, online, flags);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
-
- if (conn->driver->nodeGetCPUMap) {
- int ret = conn->driver->nodeGetCPUMap(conn, cpumap, online, flags);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
-
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virNodeGetFreePages:
- * @conn: pointer to the hypervisor connection
- * @npages: number of items in the @pages array
- * @pages: page sizes to query
- * @startCell: index of first cell to return free pages info on.
- * @cellCount: maximum number of cells for which free pages
- * information can be returned.
- * @counts: returned counts of free pages
- * @flags: extra flags; not used yet, so callers should always pass 0
- *
- * This calls queries the host system on free pages of
- * specified size. For the input, @pages is expected to be
- * filled with pages that caller is interested in (the size
- * unit is kibibytes, so e.g. pass 2048 for 2MB), then @startcell
- * refers to the first NUMA node that info should be collected
- * from, and @cellcount tells how many consecutive nodes should
- * be queried. On the function output, @counts is filled with
- * desired information, where items are grouped by NUMA node.
- * So from @counts[0] till @counts[@npages - 1] you'll find count
- * for the first node (@startcell), then from @counts[@npages]
- * till @count[2 * @npages - 1] you'll find info for the
- * (@startcell + 1) node, and so on. It's callers responsibility
- * to allocate the @counts array.
- *
- * Example how to use this API:
- *
- * unsigned int pages[] = { 4, 2048, 1048576}
- * unsigned int npages = ARRAY_CARDINALITY(pages);
- * int startcell = 0;
- * unsigned int cellcount = 2;
- *
- * unsigned long long counts = malloc(sizeof(long long) * npages * cellcount);
- *
- * virNodeGetFreePages(conn, pages, npages,
- * startcell, cellcount, counts, 0);
- *
- * for (i = 0 ; i < cellcount ; i++) {
- * fprintf(stdout, "Cell %d\n", startcell + i);
- * for (j = 0 ; j < npages ; j++) {
- * fprintf(stdout, " Page size=%d count=%d bytes=%llu\n",
- * pages[j], counts[(i * npages) + j],
- * pages[j] * counts[(i * npages) + j]);
- * }
- * }
- *
- * This little code snippet will produce something like this:
- * Cell 0
- * Page size=4096 count=300 bytes=1228800
- * Page size=2097152 count=0 bytes=0
- * Page size=1073741824 count=1 bytes=1073741824
- * Cell 1
- * Page size=4096 count=0 bytes=0
- * Page size=2097152 count=20 bytes=41943040
- * Page size=1073741824 count=0 bytes=0
- *
- * Returns: the number of entries filled in @counts or -1 in case of error.
- */
-int
-virNodeGetFreePages(virConnectPtr conn,
- unsigned int npages,
- unsigned int *pages,
- int startCell,
- unsigned int cellCount,
- unsigned long long *counts,
- unsigned int flags)
-{
- VIR_DEBUG("conn=%p, npages=%u, pages=%p, startCell=%u, "
- "cellCount=%u, counts=%p, flags=%x",
- conn, npages, pages, startCell, cellCount, counts, flags);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virCheckNonZeroArgGoto(npages, error);
- virCheckNonNullArgGoto(pages, error);
- virCheckNonZeroArgGoto(cellCount, error);
- virCheckNonNullArgGoto(counts, error);
-
- if (conn->driver->nodeGetFreePages) {
- int ret;
- ret = conn->driver->nodeGetFreePages(conn, npages, pages, startCell,
- cellCount, counts, flags);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
- error:
- virDispatchError(conn);
- return -1;
-}
-
-
-/**
- * virNodeAllocPages:
- * @conn: pointer to the hypervisor connection
- * @npages: number of items in the @pageSizes and
- * @pageCounts arrays
- * @pageSizes: which huge page sizes to allocate
- * @pageCounts: how many pages should be allocated
- * @startCell: index of first cell to allocate pages on
- * @cellCount: number of consecutive cells to allocate pages on
- * @flags: extra flags; binary-OR of virNodeAllocPagesFlags
- *
- * Sometimes, when trying to start a new domain, it may be
- * necessary to reserve some huge pages in the system pool which
- * can be then allocated by the domain. This API serves that
- * purpose. On its input, @pageSizes and @pageCounts are arrays
- * of the same cardinality of @npages. The @pageSizes contains
- * page sizes which are to be allocated in the system (the size
- * unit is kibibytes), and @pageCounts then contains the number
- * of pages to reserve. If @flags is 0
- * (VIR_NODE_ALLOC_PAGES_ADD), each pool corresponding to
- * @pageSizes grows by the number of pages specified in the
- * corresponding @pageCounts. If @flags contains
- * VIR_NODE_ALLOC_PAGES_SET, each pool mentioned is resized to
- * the given number of pages. The pages pool can be allocated
- * over several NUMA nodes at once, just point at @startCell and
- * tell how many subsequent NUMA nodes should be taken in. As a
- * special case, if @startCell is equal to negative one, then
- * kernel is instructed to allocate the pages over all NUMA nodes
- * proportionally.
- *
- * Returns: the number of nodes successfully adjusted or -1 in
- * case of an error.
- */
-int
-virNodeAllocPages(virConnectPtr conn,
- unsigned int npages,
- unsigned int *pageSizes,
- unsigned long long *pageCounts,
- int startCell,
- unsigned int cellCount,
- unsigned int flags)
-{
- VIR_DEBUG("conn=%p npages=%u pageSizes=%p pageCounts=%p "
- "startCell=%d cellCount=%u flagx=%x",
- conn, npages, pageSizes, pageCounts, startCell,
- cellCount, flags);
-
- virResetLastError();
-
- virCheckConnectReturn(conn, -1);
- virCheckReadOnlyGoto(conn->flags, error);
- virCheckNonZeroArgGoto(npages, error);
- virCheckNonNullArgGoto(pageSizes, error);
- virCheckNonNullArgGoto(pageCounts, error);
- virCheckNonZeroArgGoto(cellCount, error);
-
- if (conn->driver->nodeAllocPages) {
- int ret;
- ret = conn->driver->nodeAllocPages(conn, npages, pageSizes,
- pageCounts, startCell,
- cellCount, flags);
- if (ret < 0)
- goto error;
- return ret;
- }
-
- virReportUnsupportedError();
- error:
- virDispatchError(conn);
- return -1;
-}
--
2.1.0
--
libvir-list mailing list
libvir-list@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/libvir-list