typedef virDrvOpenStatus
(*virDrvOpen) (virConnectPtr conn,
virConnectAuthPtr auth,
- int flags);
+ unsigned int flags);
typedef int
(*virDrvClose) (virConnectPtr conn);
typedef int
typedef int
(*virDrvDomainCoreDump) (virDomainPtr domain,
const char *to,
- int flags);
+ unsigned int flags);
typedef char *
(*virDrvDomainScreenshot) (virDomainPtr domain,
virStreamPtr stream,
unsigned int flags);
typedef char *
(*virDrvDomainGetXMLDesc) (virDomainPtr dom,
- int flags);
+ unsigned int flags);
typedef char *
(*virDrvConnectDomainXMLFromNative) (virConnectPtr conn,
const char *nativeFormat,
(*virDrvNetworkDestroy) (virNetworkPtr network);
typedef char *
(*virDrvNetworkGetXMLDesc) (virNetworkPtr network,
- int flags);
+ unsigned int flags);
typedef char *
(*virDrvNetworkGetBridgeName) (virNetworkPtr network);
typedef int
typedef char *
(*virDrvNWFilterGetXMLDesc) (virNWFilterPtr nwfilter,
- int flags);
+ unsigned int flags);
typedef struct _virNWFilterDriver virNWFilterDriver;
* esx_device_monitor.c: device monitor functions for managing VMware ESX
* host devices
*
- * Copyright (C) 2010 Red Hat, Inc.
+ * Copyright (C) 2010-2011 Red Hat, Inc.
* Copyright (C) 2010 Matthias Bolte <matthias.bolte@googlemail.com>
*
* This library is free software; you can redistribute it and/or
static virDrvOpenStatus
esxDeviceOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if (conn->driver->no != VIR_DRV_ESX) {
return VIR_DRV_OPEN_DECLINED;
* socks5. The optional <port> part allows to override the default port 1080.
*/
static virDrvOpenStatus
-esxOpen(virConnectPtr conn, virConnectAuthPtr auth, int flags ATTRIBUTE_UNUSED)
+esxOpen(virConnectPtr conn, virConnectAuthPtr auth,
+ unsigned int flags ATTRIBUTE_UNUSED)
{
virDrvOpenStatus result = VIR_DRV_OPEN_ERROR;
esxPrivate *priv = NULL;
static char *
-esxDomainGetXMLDesc(virDomainPtr domain, int flags)
+esxDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
{
esxPrivate *priv = domain->conn->privateData;
esxVI_String *propertyNameList = NULL;
* esx_interface_driver.c: interface driver functions for managing VMware ESX
* host interfaces
*
- * Copyright (C) 2010 Red Hat, Inc.
+ * Copyright (C) 2010-2011 Red Hat, Inc.
* Copyright (C) 2010 Matthias Bolte <matthias.bolte@googlemail.com>
*
* This library is free software; you can redistribute it and/or
static virDrvOpenStatus
esxInterfaceOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if (conn->driver->no != VIR_DRV_ESX) {
return VIR_DRV_OPEN_DECLINED;
* esx_network_driver.c: network driver functions for managing VMware ESX
* host networks
*
- * Copyright (C) 2010 Red Hat, Inc.
+ * Copyright (C) 2010-2011 Red Hat, Inc.
* Copyright (C) 2010 Matthias Bolte <matthias.bolte@googlemail.com>
*
* This library is free software; you can redistribute it and/or
static virDrvOpenStatus
esxNetworkOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if (conn->driver->no != VIR_DRV_ESX) {
return VIR_DRV_OPEN_DECLINED;
* esx_nwfilter_driver.c: nwfilter driver functions for managing VMware ESX
* firewall rules
*
+ * Copyright (C) 2011 Red Hat, Inc.
* Copyright (C) 2010 Matthias Bolte <matthias.bolte@googlemail.com>
*
* This library is free software; you can redistribute it and/or
static virDrvOpenStatus
esxNWFilterOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if (conn->driver->no != VIR_DRV_ESX) {
return VIR_DRV_OPEN_DECLINED;
/*
* esx_secret_driver.c: secret driver functions for VMware ESX secret manipulation
*
- * Copyright (C) 2010 Red Hat, Inc.
+ * Copyright (C) 2010-2011 Red Hat, Inc.
* Copyright (C) 2010 Matthias Bolte <matthias.bolte@googlemail.com>
*
* This library is free software; you can redistribute it and/or
static virDrvOpenStatus
esxSecretOpen(virConnectPtr conn, virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if (conn->driver->no != VIR_DRV_ESX) {
return VIR_DRV_OPEN_DECLINED;
* esx_storage_driver.c: storage driver functions for managing VMware ESX
* host storage
*
- * Copyright (C) 2010 Red Hat, Inc.
+ * Copyright (C) 2010-2011 Red Hat, Inc.
* Copyright (C) 2010 Matthias Bolte <matthias.bolte@googlemail.com>
*
* This library is free software; you can redistribute it and/or
static virDrvOpenStatus
esxStorageOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if (conn->driver->no != VIR_DRV_ESX) {
return VIR_DRV_OPEN_DECLINED;
* interface_driver.c: backend driver methods to handle physical
* interface configuration using the netcf library.
*
- * Copyright (C) 2006-2010 Red Hat, Inc.
+ * Copyright (C) 2006-2011 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
static virDrvOpenStatus interfaceOpenInterface(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
struct interface_driver *driverState;
static virDrvOpenStatus
libxlOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if (conn->uri == NULL) {
if (libxl_driver == NULL)
}
static int
-libxlDomainCoreDump(virDomainPtr dom, const char *to, int flags)
+libxlDomainCoreDump(virDomainPtr dom, const char *to, unsigned int flags)
{
libxlDriverPrivatePtr driver = dom->conn->privateData;
libxlDomainObjPrivatePtr priv;
}
static char *
-libxlDomainGetXMLDesc(virDomainPtr dom, int flags)
+libxlDomainGetXMLDesc(virDomainPtr dom, unsigned int flags)
{
libxlDriverPrivatePtr driver = dom->conn->privateData;
virDomainObjPtr vm;
static virDrvOpenStatus lxcOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
/* Verify uri was specified */
if (conn->uri == NULL) {
}
static char *lxcDomainGetXMLDesc(virDomainPtr dom,
- int flags)
+ unsigned int flags)
{
lxc_driver_t *driver = dom->conn->privateData;
virDomainObjPtr vm;
static virDrvOpenStatus networkOpenNetwork(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
if (!driverState)
return VIR_DRV_OPEN_DECLINED;
return ret;
}
-static char *networkGetXMLDesc(virNetworkPtr net, int flags ATTRIBUTE_UNUSED) {
+static char *networkGetXMLDesc(virNetworkPtr net,
+ unsigned int flags ATTRIBUTE_UNUSED)
+{
struct network_driver *driver = net->conn->networkPrivateData;
virNetworkObjPtr network;
char *ret = NULL;
/*
* node_device_hal.c: node device enumeration - HAL-based implementation
*
+ * Copyright (C) 2011 Red Hat, Inc.
* Copyright (C) 2008 Virtual Iron Software, Inc.
* Copyright (C) 2008 David F. Lively
*
static virDrvOpenStatus halNodeDrvOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if (driverState == NULL)
return VIR_DRV_OPEN_DECLINED;
static virDrvOpenStatus udevNodeDrvOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if (driverState == NULL) {
return VIR_DRV_OPEN_DECLINED;
static virDrvOpenStatus
nwfilterOpen(virConnectPtr conn,
- virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ virConnectAuthPtr auth ATTRIBUTE_UNUSED,
+ unsigned int flags ATTRIBUTE_UNUSED)
+{
if (!driverState)
return VIR_DRV_OPEN_DECLINED;
static char *
nwfilterGetXMLDesc(virNWFilterPtr obj,
- int flags) {
+ unsigned int flags)
+{
virNWFilterDriverStatePtr driver = obj->conn->nwfilterPrivateData;
virNWFilterObjPtr nwfilter;
char *ret = NULL;
return 0;
}
-static char *openvzDomainGetXMLDesc(virDomainPtr dom, int flags) {
+static char *openvzDomainGetXMLDesc(virDomainPtr dom, unsigned int flags) {
struct openvz_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
char *ret = NULL;
static virDrvOpenStatus openvzOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
struct openvz_driver *driver;
static virDrvOpenStatus
phypOpen(virConnectPtr conn,
- virConnectAuthPtr auth, int flags ATTRIBUTE_UNUSED)
+ virConnectAuthPtr auth, unsigned int flags ATTRIBUTE_UNUSED)
{
LIBSSH2_SESSION *session = NULL;
ConnectionData *connection_data = NULL;
}
static char *
-phypDomainGetXMLDesc(virDomainPtr dom, int flags)
+phypDomainGetXMLDesc(virDomainPtr dom, unsigned int flags)
{
ConnectionData *connection_data = dom->conn->networkPrivateData;
phyp_driverPtr phyp_driver = dom->conn->privateData;
static virDrvOpenStatus
phypVIOSDriverOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if (conn->driver->no != VIR_DRV_PHYP)
return VIR_DRV_OPEN_DECLINED;
static virDrvOpenStatus qemudOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED)
+{
if (conn->uri == NULL) {
if (qemu_driver == NULL)
return VIR_DRV_OPEN_DECLINED;
static int qemudDomainCoreDump(virDomainPtr dom,
const char *path,
- int flags)
+ unsigned int flags)
{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
static char *qemuDomainGetXMLDesc(virDomainPtr dom,
- int flags) {
+ unsigned int flags)
+{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
char *ret = NULL;
doRemoteOpen (virConnectPtr conn,
struct private_data *priv,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags)
+ unsigned int flags)
{
struct qparam_set *vars = NULL;
char *transport_str = NULL;
static virDrvOpenStatus
remoteOpen (virConnectPtr conn,
virConnectAuthPtr auth,
- int flags)
+ unsigned int flags)
{
struct private_data *priv;
int ret, rflags = 0;
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
remoteGenericOpen(virConnectPtr conn, virConnectAuthPtr auth,
- int flags, void **genericPrivateData)
+ unsigned int flags, void **genericPrivateData)
{
if (inside_daemon)
return VIR_DRV_OPEN_DECLINED;
}
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
-remoteNetworkOpen(virConnectPtr conn, virConnectAuthPtr auth, int flags)
+remoteNetworkOpen(virConnectPtr conn, virConnectAuthPtr auth,
+ unsigned int flags)
{
return remoteGenericOpen(conn, auth, flags, &conn->networkPrivateData);
}
/*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
-remoteInterfaceOpen(virConnectPtr conn, virConnectAuthPtr auth, int flags)
+remoteInterfaceOpen(virConnectPtr conn, virConnectAuthPtr auth,
+ unsigned int flags)
{
return remoteGenericOpen(conn, auth, flags, &conn->interfacePrivateData);
}
/*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
-remoteStorageOpen(virConnectPtr conn, virConnectAuthPtr auth, int flags)
+remoteStorageOpen(virConnectPtr conn, virConnectAuthPtr auth,
+ unsigned int flags)
{
return remoteGenericOpen(conn, auth, flags, &conn->storagePrivateData);
}
/*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
-remoteDevMonOpen(virConnectPtr conn, virConnectAuthPtr auth, int flags)
+remoteDevMonOpen(virConnectPtr conn, virConnectAuthPtr auth,
+ unsigned int flags)
{
return remoteGenericOpen(conn, auth, flags, &conn->devMonPrivateData);
}
/* ------------------------------------------------------------- */
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
-remoteNWFilterOpen(virConnectPtr conn, virConnectAuthPtr auth, int flags)
+remoteNWFilterOpen(virConnectPtr conn, virConnectAuthPtr auth,
+ unsigned int flags)
{
return remoteGenericOpen(conn, auth, flags, &conn->nwfilterPrivateData);
}
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
-remoteSecretOpen(virConnectPtr conn, virConnectAuthPtr auth, int flags)
+remoteSecretOpen(virConnectPtr conn, virConnectAuthPtr auth,
+ unsigned int flags)
{
return remoteGenericOpen(conn, auth, flags, &conn->secretPrivateData);
}
* yet do that using the remote_internal driver.
*/
remote_string name;
- int flags;
+ unsigned int flags;
};
struct remote_supports_feature_args {
struct remote_domain_core_dump_args {
remote_nonnull_domain dom;
remote_nonnull_string to;
- int flags;
+ unsigned int flags;
};
struct remote_domain_screenshot_args {
struct remote_domain_get_xml_desc_args {
remote_nonnull_domain dom;
- int flags;
+ unsigned int flags;
};
struct remote_domain_get_xml_desc_ret {
struct remote_network_get_xml_desc_args {
remote_nonnull_network net;
- int flags;
+ unsigned int flags;
};
struct remote_network_get_xml_desc_ret {
struct remote_nwfilter_get_xml_desc_args {
remote_nonnull_nwfilter nwfilter;
- int flags;
+ unsigned int flags;
};
struct remote_nwfilter_get_xml_desc_ret {
};
struct remote_open_args {
remote_string name;
- int flags;
+ u_int flags;
};
struct remote_supports_feature_args {
int feature;
struct remote_domain_core_dump_args {
remote_nonnull_domain dom;
remote_nonnull_string to;
- int flags;
+ u_int flags;
};
struct remote_domain_screenshot_args {
remote_nonnull_domain dom;
};
struct remote_domain_get_xml_desc_args {
remote_nonnull_domain dom;
- int flags;
+ u_int flags;
};
struct remote_domain_get_xml_desc_ret {
remote_nonnull_string xml;
};
struct remote_network_get_xml_desc_args {
remote_nonnull_network net;
- int flags;
+ u_int flags;
};
struct remote_network_get_xml_desc_ret {
remote_nonnull_string xml;
};
struct remote_nwfilter_get_xml_desc_args {
remote_nonnull_nwfilter nwfilter;
- int flags;
+ u_int flags;
};
struct remote_nwfilter_get_xml_desc_ret {
remote_nonnull_string xml;
static virDrvOpenStatus
secretOpen(virConnectPtr conn, virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
if (driverState == NULL)
return VIR_DRV_OPEN_DECLINED;
static virDrvOpenStatus
storageOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
if (!driverState)
return VIR_DRV_OPEN_DECLINED;
static virDrvOpenStatus testOpen(virConnectPtr conn,
- virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ virConnectAuthPtr auth ATTRIBUTE_UNUSED,
+ unsigned int flags ATTRIBUTE_UNUSED)
{
int ret;
testConnPtr privconn;
static int testDomainCoreDump(virDomainPtr domain,
const char *to,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
testConnPtr privconn = domain->conn->privateData;
int fd = -1;
return ret;
}
-static char *testDomainGetXMLDesc(virDomainPtr domain, int flags)
+static char *testDomainGetXMLDesc(virDomainPtr domain, unsigned int flags)
{
testConnPtr privconn = domain->conn->privateData;
virDomainDefPtr def;
static virDrvOpenStatus testOpenNetwork(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
if (STRNEQ(conn->driver->name, "Test"))
return VIR_DRV_OPEN_DECLINED;
return ret;
}
-static char *testNetworkGetXMLDesc(virNetworkPtr network, int flags ATTRIBUTE_UNUSED) {
+static char *testNetworkGetXMLDesc(virNetworkPtr network,
+ unsigned int flags ATTRIBUTE_UNUSED)
+{
testConnPtr privconn = network->conn->privateData;
virNetworkObjPtr privnet;
char *ret = NULL;
static virDrvOpenStatus testOpenInterface(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if (STRNEQ(conn->driver->name, "Test"))
return VIR_DRV_OPEN_DECLINED;
static virDrvOpenStatus testStorageOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
if (STRNEQ(conn->driver->name, "Test"))
return VIR_DRV_OPEN_DECLINED;
/* Node device implementations */
static virDrvOpenStatus testDevMonOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
if (STRNEQ(conn->driver->name, "Test"))
return VIR_DRV_OPEN_DECLINED;
static virDrvOpenStatus testSecretOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
if (STRNEQ(conn->driver->name, "Test"))
return VIR_DRV_OPEN_DECLINED;
static virDrvOpenStatus testNWFilterOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
if (STRNEQ(conn->driver->name, "Test"))
return VIR_DRV_OPEN_DECLINED;
static virDrvOpenStatus umlOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
if (conn->uri == NULL) {
if (uml_driver == NULL)
return VIR_DRV_OPEN_DECLINED;
static char *umlDomainGetXMLDesc(virDomainPtr dom,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
struct uml_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
char *ret = NULL;
*/
/*
- * Copyright (C) 2010 Red Hat, Inc.
+ * Copyright (C) 2010-2011 Red Hat, Inc.
* Copyright (C) 2008-2009 Sun Microsystems, Inc.
*
* This file is part of a free software library; you can redistribute
static virDrvOpenStatus vboxOpenDummy(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
uid_t uid = getuid();
if (conn->uri == NULL ||
static virDrvOpenStatus vboxOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
vboxGlobalData *data = NULL;
uid_t uid = getuid();
VIR_DOMAIN_VCPU_MAXIMUM));
}
-static char *vboxDomainGetXMLDesc(virDomainPtr dom, int flags) {
+static char *vboxDomainGetXMLDesc(virDomainPtr dom, unsigned int flags) {
VBOX_OBJECT_CHECK(dom->conn, char *, NULL);
virDomainDefPtr def = NULL;
IMachine *machine = NULL;
*/
static virDrvOpenStatus vboxNetworkOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
vboxGlobalData *data = conn->privateData;
if (STRNEQ(conn->driver->name, "VBOX"))
return vboxNetworkUndefineDestroy(network, false);
}
-static char *vboxNetworkGetXMLDesc(virNetworkPtr network, int flags ATTRIBUTE_UNUSED) {
+static char *vboxNetworkGetXMLDesc(virNetworkPtr network,
+ unsigned int flags ATTRIBUTE_UNUSED) {
VBOX_OBJECT_HOST_CHECK(network->conn, char *, NULL);
virNetworkDefPtr def = NULL;
virNetworkIpDefPtr ipdef = NULL;
static virDrvOpenStatus vboxStorageOpen (virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED) {
+ unsigned int flags ATTRIBUTE_UNUSED) {
vboxGlobalData *data = conn->privateData;
if (STRNEQ(conn->driver->name, "VBOX"))
static virDrvOpenStatus
vmwareOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
struct vmware_driver *driver;
char * vmrun = NULL;
static char *
-vmwareDomainGetXMLDesc(virDomainPtr dom, int flags)
+vmwareDomainGetXMLDesc(virDomainPtr dom, unsigned int flags)
{
struct vmware_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
#endif
static virDrvOpenStatus
-xenUnifiedOpen (virConnectPtr conn, virConnectAuthPtr auth, int flags)
+xenUnifiedOpen (virConnectPtr conn, virConnectAuthPtr auth, unsigned int flags)
{
int i, ret = VIR_DRV_OPEN_DECLINED;
xenUnifiedPrivatePtr priv;
}
static int
-xenUnifiedDomainCoreDump (virDomainPtr dom, const char *to, int flags)
+xenUnifiedDomainCoreDump (virDomainPtr dom, const char *to, unsigned int flags)
{
GET_PRIVATE(dom->conn);
int i;
}
static char *
-xenUnifiedDomainGetXMLDesc(virDomainPtr dom, int flags)
+xenUnifiedDomainGetXMLDesc(virDomainPtr dom, unsigned int flags)
{
GET_PRIVATE(dom->conn);
virDrvOpenStatus
xenHypervisorOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
int ret;
xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData;
virDrvOpenStatus
xenHypervisorOpen (virConnectPtr conn,
virConnectAuthPtr auth,
- int flags);
+ unsigned int flags);
int xenHypervisorClose (virConnectPtr conn);
int xenHypervisorGetVersion (virConnectPtr conn,
unsigned long *hvVer);
* /etc/xen
* /var/lib/xend/domains
*
- * Copyright (C) 2010 Red Hat, Inc.
+ * Copyright (C) 2010-2011 Red Hat, Inc.
* Copyright (C) 2008 VirtualIron
*
* This library is free software; you can redistribute it and/or
*/
virDrvOpenStatus
xenInotifyOpen(virConnectPtr conn,
- virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ virConnectAuthPtr auth ATTRIBUTE_UNUSED,
+ unsigned int flags ATTRIBUTE_UNUSED)
{
DIR *dh;
struct dirent *ent;
/*
* xen_inofify.h: Xen notification of xml files
*
+ * Copyright (C) 2011 Red Hat, Inc.
* Copyright (C) 2008 VirtualIron
*
* This library is free software; you can redistribute it and/or
virDrvOpenStatus xenInotifyOpen (virConnectPtr conn,
virConnectAuthPtr auth,
- int flags);
+ unsigned int flags);
int xenInotifyClose (virConnectPtr conn);
#endif
virDrvOpenStatus
xenDaemonOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
char *port = NULL;
int ret = VIR_DRV_OPEN_ERROR;
*/
static int
xenDaemonDomainCoreDump(virDomainPtr domain, const char *filename,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
if ((domain == NULL) || (domain->conn == NULL) || (domain->name == NULL) ||
(filename == NULL)) {
/*
* xend_internal.h
*
- * Copyright (C) 2006-2008, 2010 Red Hat, Inc.
+ * Copyright (C) 2006-2008, 2010-2011 Red Hat, Inc.
* Copyright (C) 2005,2006
*
* Anthony Liguori <aliguori@us.ibm.com>
/* refactored ones */
-virDrvOpenStatus xenDaemonOpen(virConnectPtr conn, virConnectAuthPtr auth, int flags);
+virDrvOpenStatus xenDaemonOpen(virConnectPtr conn, virConnectAuthPtr auth,
+ unsigned int flags);
int xenDaemonClose(virConnectPtr conn);
int xenDaemonGetVersion(virConnectPtr conn, unsigned long *hvVer);
int xenDaemonNodeGetInfo(virConnectPtr conn, virNodeInfoPtr info);
virDrvOpenStatus
xenXMOpen (virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
xenUnifiedPrivatePtr priv = conn->privateData;
/*
* xm_internal.h: helper routines for dealing with inactive domains
*
- * Copyright (C) 2006-2007, 2010 Red Hat, Inc.
+ * Copyright (C) 2006-2007, 2010-2011 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
int xenXMConfigCacheAddFile(virConnectPtr conn, const char *filename);
int xenXMConfigCacheRemoveFile(virConnectPtr conn, const char *filename);
-virDrvOpenStatus xenXMOpen(virConnectPtr conn, virConnectAuthPtr auth, int flags);
+virDrvOpenStatus xenXMOpen(virConnectPtr conn, virConnectAuthPtr auth,
+ unsigned int flags);
int xenXMClose(virConnectPtr conn);
const char *xenXMGetType(virConnectPtr conn);
int xenXMDomainGetInfo(virDomainPtr domain, virDomainInfoPtr info);
/*
* xs_internal.c: access to Xen Store
*
- * Copyright (C) 2006, 2009-2010 Red Hat, Inc.
+ * Copyright (C) 2006, 2009-2011 Red Hat, Inc.
*
* See COPYING.LIB for the License of this software
*
virDrvOpenStatus
xenStoreOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED)
+ unsigned int flags ATTRIBUTE_UNUSED)
{
xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData;
/*
* xs_internal.h: internal API for access to XenStore
*
- * Copyright (C) 2006, 2010 Red Hat, Inc.
+ * Copyright (C) 2006, 2010-2011 Red Hat, Inc.
*
* See COPYING.LIB for the License of this software
*
virDrvOpenStatus xenStoreOpen (virConnectPtr conn,
virConnectAuthPtr auth,
- int flags);
+ unsigned int flags);
int xenStoreClose (virConnectPtr conn);
int xenStoreGetDomainInfo (virDomainPtr domain,
virDomainInfoPtr info);
* Return VIR_DRV_OPEN_SUCCESS on success, else VIR_DRV_OPEN_ERROR
*/
static virDrvOpenStatus
-xenapiOpen (virConnectPtr conn, virConnectAuthPtr auth, int flags ATTRIBUTE_UNUSED)
+xenapiOpen (virConnectPtr conn, virConnectAuthPtr auth,
+ unsigned int flags ATTRIBUTE_UNUSED)
{
char *username = NULL;
char *password = NULL;
* Returns XML string of the domain configuration on success or -1 in case of error
*/
static char *
-xenapiDomainGetXMLDesc(virDomainPtr dom, int flags ATTRIBUTE_UNUSED)
+xenapiDomainGetXMLDesc(virDomainPtr dom, unsigned int flags ATTRIBUTE_UNUSED)
{
xen_vm vm=NULL;
xen_vm_set *vms;