#if defined(POLKIT_AUTH)
-static int virConnectAuthGainPolkit(const char *privilege) {
+static int
+virConnectAuthGainPolkit(const char *privilege)
+{
virCommandPtr cmd;
int status;
int ret = -1;
}
#endif
-static int virConnectAuthCallbackDefault(virConnectCredentialPtr cred,
- unsigned int ncred,
- void *cbdata ATTRIBUTE_UNUSED) {
+
+static int
+virConnectAuthCallbackDefault(virConnectCredentialPtr cred,
+ unsigned int ncred,
+ void *cbdata ATTRIBUTE_UNUSED)
+{
size_t i;
for (i = 0; i < ncred; i++) {
return 0;
}
+
/* Don't typically want VIR_CRED_USERNAME. It enables you to authenticate
* as one user, and act as another. It just results in annoying
* prompts for the username twice & is very rarely what you want
#ifdef WITH_GNUTLS_GCRYPT
-static int virTLSMutexInit(void **priv)
+static int
+virTLSMutexInit(void **priv)
{
virMutexPtr lock = NULL;
return 0;
}
-static int virTLSMutexDestroy(void **priv)
+
+static int
+virTLSMutexDestroy(void **priv)
{
virMutexPtr lock = *priv;
virMutexDestroy(lock);
return 0;
}
-static int virTLSMutexLock(void **priv)
+
+static int
+virTLSMutexLock(void **priv)
{
virMutexPtr lock = *priv;
virMutexLock(lock);
return 0;
}
-static int virTLSMutexUnlock(void **priv)
+
+static int
+virTLSMutexUnlock(void **priv)
{
virMutexPtr lock = *priv;
virMutexUnlock(lock);
return 0;
}
+
static struct gcry_thread_cbs virTLSThreadImpl = {
/* GCRY_THREAD_OPTION_VERSION was added in gcrypt 1.4.2 */
# ifdef GCRY_THREAD_OPTION_VERSION
virGlobalError = true;
}
+
/**
* virInitialize:
*
return 0;
}
+
#ifdef WIN32
BOOL WINAPI
DllMain(HINSTANCE instance, DWORD reason, LPVOID ignore);
}
#endif
+
#define virLibConnError(code, ...) \
virReportErrorHelper(VIR_FROM_NONE, code, __FILE__, \
__FUNCTION__, __LINE__, __VA_ARGS__)
return virNetworkDriverTabCount++;
}
+
/**
* virRegisterInterfaceDriver:
* @driver: pointer to an interface driver block
return virInterfaceDriverTabCount++;
}
+
/**
* virRegisterStorageDriver:
* @driver: pointer to a storage driver block
return virStorageDriverTabCount++;
}
+
/**
* virRegisterNodeDeviceDriver:
* @driver: pointer to a device monitor block
return virNodeDeviceDriverTabCount++;
}
+
/**
* virRegisterSecretDriver:
* @driver: pointer to a secret driver block
return virSecretDriverTabCount++;
}
+
/**
* virRegisterNWFilterDriver:
* @driver: pointer to a network filter driver block
return virDriverTabCount++;
}
+
#ifdef WITH_LIBVIRTD
/**
* virRegisterStateDriver:
return virStateDriverTabCount++;
}
+
/**
* virStateInitialize:
* @privileged: set to true if running with root privilege, false otherwise
*
* Returns 0 if all succeed, -1 upon any failure.
*/
-int virStateInitialize(bool privileged,
- virStateInhibitCallback callback,
- void *opaque)
+int
+virStateInitialize(bool privileged,
+ virStateInhibitCallback callback,
+ void *opaque)
{
size_t i;
return 0;
}
+
/**
* virStateCleanup:
*
*
* Returns 0 if all succeed, -1 upon any failure.
*/
-int virStateCleanup(void) {
+int
+virStateCleanup(void)
+{
size_t i;
int ret = 0;
return ret;
}
+
/**
* virStateReload:
*
*
* Returns 0 if all succeed, -1 upon any failure.
*/
-int virStateReload(void) {
+int
+virStateReload(void)
+{
size_t i;
int ret = 0;
return ret;
}
+
/**
* virStateStop:
*
*
* Returns 0 if successful, -1 on failure
*/
-int virStateStop(void) {
+int
+virStateStop(void)
+{
size_t i;
int ret = 0;
}
return ret;
}
-
-#endif
-
+#endif /* WITH_LIBVIRTD */
/**
return -1;
}
+
static char *
virConnectGetConfigFilePath(void)
{
return path;
}
+
static int
virConnectGetConfigFile(virConfPtr *conf)
{
#define URI_ALIAS_CHARS "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-"
+
static int
-virConnectOpenFindURIAliasMatch(virConfValuePtr value, const char *alias, char **uri)
+virConnectOpenFindURIAliasMatch(virConfValuePtr value, const char *alias,
+ char **uri)
{
virConfValuePtr entry;
size_t alias_len;
return 0;
}
+
static int
virConnectOpenResolveURIAlias(virConfPtr conf,
const char *alias, char **uri)
return ret;
}
+
static virConnectPtr
do_open(const char *name,
virConnectAuthPtr auth,
return NULL;
}
+
/**
* virConnectOpen:
* @name: (optional) URI of the hypervisor
return NULL;
}
+
/**
* virConnectOpenReadOnly:
* @name: (optional) URI of the hypervisor
return NULL;
}
+
/**
* virConnectOpenAuth:
* @name: (optional) URI of the hypervisor
return NULL;
}
+
/**
* virConnectClose:
* @conn: pointer to the hypervisor connection
return ret;
}
+
/**
* virConnectRef:
* @conn: the connection to hold a reference on
return 0;
}
+
/*
* Not for public use. This function is part of the internal
* implementation of driver features in the remote case.
return ret;
}
+
/**
* virConnectGetType:
* @conn: pointer to the hypervisor connection
return conn->driver->name;
}
+
/**
* virConnectGetVersion:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virConnectGetLibVersion:
* @conn: pointer to the hypervisor connection
return ret;
}
+
/**
* virConnectGetHostname:
* @conn: pointer to a hypervisor connection
return NULL;
}
+
/**
* virConnectGetURI:
* @conn: pointer to a hypervisor connection
return NULL;
}
+
/**
* virConnectGetSysinfo:
* @conn: pointer to a hypervisor connection
return NULL;
}
+
/**
* virConnectGetMaxVcpus:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virConnectListDomains:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virConnectNumOfDomains:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virDomainGetConnect:
* @dom: pointer to a domain
return dom->conn;
}
+
/**
* virDomainCreateXML:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virDomainCreateXMLWithFiles:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virDomainCreateLinux:
* @conn: pointer to the hypervisor connection
return virDomainCreateXML(conn, xmlDesc, flags);
}
+
/**
* virDomainLookupByID:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virDomainLookupByUUID:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virDomainLookupByUUIDString:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virDomainLookupByName:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virDomainDestroy:
* @domain: a domain object
return -1;
}
+
/**
* virDomainDestroyFlags:
* @domain: a domain object
return -1;
}
+
/**
* virDomainFree:
* @domain: a domain object
return 0;
}
+
/**
* virDomainRef:
* @domain: the domain to hold a reference on
return -1;
}
+
/**
* virDomainResume:
* @domain: a domain object
return -1;
}
+
/**
* virDomainPMSuspendForDuration:
* @dom: a domain object
return -1;
}
+
/**
* virDomainPMWakeup:
* @dom: a domain object
return -1;
}
+
/**
* virDomainSave:
* @domain: a domain object
return -1;
}
+
/**
* virDomainSaveFlags:
* @domain: a domain object
return -1;
}
+
/**
* virDomainRestore:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virDomainRestoreFlags:
* @conn: pointer to the hypervisor connection
*/
int
virDomainRestoreFlags(virConnectPtr conn, const char *from, const char *dxml,
- unsigned int flags)
+ unsigned int flags)
{
VIR_DEBUG("conn=%p, from=%s, dxml=%s, flags=%x",
conn, from, NULLSTR(dxml), flags);
return -1;
}
+
/**
* virDomainSaveImageGetXMLDesc:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virDomainSaveImageDefineXML:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virDomainCoreDump:
* @domain: a domain object
return -1;
}
+
/**
* virDomainScreenshot:
* @domain: a domain object
return NULL;
}
+
/**
* virDomainShutdown:
* @domain: a domain object
return -1;
}
+
/**
* virDomainShutdownFlags:
* @domain: a domain object
return -1;
}
+
/**
* virDomainReboot:
* @domain: a domain object
return -1;
}
+
/**
* virDomainReset:
* @domain: a domain object
return -1;
}
+
/**
* virDomainGetName:
* @domain: a domain object
return domain->name;
}
+
/**
* virDomainGetUUID:
* @domain: a domain object
return 0;
}
+
/**
* virDomainGetUUIDString:
* @domain: a domain object
return -1;
}
+
/**
* virDomainGetID:
* @domain: a domain object
return domain->id;
}
+
/**
* virDomainGetOSType:
* @domain: a domain object
return NULL;
}
+
/**
* virDomainGetMaxMemory:
* @domain: a domain object or NULL
return 0;
}
+
/**
* virDomainSetMaxMemory:
* @domain: a domain object or NULL
return -1;
}
+
/**
* virDomainSetMemory:
* @domain: a domain object or NULL
return -1;
}
+
/**
* virDomainSetMemoryFlags:
* @domain: a domain object or NULL
*
* Returns 0 in case of success, -1 in case of failure.
*/
-
int
virDomainSetMemoryFlags(virDomainPtr domain, unsigned long memory,
unsigned int flags)
return -1;
}
+
/**
* virDomainSetMemoryStatsPeriod:
* @domain: a domain object or NULL
*
* Returns 0 in case of success, -1 in case of failure.
*/
-
int
virDomainSetMemoryStatsPeriod(virDomainPtr domain, int period,
unsigned int flags)
return -1;
}
+
/* Helper function called to validate incoming client array on any
* interface that sets typed parameters in the hypervisor. */
static int
return 0;
}
+
/**
* virDomainSetMemoryParameters:
* @domain: pointer to domain object
return -1;
}
+
/**
* virDomainGetMemoryParameters:
* @domain: pointer to domain object
*
* Here is a sample code snippet:
*
- * if ((virDomainGetMemoryParameters(dom, NULL, &nparams, 0) == 0) &&
- * (nparams != 0)) {
+ * if (virDomainGetMemoryParameters(dom, NULL, &nparams, 0) == 0 &&
+ * nparams != 0) {
* if ((params = malloc(sizeof(*params) * nparams)) == NULL)
* goto error;
* memset(params, 0, sizeof(*params) * nparams);
return -1;
}
+
/**
* virDomainSetNumaParameters:
* @domain: pointer to domain object
return -1;
}
+
/**
* virDomainGetNumaParameters:
* @domain: pointer to domain object
*
* Returns -1 in case of error, 0 in case of success.
*/
-
int
virDomainGetNumaParameters(virDomainPtr domain,
virTypedParameterPtr params,
return -1;
}
+
/**
* virDomainSetBlkioParameters:
* @domain: pointer to domain object
*/
int
virDomainSetBlkioParameters(virDomainPtr domain,
- virTypedParameterPtr params,
- int nparams, unsigned int flags)
+ virTypedParameterPtr params,
+ int nparams, unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainGetBlkioParameters:
* @domain: pointer to domain object
*/
int
virDomainGetBlkioParameters(virDomainPtr domain,
- virTypedParameterPtr params,
- int *nparams, unsigned int flags)
+ virTypedParameterPtr params,
+ int *nparams, unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainGetInfo:
* @domain: a domain object
return -1;
}
+
/**
* virDomainGetState:
* @domain: a domain object
return -1;
}
+
/**
* virDomainGetControlInfo:
* @domain: a domain object
return -1;
}
+
/**
* virDomainGetXMLDesc:
* @domain: a domain object
return NULL;
}
+
/**
* virConnectDomainXMLFromNative:
* @conn: a connection object
* Returns a 0 terminated UTF-8 encoded XML instance, or NULL in case of error.
* the caller must free() the returned value.
*/
-char *virConnectDomainXMLFromNative(virConnectPtr conn,
- const char *nativeFormat,
- const char *nativeConfig,
- unsigned int flags)
+char *
+virConnectDomainXMLFromNative(virConnectPtr conn,
+ const char *nativeFormat,
+ const char *nativeConfig,
+ unsigned int flags)
{
VIR_DEBUG("conn=%p, format=%s, config=%s, flags=%x",
conn, nativeFormat, nativeConfig, flags);
return NULL;
}
+
/**
* virConnectDomainXMLToNative:
* @conn: a connection object
* Returns a 0 terminated UTF-8 encoded native config datafile, or NULL in case of error.
* the caller must free() the returned value.
*/
-char *virConnectDomainXMLToNative(virConnectPtr conn,
- const char *nativeFormat,
- const char *domainXml,
- unsigned int flags)
+char *
+virConnectDomainXMLToNative(virConnectPtr conn,
+ const char *nativeFormat,
+ const char *domainXml,
+ unsigned int flags)
{
VIR_DEBUG("conn=%p, format=%s, xml=%s, flags=%x",
conn, nativeFormat, domainXml, flags);
else
ddomain = virDomainLookupByName(dconn, dname);
- done:
+done:
VIR_FREE(uri_out);
VIR_FREE(cookie);
return ddomain;
}
+
/*
* Sequence v2:
*
ddomain = dconn->driver->domainMigrateFinish2
(dconn, dname, cookie, cookielen, uri, destflags, cancelled);
- done:
+done:
if (orig_err) {
virSetError(orig_err);
virFreeError(orig_err);
}
}
- done:
+done:
if (orig_err) {
virSetError(orig_err);
virFreeError(orig_err);
return ddomain;
}
+
static virDomainPtr
virDomainMigrateVersion3(virDomainPtr domain,
virConnectPtr dconn,
bandwidth, NULL, 0, false, flags);
}
+
static virDomainPtr
virDomainMigrateVersion3Params(virDomainPtr domain,
virConnectPtr dconn,
}
- /*
- * In normal migration, the libvirt client co-ordinates communication
- * between the 2 libvirtd instances on source & dest hosts.
- *
- * In this peer-2-peer migration alternative, the libvirt client
- * only talks to the source libvirtd instance. The source libvirtd
- * then opens its own connection to the destination and co-ordinates
- * migration itself.
- *
- * If useParams is true, params and nparams contain migration parameters and
- * we know it's safe to call the API which supports extensible parameters.
- * Otherwise, we have to use xmlin, dname, uri, and bandwidth and pass them
- * to the old-style APIs.
- */
+/*
+ * In normal migration, the libvirt client co-ordinates communication
+ * between the 2 libvirtd instances on source & dest hosts.
+ *
+ * In this peer-2-peer migration alternative, the libvirt client
+ * only talks to the source libvirtd instance. The source libvirtd
+ * then opens its own connection to the destination and co-ordinates
+ * migration itself.
+ *
+ * If useParams is true, params and nparams contain migration parameters and
+ * we know it's safe to call the API which supports extensible parameters.
+ * Otherwise, we have to use xmlin, dname, uri, and bandwidth and pass them
+ * to the old-style APIs.
+ */
static int
virDomainMigratePeer2PeerFull(virDomainPtr domain,
const char *dconnuri,
}
}
+
static int
virDomainMigratePeer2Peer(virDomainPtr domain,
const char *xmlin,
bandwidth, NULL, 0, false, flags);
}
+
static int
virDomainMigratePeer2PeerParams(virDomainPtr domain,
const char *dconnuri,
return -1;
}
+
/*
* Not for public use. This function is part of the internal
* implementation of migration in the remote case.
return -1;
}
+
/*
* Not for public use. This function is part of the internal
* implementation of migration in the remote case.
return -1;
}
+
/*
* Not for public use. This function is part of the internal
* implementation of migration in the remote case.
return -1;
}
+
/*
* Not for public use. This function is part of the internal
* implementation of migration in the remote case.
return -1;
}
+
/*
* Not for public use. This function is part of the internal
* implementation of migration in the remote case.
const char *dname,
unsigned long bandwidth,
const char *dom_xml)
-
{
VIR_DEBUG("conn=%p, stream=%p, cookiein=%p, cookieinlen=%d, cookieout=%p, "
"cookieoutlen=%p, flags=%lx, dname=%s, bandwidth=%lu, "
char **cookieout,
int *cookieoutlen,
unsigned int flags)
-
{
VIR_DEBUG("conn=%p, stream=%p, params=%p, nparams=%d, cookiein=%p, "
"cookieinlen=%d, cookieout=%p, cookieoutlen=%p, flags=%x",
return -1;
}
+
/**
* virConnectGetCapabilities:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virNodeGetCPUStats:
* @conn: pointer to the hypervisor connection.
*
* Returns -1 in case of error, 0 in case of success.
*/
-int virNodeGetCPUStats(virConnectPtr conn,
- int cpuNum,
- virNodeCPUStatsPtr params,
- int *nparams, unsigned int flags)
+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);
virCheckNonNullArgGoto(nparams, error);
virCheckNonNegativeArgGoto(*nparams, error);
- if (((cpuNum < 0) && (cpuNum != VIR_NODE_CPU_STATS_ALL_CPUS))) {
+ 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);
return -1;
}
+
/**
* virNodeGetMemoryStats:
* @conn: pointer to the hypervisor connection.
*
* Returns -1 in case of error, 0 in case of success.
*/
-int virNodeGetMemoryStats(virConnectPtr conn,
- int cellNum,
- virNodeMemoryStatsPtr params,
- int *nparams, unsigned int flags)
+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);
virCheckNonNullArgGoto(nparams, error);
virCheckNonNegativeArgGoto(*nparams, error);
- if (((cellNum < 0) && (cellNum != VIR_NODE_MEMORY_STATS_ALL_CELLS))) {
+ 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);
return -1;
}
+
/**
* virNodeGetFreeMemory:
* @conn: pointer to the hypervisor connection
return 0;
}
+
/**
* virNodeSuspendForDuration:
* @conn: pointer to the hypervisor connection
unsigned long long duration,
unsigned int flags)
{
-
VIR_DEBUG("conn=%p, target=%d, duration=%lld, flags=%x",
conn, target, duration, flags);
return -1;
}
+
/*
* virNodeGetMemoryParameters:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/*
* virNodeSetMemoryParameters:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virDomainGetSchedulerType:
* @domain: pointer to domain object
return -1;
}
+
/**
* virDomainGetSchedulerParametersFlags:
* @domain: pointer to domain object
return -1;
}
+
/**
* virDomainSetSchedulerParameters:
* @domain: pointer to domain object
return -1;
}
+
/**
* virDomainBlockStatsFlags:
* @dom: pointer to domain object
*
* Returns -1 in case of error, 0 in case of success.
*/
-int virDomainBlockStatsFlags(virDomainPtr dom,
- const char *disk,
- virTypedParameterPtr params,
- int *nparams,
- unsigned int flags)
+int
+virDomainBlockStatsFlags(virDomainPtr dom,
+ const char *disk,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags)
{
virConnectPtr conn;
return -1;
}
- /**
+
+/**
* virDomainSetInterfaceParameters:
* @domain: pointer to domain object
* @device: the interface name or mac address
return -1;
}
- /**
+
+/**
* virDomainGetInterfaceParameters:
* @domain: pointer to domain object
* @device: the interface name or mac address
*
* Returns -1 in case of error, 0 in case of success.
*/
-
int
virDomainGetInterfaceParameters(virDomainPtr domain,
const char *device,
return -1;
}
+
/**
* virDomainMemoryStats:
* @dom: pointer to the domain object
*
* Returns: The number of stats provided or -1 in case of failure.
*/
-int virDomainMemoryStats(virDomainPtr dom, virDomainMemoryStatPtr stats,
- unsigned int nr_stats, unsigned int flags)
+int
+virDomainMemoryStats(virDomainPtr dom, virDomainMemoryStatPtr stats,
+ unsigned int nr_stats, unsigned int flags)
{
virConnectPtr conn;
unsigned long nr_stats_ret = 0;
return -1;
}
+
/**
* virDomainBlockPeek:
* @dom: pointer to the domain object
return -1;
}
+
/**
* virDomainBlockResize:
* @dom: pointer to the domain object
*
* Returns: 0 in case of success or -1 in case of failure.
*/
-
int
virDomainBlockResize(virDomainPtr dom,
const char *disk,
return -1;
}
+
/**
* virDomainMemoryPeek:
* @dom: pointer to the domain object
* Returns NULL in case of error, a pointer to the domain otherwise
*/
virDomainPtr
-virDomainDefineXML(virConnectPtr conn, const char *xml) {
+virDomainDefineXML(virConnectPtr conn, const char *xml)
+{
VIR_DEBUG("conn=%p, xml=%s", conn, xml);
virResetLastError();
return NULL;
}
+
/**
* virDomainUndefine:
* @domain: pointer to a defined domain
* Returns 0 in case of success, -1 in case of error
*/
int
-virDomainUndefine(virDomainPtr domain) {
+virDomainUndefine(virDomainPtr domain)
+{
virConnectPtr conn;
VIR_DOMAIN_DEBUG(domain);
return -1;
}
+
/**
* virDomainUndefineFlags:
* @domain: pointer to a defined domain
return -1;
}
+
/**
* virConnectListDefinedDomains:
* @conn: pointer to the hypervisor connection
*/
int
virConnectListDefinedDomains(virConnectPtr conn, char **const names,
- int maxnames) {
+ int maxnames)
+{
VIR_DEBUG("conn=%p, names=%p, maxnames=%d", conn, names, maxnames);
virResetLastError();
return -1;
}
+
/**
* virConnectListAllDomains:
* @conn: Pointer to the hypervisor connection.
return -1;
}
+
/**
* virDomainCreate:
* @domain: pointer to a defined domain
* Returns 0 in case of success, -1 in case of error
*/
int
-virDomainCreate(virDomainPtr domain) {
+virDomainCreate(virDomainPtr domain)
+{
virConnectPtr conn;
VIR_DOMAIN_DEBUG(domain);
return -1;
}
+
/**
* virDomainCreateWithFlags:
* @domain: pointer to a defined domain
* Returns 0 in case of success, -1 in case of error
*/
int
-virDomainCreateWithFlags(virDomainPtr domain, unsigned int flags) {
+virDomainCreateWithFlags(virDomainPtr domain, unsigned int flags)
+{
virConnectPtr conn;
VIR_DOMAIN_DEBUG(domain, "flags=%x", flags);
return -1;
}
+
/**
* virDomainCreateWithFiles:
* @domain: pointer to a defined domain
return -1;
}
+
/**
* virDomainGetAutostart:
* @domain: a domain object
return -1;
}
+
/**
* virDomainSetAutostart:
* @domain: a domain object
return -1;
}
+
/**
* virDomainInjectNMI:
* @domain: pointer to domain object, or NULL for Domain0
*
* Returns 0 in case of success, -1 in case of failure.
*/
-
-int virDomainInjectNMI(virDomainPtr domain, unsigned int flags)
+int
+virDomainInjectNMI(virDomainPtr domain, unsigned int flags)
{
virConnectPtr conn;
VIR_DOMAIN_DEBUG(domain, "flags=%x", flags);
return -1;
}
+
/**
* virDomainSendKey:
* @domain: pointer to domain object, or NULL for Domain0
*
* Returns 0 in case of success, -1 in case of failure.
*/
-
-int virDomainSendKey(virDomainPtr domain,
- unsigned int codeset,
- unsigned int holdtime,
- unsigned int *keycodes,
- int nkeycodes,
- unsigned int flags)
+int
+virDomainSendKey(virDomainPtr domain,
+ unsigned int codeset,
+ unsigned int holdtime,
+ unsigned int *keycodes,
+ int nkeycodes,
+ unsigned int flags)
{
virConnectPtr conn;
VIR_DOMAIN_DEBUG(domain, "codeset=%u, holdtime=%u, nkeycodes=%u, flags=%x",
*
* Returns 0 in case of success, -1 in case of failure.
*/
-int virDomainSendProcessSignal(virDomainPtr domain,
- long long pid_value,
- unsigned int signum,
- unsigned int flags)
+int
+virDomainSendProcessSignal(virDomainPtr domain,
+ long long pid_value,
+ unsigned int signum,
+ unsigned int flags)
{
virConnectPtr conn;
VIR_DOMAIN_DEBUG(domain, "pid=%lld, signum=%u flags=%x",
*
* Returns 0 in case of success, -1 in case of failure.
*/
-
int
virDomainSetVcpus(virDomainPtr domain, unsigned int nvcpus)
{
return -1;
}
+
/**
* virDomainSetVcpusFlags:
* @domain: pointer to domain object, or NULL for Domain0
*
* Returns 0 in case of success, -1 in case of failure.
*/
-
int
virDomainSetVcpusFlags(virDomainPtr domain, unsigned int nvcpus,
unsigned int flags)
return -1;
}
+
/**
* virDomainGetVcpusFlags:
* @domain: pointer to domain object, or NULL for Domain0
*
* Returns the number of vCPUs in case of success, -1 in case of failure.
*/
-
int
virDomainGetVcpusFlags(virDomainPtr domain, unsigned int flags)
{
return -1;
}
+
/**
* virDomainPinVcpu:
* @domain: pointer to domain object, or NULL for Domain0
return -1;
}
+
/**
* virDomainPinVcpuFlags:
* @domain: pointer to domain object, or NULL for Domain0
error:
virDispatchError(domain->conn);
return -1;
-
}
+
/**
* virDomainGetVcpuPinInfo:
* @domain: pointer to domain object, or NULL for Domain0
return -1;
}
+
/**
* virDomainPinEmulator:
* @domain: pointer to domain object, or NULL for Domain0
return -1;
}
+
/**
* virDomainGetEmulatorPinInfo:
* @domain: pointer to domain object, or NULL for Domain0
return -1;
}
+
/**
* virDomainGetVcpus:
* @domain: pointer to domain object, or NULL for Domain0
return -1;
}
+
/**
* virDomainGetMaxVcpus:
* @domain: pointer to domain object
return -1;
}
+
/**
* virDomainGetSecurityLabel:
* @domain: a domain object
return -1;
}
+
/**
* virDomainGetSecurityLabelList:
* @domain: a domain object
return -1;
}
+
/**
* virDomainGetMetadata:
* @domain: a domain object
return NULL;
}
+
/**
* virNodeGetSecurityModel:
* @conn: a connection object
return -1;
}
+
/**
* virDomainAttachDevice:
* @domain: pointer to domain object
return -1;
}
+
/**
* virDomainAttachDeviceFlags:
* @domain: pointer to domain object
return -1;
}
+
/**
* virDomainDetachDevice:
* @domain: pointer to domain object
return -1;
}
+
/**
* virDomainDetachDeviceFlags:
* @domain: pointer to domain object
return -1;
}
+
/**
* virDomainUpdateDeviceFlags:
* @domain: pointer to domain object
return -1;
}
+
/**
* virNodeGetCellsFreeMemory:
* @conn: pointer to the hypervisor connection
*
* 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)
return -1;
}
+
/**
* virNetworkGetConnect:
* @net: pointer to a network
return net->conn;
}
+
/**
* virConnectListAllNetworks:
* @conn: Pointer to the hypervisor connection.
return -1;
}
+
/**
* virConnectListNetworks:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virConnectNumOfDefinedNetworks:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virConnectListDefinedNetworks:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virNetworkLookupByName:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virNetworkLookupByUUID:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virNetworkLookupByUUIDString:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virNetworkCreateXML:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virNetworkDefineXML:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virNetworkUndefine:
* @network: pointer to a defined network
* Returns 0 in case of success, -1 in case of error
*/
int
-virNetworkUndefine(virNetworkPtr network) {
+virNetworkUndefine(virNetworkPtr network)
+{
virConnectPtr conn;
VIR_DEBUG("network=%p", network);
return -1;
}
+
/**
* virNetworkUpdate:
* @network: pointer to a defined network
return -1;
}
+
/**
* virNetworkCreate:
* @network: pointer to a defined network
return -1;
}
+
/**
* virNetworkDestroy:
* @network: a network object
return -1;
}
+
/**
* virNetworkFree:
* @network: a network object
return 0;
}
+
/**
* virNetworkRef:
* @network: the network to hold a reference on
return 0;
}
+
/**
* virNetworkGetName:
* @network: a network object
return network->name;
}
+
/**
* virNetworkGetUUID:
* @network: a network object
return -1;
}
+
/**
* virNetworkGetUUIDString:
* @network: a network object
return -1;
}
+
/**
* virNetworkGetXMLDesc:
* @network: a network object
return NULL;
}
+
/**
* virNetworkGetBridgeName:
* @network: a network object
return NULL;
}
+
/**
* virNetworkGetAutostart:
* @network: a network object
return -1;
}
+
/**
* virNetworkSetAutostart:
* @network: a network object
return -1;
}
+
/**
* virInterfaceGetConnect:
* @iface: pointer to an interface
return iface->conn;
}
+
/**
* virConnectListAllInterfaces:
* @conn: Pointer to the hypervisor connection.
return -1;
}
+
/**
* virConnectNumOfInterfaces:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virConnectListInterfaces:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virConnectNumOfDefinedInterfaces:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virConnectListDefinedInterfaces:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virInterfaceLookupByName:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virInterfaceLookupByMACString:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virInterfaceGetName:
* @iface: an interface object
return iface->name;
}
+
/**
* virInterfaceGetMACString:
* @iface: an interface object
return iface->mac;
}
+
/**
* virInterfaceGetXMLDesc:
* @iface: an interface object
return NULL;
}
+
/**
* virInterfaceDefineXML:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virInterfaceUndefine:
* @iface: pointer to a defined interface
* Returns 0 in case of success, -1 in case of error
*/
int
-virInterfaceUndefine(virInterfacePtr iface) {
+virInterfaceUndefine(virInterfacePtr iface)
+{
virConnectPtr conn;
VIR_DEBUG("iface=%p", iface);
return -1;
}
+
/**
* virInterfaceCreate:
* @iface: pointer to a defined interface
return -1;
}
+
/**
* virInterfaceDestroy:
* @iface: an interface object
return -1;
}
+
/**
* virInterfaceRef:
* @iface: the interface to hold a reference on
return 0;
}
+
/**
* virInterfaceFree:
* @iface: an interface object
return 0;
}
+
/**
* virInterfaceChangeBegin:
* @conn: pointer to hypervisor connection
return -1;
}
+
/**
* virInterfaceChangeCommit:
* @conn: pointer to hypervisor connection
return -1;
}
+
/**
* virInterfaceChangeRollback:
* @conn: pointer to hypervisor connection
return pool->conn;
}
+
/**
* virConnectListAllStoragePools:
* @conn: Pointer to the hypervisor connection.
return -1;
}
+
/**
* virConnectNumOfStoragePools:
* @conn: pointer to hypervisor connection
return -1;
}
+
/**
* virConnectListStoragePools:
* @conn: pointer to hypervisor connection
return NULL;
}
+
/**
* virStoragePoolCreateXML:
* @conn: pointer to hypervisor connection
return NULL;
}
+
/**
* virStoragePoolDefineXML:
* @conn: pointer to hypervisor connection
return NULL;
}
+
/**
* virStoragePoolBuild:
* @pool: pointer to storage pool
return -1;
}
+
/**
* virStoragePoolDelete:
* @pool: pointer to storage pool
return 0;
}
+
/**
* virStoragePoolRefresh:
* @pool: pointer to storage pool
return -1;
}
+
/**
* virStoragePoolGetUUIDString:
* @pool: pointer to storage pool
return -1;
}
+
/**
* virStoragePoolListAllVolumes:
* @pool: Pointer to storage pool
return -1;
}
+
/**
* virStoragePoolNumOfVolumes:
* @pool: pointer to storage pool
}
-
/**
* virStorageVolLookupByKey:
* @conn: pointer to hypervisor connection
return NULL;
}
+
/**
* virStorageVolLookupByPath:
* @conn: pointer to hypervisor connection
return -1;
}
+
/**
* virStorageVolFree:
* @vol: pointer to storage volume
return 0;
}
+
/**
* virStorageVolGetInfo:
* @vol: pointer to storage volume
return NULL;
}
+
/**
* virStorageVolResize:
* @vol: pointer to storage volume
return -1;
}
+
/**
* virNodeNumOfDevices:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virConnectListAllNodeDevices:
* @conn: Pointer to the hypervisor connection.
return -1;
}
+
/**
* virNodeListDevices:
* @conn: pointer to the hypervisor connection
*
* Returns a virNodeDevicePtr if found, NULL otherwise.
*/
-virNodeDevicePtr virNodeDeviceLookupByName(virConnectPtr conn, const char *name)
+virNodeDevicePtr
+virNodeDeviceLookupByName(virConnectPtr conn, const char *name)
{
VIR_DEBUG("conn=%p, name=%p", conn, name);
return NULL;
}
+
/**
* virNodeDeviceLookupSCSIHostByWWN:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virNodeDeviceGetXMLDesc:
* @dev: pointer to the node device
*
* Returns the XML document, or NULL on error
*/
-char *virNodeDeviceGetXMLDesc(virNodeDevicePtr dev, unsigned int flags)
+char *
+virNodeDeviceGetXMLDesc(virNodeDevicePtr dev, unsigned int flags)
{
VIR_DEBUG("dev=%p, conn=%p, flags=%x", dev, dev ? dev->conn : NULL, flags);
*
* Returns the device name or NULL in case of error
*/
-const char *virNodeDeviceGetName(virNodeDevicePtr dev)
+const char *
+virNodeDeviceGetName(virNodeDevicePtr dev)
{
VIR_DEBUG("dev=%p, conn=%p", dev, dev ? dev->conn : NULL);
return dev->name;
}
+
/**
* virNodeDeviceGetParent:
* @dev: the device
* Returns the name of the device's parent, or NULL if the
* device has no parent.
*/
-const char *virNodeDeviceGetParent(virNodeDevicePtr dev)
+const char *
+virNodeDeviceGetParent(virNodeDevicePtr dev)
{
VIR_DEBUG("dev=%p, conn=%p", dev, dev ? dev->conn : NULL);
return dev->parent;
}
+
/**
* virNodeDeviceNumOfCaps:
* @dev: the device
*
* Returns the number of capabilities supported by the device.
*/
-int virNodeDeviceNumOfCaps(virNodeDevicePtr dev)
+int
+virNodeDeviceNumOfCaps(virNodeDevicePtr dev)
{
VIR_DEBUG("dev=%p, conn=%p", dev, dev ? dev->conn : NULL);
return -1;
}
+
/**
* virNodeDeviceListCaps:
* @dev: the device
*
* Returns the number of capability names listed in @names.
*/
-int virNodeDeviceListCaps(virNodeDevicePtr dev,
- char **const names,
- int maxnames)
+int
+virNodeDeviceListCaps(virNodeDevicePtr dev,
+ char **const names,
+ int maxnames)
{
VIR_DEBUG("dev=%p, conn=%p, names=%p, maxnames=%d",
dev, dev ? dev->conn : NULL, names, maxnames);
*
* Returns the 0 for success, -1 for error.
*/
-int virNodeDeviceFree(virNodeDevicePtr dev)
+int
+virNodeDeviceFree(virNodeDevicePtr dev)
{
VIR_DEBUG("dev=%p, conn=%p", dev, dev ? dev->conn : NULL);
return 0;
}
+
/**
* virNodeDeviceDettach:
* @dev: pointer to the node device
return -1;
}
+
/**
* virNodeDeviceDetachFlags:
* @dev: pointer to the node device
return -1;
}
+
/**
* virNodeDeviceReAttach:
* @dev: pointer to the node device
return -1;
}
+
/**
* virNodeDeviceReset:
* @dev: pointer to the node device
}
virCheckNonNullArgGoto(cb, error);
- if ((conn->driver) && (conn->driver->connectDomainEventRegister)) {
+ if (conn->driver && conn->driver->connectDomainEventRegister) {
int ret;
ret = conn->driver->connectDomainEventRegister(conn, cb, opaque, freecb);
if (ret < 0)
return -1;
}
+
/**
* virConnectDomainEventDeregister:
* @conn: pointer to the connection
}
virCheckNonNullArgGoto(cb, error);
- if ((conn->driver) && (conn->driver->connectDomainEventDeregister)) {
+ if (conn->driver && conn->driver->connectDomainEventDeregister) {
int ret;
ret = conn->driver->connectDomainEventDeregister(conn, cb);
if (ret < 0)
return -1;
}
+
/**
* virSecretGetConnect:
* @secret: A virSecret secret
return secret->conn;
}
+
/**
* virConnectNumOfSecrets:
* @conn: virConnect connection
return -1;
}
+
/**
* virConnectListAllSecrets:
* @conn: Pointer to the hypervisor connection.
return -1;
}
+
/**
* virConnectListSecrets:
* @conn: virConnect connection
return -1;
}
+
/**
* virSecretLookupByUUID:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virSecretLookupByUUIDString:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virSecretGetUUID:
* @secret: A virSecret secret
return -1;
}
+
/**
* virSecretGetUUIDString:
* @secret: a secret object
return -1;
}
+
/**
* virSecretGetUsageType:
* @secret: a secret object
return secret->usageType;
}
+
/**
* virSecretGetUsageID:
* @secret: a secret object
return NULL;
}
+
/**
* virSecretSetValue:
* @secret: A virSecret secret
return -1;
}
+
/**
* virSecretGetValue:
* @secret: A virSecret connection
return NULL;
}
+
/**
* virSecretUndefine:
* @secret: A virSecret secret
return -1;
}
+
/**
* virSecretRef:
* @secret: the secret to hold a reference on
return 0;
}
+
/**
* virSecretFree:
* @secret: pointer to a secret
* Returns -2 if the outgoing transmit buffers are full &
* the stream is marked as non-blocking.
*/
-int virStreamSend(virStreamPtr stream,
- const char *data,
- size_t nbytes)
+int
+virStreamSend(virStreamPtr stream,
+ const char *data,
+ size_t nbytes)
{
VIR_DEBUG("stream=%p, data=%p, nbytes=%zi", stream, data, nbytes);
* Returns -2 if there is no data pending to be read & the
* stream is marked as non-blocking.
*/
-int virStreamRecv(virStreamPtr stream,
- char *data,
- size_t nbytes)
+int
+virStreamRecv(virStreamPtr stream,
+ char *data,
+ size_t nbytes)
{
VIR_DEBUG("stream=%p, data=%p, nbytes=%zi", stream, data, nbytes);
* having been called, so the caller need only call
* virStreamFree()
*/
-int virStreamSendAll(virStreamPtr stream,
- virStreamSourceFunc handler,
- void *opaque)
+int
+virStreamSendAll(virStreamPtr stream,
+ virStreamSourceFunc handler,
+ void *opaque)
{
char *bytes = NULL;
int want = 1024*64;
* having been called, so the caller need only call
* virStreamFree()
*/
-int virStreamRecvAll(virStreamPtr stream,
- virStreamSinkFunc handler,
- void *opaque)
+int
+virStreamRecvAll(virStreamPtr stream,
+ virStreamSinkFunc handler,
+ void *opaque)
{
char *bytes = NULL;
int want = 1024*64;
*
* Returns 0 on success, -1 upon error
*/
-int virStreamEventAddCallback(virStreamPtr stream,
- int events,
- virStreamEventCallback cb,
- void *opaque,
- virFreeCallback ff)
+int
+virStreamEventAddCallback(virStreamPtr stream,
+ int events,
+ virStreamEventCallback cb,
+ void *opaque,
+ virFreeCallback ff)
{
VIR_DEBUG("stream=%p, events=%d, cb=%p, opaque=%p, ff=%p", stream, events, cb, opaque, ff);
*
* Returns 0 on success, -1 if no callback is registered
*/
-int virStreamEventUpdateCallback(virStreamPtr stream,
- int events)
+int
+virStreamEventUpdateCallback(virStreamPtr stream,
+ int events)
{
VIR_DEBUG("stream=%p, events=%d", stream, events);
return -1;
}
+
/**
* virStreamEventRemoveCallback:
* @stream: pointer to the stream object
*
* Returns 0 on success, -1 on error
*/
-int virStreamEventRemoveCallback(virStreamPtr stream)
+int
+virStreamEventRemoveCallback(virStreamPtr stream)
{
VIR_DEBUG("stream=%p", stream);
return -1;
}
+
/**
* virStreamFinish:
* @stream: pointer to the stream object
*
* Returns 0 on success, -1 upon error
*/
-int virStreamFinish(virStreamPtr stream)
+int
+virStreamFinish(virStreamPtr stream)
{
VIR_DEBUG("stream=%p", stream);
return -1;
}
+
/**
* virStreamAbort:
* @stream: pointer to the stream object
*
* Returns 0 on success, -1 upon error
*/
-int virStreamAbort(virStreamPtr stream)
+int
+virStreamAbort(virStreamPtr stream)
{
VIR_DEBUG("stream=%p", stream);
return -1;
}
+
/**
* virStreamFree:
* @stream: pointer to the stream object
*
* Returns 0 upon success, or -1 on error
*/
-int virStreamFree(virStreamPtr stream)
+int
+virStreamFree(virStreamPtr stream)
{
VIR_DEBUG("stream=%p", stream);
*
* Returns 1 if running, 0 if inactive, -1 on error
*/
-int virDomainIsActive(virDomainPtr dom)
+int
+virDomainIsActive(virDomainPtr dom)
{
VIR_DEBUG("dom=%p", dom);
return -1;
}
+
/**
* virDomainIsPersistent:
* @dom: pointer to the domain object
*
* Returns 1 if persistent, 0 if transient, -1 on error
*/
-int virDomainIsPersistent(virDomainPtr dom)
+int
+virDomainIsPersistent(virDomainPtr dom)
{
VIR_DOMAIN_DEBUG(dom);
return -1;
}
+
/**
* virDomainIsUpdated:
* @dom: pointer to the domain object
*
* Returns 1 if updated, 0 if not, -1 on error
*/
-int virDomainIsUpdated(virDomainPtr dom)
+int
+virDomainIsUpdated(virDomainPtr dom)
{
VIR_DOMAIN_DEBUG(dom);
return -1;
}
+
/**
* virNetworkIsActive:
* @net: pointer to the network object
*
* Returns 1 if running, 0 if inactive, -1 on error
*/
-int virNetworkIsActive(virNetworkPtr net)
+int
+virNetworkIsActive(virNetworkPtr net)
{
VIR_DEBUG("net=%p", net);
*
* Returns 1 if persistent, 0 if transient, -1 on error
*/
-int virNetworkIsPersistent(virNetworkPtr net)
+int
+virNetworkIsPersistent(virNetworkPtr net)
{
VIR_DEBUG("net=%p", net);
*
* Returns 1 if running, 0 if inactive, -1 on error
*/
-int virStoragePoolIsActive(virStoragePoolPtr pool)
+int
+virStoragePoolIsActive(virStoragePoolPtr pool)
{
VIR_DEBUG("pool=%p", pool);
*
* Returns 1 if persistent, 0 if transient, -1 on error
*/
-int virStoragePoolIsPersistent(virStoragePoolPtr pool)
+int
+virStoragePoolIsPersistent(virStoragePoolPtr pool)
{
VIR_DEBUG("pool=%p", pool);
}
-
/**
* virConnectNumOfNWFilters:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virConnectListAllNWFilters:
* @conn: Pointer to the hypervisor connection.
return -1;
}
+
/**
* virConnectListNWFilters:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virNWFilterLookupByUUID:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virNWFilterLookupByUUIDString:
* @conn: pointer to the hypervisor connection
return NULL;
}
+
/**
* virNWFilterFree:
* @nwfilter: a nwfilter object
return 0;
}
+
/**
* virNWFilterGetName:
* @nwfilter: a nwfilter object
return nwfilter->name;
}
+
/**
* virNWFilterGetUUID:
* @nwfilter: a nwfilter object
return -1;
}
+
/**
* virNWFilterGetUUIDString:
* @nwfilter: a nwfilter object
*
* Returns 1 if running, 0 if inactive, -1 on error
*/
-int virInterfaceIsActive(virInterfacePtr iface)
+int
+virInterfaceIsActive(virInterfacePtr iface)
{
VIR_DEBUG("iface=%p", iface);
*
* Returns 1 if encrypted, 0 if not encrypted, -1 on error
*/
-int virConnectIsEncrypted(virConnectPtr conn)
+int
+virConnectIsEncrypted(virConnectPtr conn)
{
VIR_DEBUG("conn=%p", conn);
return -1;
}
+
/**
* virConnectIsSecure:
* @conn: pointer to the connection object
*
* Returns 1 if secure, 0 if not secure, -1 on error
*/
-int virConnectIsSecure(virConnectPtr conn)
+int
+virConnectIsSecure(virConnectPtr conn)
{
VIR_DEBUG("conn=%p", conn);
return -1;
}
+
/**
* virDomainMigrateGetCompressionCache:
* @domain: a domain object
return -1;
}
+
/**
* virDomainMigrateSetCompressionCache:
* @domain: a domain object
return -1;
}
+
/**
* virDomainMigrateSetMaxSpeed:
* @domain: a domain object
return -1;
}
+
/**
* virDomainMigrateGetMaxSpeed:
* @domain: a domain object
return -1;
}
+
/**
* virConnectDomainEventRegisterAny:
* @conn: pointer to the connection
goto error;
}
- if ((conn->driver) && (conn->driver->connectDomainEventRegisterAny)) {
+ if (conn->driver && conn->driver->connectDomainEventRegisterAny) {
int ret;
ret = conn->driver->connectDomainEventRegisterAny(conn, dom, eventID, cb, opaque, freecb);
if (ret < 0)
return -1;
}
+
/**
* virConnectDomainEventDeregisterAny:
* @conn: pointer to the connection
}
virCheckNonNegativeArgGoto(callbackID, error);
- if ((conn->driver) && (conn->driver->connectDomainEventDeregisterAny)) {
+ if (conn->driver && conn->driver->connectDomainEventDeregisterAny) {
int ret;
ret = conn->driver->connectDomainEventDeregisterAny(conn, callbackID);
if (ret < 0)
return -1;
}
+
/**
* virConnectNetworkEventRegisterAny:
* @conn: pointer to the connection
goto error;
}
- if ((conn->networkDriver) && (conn->networkDriver->connectNetworkEventRegisterAny)) {
+ if (conn->networkDriver && conn->networkDriver->connectNetworkEventRegisterAny) {
int ret;
ret = conn->networkDriver->connectNetworkEventRegisterAny(conn, net,
eventID,
return -1;
}
+
/**
* virConnectNetworkEventDeregisterAny:
* @conn: pointer to the connection
}
virCheckNonNegativeArgGoto(callbackID, error);
- if ((conn->networkDriver) &&
- (conn->networkDriver->connectNetworkEventDeregisterAny)) {
+ if (conn->networkDriver &&
+ conn->networkDriver->connectNetworkEventDeregisterAny) {
int ret;
ret = conn->networkDriver->connectNetworkEventDeregisterAny(conn,
callbackID);
return -1;
}
+
/**
* virDomainManagedSave:
* @dom: pointer to the domain
*
* Returns 0 in case of success or -1 in case of failure
*/
-int virDomainManagedSave(virDomainPtr dom, unsigned int flags)
+int
+virDomainManagedSave(virDomainPtr dom, unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainHasManagedSaveImage:
* @dom: pointer to the domain
* Returns 0 if no image is present, 1 if an image is present, and
* -1 in case of error
*/
-int virDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
+int
+virDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainManagedSaveRemove:
* @dom: pointer to the domain
*
* Returns 0 in case of success, and -1 in case of error
*/
-int virDomainManagedSaveRemove(virDomainPtr dom, unsigned int flags)
+int
+virDomainManagedSaveRemove(virDomainPtr dom, unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainSnapshotGetName:
* @snapshot: a snapshot object
return snapshot->name;
}
+
/**
* virDomainSnapshotGetDomain:
* @snapshot: a snapshot object
return snapshot->domain;
}
+
/**
* virDomainSnapshotGetConnect:
* @snapshot: a snapshot object
return snapshot->domain->conn;
}
+
/**
* virDomainSnapshotCreateXML:
* @domain: a domain object
return NULL;
}
+
/**
* virDomainSnapshotGetXMLDesc:
* @snapshot: a domain snapshot object
return NULL;
}
+
/**
* virDomainSnapshotNum:
* @domain: a domain object
return -1;
}
+
/**
* virDomainSnapshotListNames:
* @domain: a domain object
return -1;
}
+
/**
* virDomainListAllSnapshots:
* @domain: a domain object
return -1;
}
+
/**
* virDomainSnapshotNumChildren:
* @snapshot: a domain snapshot object
return -1;
}
+
/**
* virDomainSnapshotListChildrenNames:
* @snapshot: a domain snapshot object
return -1;
}
+
/**
* virDomainSnapshotListAllChildren:
* @snapshot: a domain snapshot object
return -1;
}
+
/**
* virDomainSnapshotLookupByName:
* @domain: a domain object
return NULL;
}
+
/**
* virDomainHasCurrentSnapshot:
* @domain: pointer to the domain object
return -1;
}
+
/**
* virDomainSnapshotCurrent:
* @domain: a domain object
return NULL;
}
+
/**
* virDomainSnapshotGetParent:
* @snapshot: a snapshot object
return NULL;
}
+
/**
* virDomainSnapshotIsCurrent:
* @snapshot: a snapshot object
*
* Returns 1 if current, 0 if not current, or -1 on error.
*/
-int virDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot,
- unsigned int flags)
+int
+virDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot,
+ unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainSnapshotHasMetadata:
* @snapshot: a snapshot object
* Returns 1 if the snapshot has metadata, 0 if the snapshot exists without
* help from libvirt, or -1 on error.
*/
-int virDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot,
- unsigned int flags)
+int
+virDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot,
+ unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainRevertToSnapshot:
* @snapshot: a domain snapshot object
return -1;
}
+
/**
* virDomainSnapshotDelete:
* @snapshot: a domain snapshot object
return -1;
}
+
/**
* virDomainSnapshotRef:
* @snapshot: the snapshot to hold a reference on
return 0;
}
+
/**
* virDomainSnapshotFree:
* @snapshot: a domain snapshot object
return 0;
}
+
/**
* virDomainOpenConsole:
* @dom: a domain object
*
* Returns 0 if the console was opened, -1 on error
*/
-int virDomainOpenConsole(virDomainPtr dom,
- const char *dev_name,
- virStreamPtr st,
- unsigned int flags)
+int
+virDomainOpenConsole(virDomainPtr dom,
+ const char *dev_name,
+ virStreamPtr st,
+ unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainOpenChannel:
* @dom: a domain object
*
* Returns 0 if the channel was opened, -1 on error
*/
-int virDomainOpenChannel(virDomainPtr dom,
- const char *name,
- virStreamPtr st,
- unsigned int flags)
+int
+virDomainOpenChannel(virDomainPtr dom,
+ const char *name,
+ virStreamPtr st,
+ unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainBlockJobAbort:
* @dom: pointer to domain object
*
* Returns -1 in case of failure, 0 when successful.
*/
-int virDomainBlockJobAbort(virDomainPtr dom, const char *disk,
- unsigned int flags)
+int
+virDomainBlockJobAbort(virDomainPtr dom, const char *disk,
+ unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainGetBlockJobInfo:
* @dom: pointer to domain object
*
* Returns -1 in case of failure, 0 when nothing found, 1 when info was found.
*/
-int virDomainGetBlockJobInfo(virDomainPtr dom, const char *disk,
- virDomainBlockJobInfoPtr info, unsigned int flags)
+int
+virDomainGetBlockJobInfo(virDomainPtr dom, const char *disk,
+ virDomainBlockJobInfoPtr info, unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainBlockJobSetSpeed:
* @dom: pointer to domain object
*
* Returns -1 in case of failure, 0 when successful.
*/
-int virDomainBlockJobSetSpeed(virDomainPtr dom, const char *disk,
- unsigned long bandwidth, unsigned int flags)
+int
+virDomainBlockJobSetSpeed(virDomainPtr dom, const char *disk,
+ unsigned long bandwidth, unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainBlockPull:
* @dom: pointer to domain object
*
* Returns 0 if the operation has started, -1 on failure.
*/
-int virDomainBlockPull(virDomainPtr dom, const char *disk,
- unsigned long bandwidth, unsigned int flags)
+int
+virDomainBlockPull(virDomainPtr dom, const char *disk,
+ unsigned long bandwidth, unsigned int flags)
{
virConnectPtr conn;
*
* Returns 0 if the operation has started, -1 on failure.
*/
-int virDomainBlockRebase(virDomainPtr dom, const char *disk,
- const char *base, unsigned long bandwidth,
- unsigned int flags)
+int
+virDomainBlockRebase(virDomainPtr dom, const char *disk,
+ const char *base, unsigned long bandwidth,
+ unsigned int flags)
{
virConnectPtr conn;
*
* Returns 0 if the operation has started, -1 on failure.
*/
-int virDomainBlockCommit(virDomainPtr dom, const char *disk,
- const char *base, const char *top,
- unsigned long bandwidth, unsigned int flags)
+int
+virDomainBlockCommit(virDomainPtr dom, const char *disk,
+ const char *base, const char *top,
+ unsigned long bandwidth, unsigned int flags)
{
virConnectPtr conn;
*
* Returns 0 on success, -1 on failure
*/
-int virDomainOpenGraphics(virDomainPtr dom,
- unsigned int idx,
- int fd,
- unsigned int flags)
+int
+virDomainOpenGraphics(virDomainPtr dom,
+ unsigned int idx,
+ int fd,
+ unsigned int flags)
{
struct stat sb;
VIR_DOMAIN_DEBUG(dom, "idx=%u, fd=%d, flags=%x",
* 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
+virConnectSetKeepAlive(virConnectPtr conn,
+ int interval,
+ unsigned int count)
{
int ret = -1;
return -1;
}
+
/**
* virConnectIsAlive:
* @conn: pointer to the connection object
*
* Returns 1 if alive, 0 if dead, -1 on error
*/
-int virConnectIsAlive(virConnectPtr conn)
+int
+virConnectIsAlive(virConnectPtr conn)
{
VIR_DEBUG("conn=%p", conn);
*
* Returns 0 on success, -1 on error
*/
-int virConnectRegisterCloseCallback(virConnectPtr conn,
- virConnectCloseFunc cb,
- void *opaque,
- virFreeCallback freecb)
+int
+virConnectRegisterCloseCallback(virConnectPtr conn,
+ virConnectCloseFunc cb,
+ void *opaque,
+ virFreeCallback freecb)
{
VIR_DEBUG("conn=%p", conn);
return -1;
}
+
/**
* virConnectUnregisterCloseCallback:
* @conn: pointer to connection object
*
* Returns 0 on success, -1 on error
*/
-int virConnectUnregisterCloseCallback(virConnectPtr conn,
- virConnectCloseFunc cb)
+int
+virConnectUnregisterCloseCallback(virConnectPtr conn,
+ virConnectCloseFunc cb)
{
VIR_DEBUG("conn=%p", conn);
return -1;
}
+
/**
* virDomainSetBlockIoTune:
* @dom: pointer to domain object
*
* Returns -1 in case of error, 0 in case of success.
*/
-int virDomainSetBlockIoTune(virDomainPtr dom,
- const char *disk,
- virTypedParameterPtr params,
- int nparams,
- unsigned int flags)
+int
+virDomainSetBlockIoTune(virDomainPtr dom,
+ const char *disk,
+ virTypedParameterPtr params,
+ int nparams,
+ unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainGetBlockIoTune:
* @dom: pointer to domain object
*
* Returns -1 in case of error, 0 in case of success.
*/
-int virDomainGetBlockIoTune(virDomainPtr dom,
- const char *disk,
- virTypedParameterPtr params,
- int *nparams,
- unsigned int flags)
+int
+virDomainGetBlockIoTune(virDomainPtr dom,
+ const char *disk,
+ virTypedParameterPtr params,
+ int *nparams,
+ unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainGetCPUStats:
* @domain: domain to query
* @ncpus is too large). The caller is responsible for freeing any
* returned string parameters.
*/
-int virDomainGetCPUStats(virDomainPtr domain,
- virTypedParameterPtr params,
- unsigned int nparams,
- int start_cpu,
- unsigned int ncpus,
- unsigned int flags)
+int
+virDomainGetCPUStats(virDomainPtr domain,
+ virTypedParameterPtr params,
+ unsigned int nparams,
+ int start_cpu,
+ unsigned int ncpus,
+ unsigned int flags)
{
virConnectPtr conn;
return -1;
}
+
/**
* virDomainGetDiskErrors:
* @dom: a domain object
return -1;
}
+
/**
* virDomainGetHostname:
* @domain: a domain object
return NULL;
}
+
/**
* virNodeGetCPUMap:
* @conn: pointer to the hypervisor connection
return -1;
}
+
/**
* virDomainFSTrim:
* @dom: a domain object
projects / libvirt.git / commitdiff