[libvirt] [PATCH 0/5] Interface Config Public APIs and remote stubs, with MAC addresses in string format
3:07 p.m.
These patches are based on those I sent last week (the public
virInterface*() API definition, the local plumbing, and the RPC glue),
but with suggestions incorporated:
1) MAC address is always used in null-terminated ASCII string
format. This eliminates any potential problems with extra long
addresses.
2) no comments in libvirt.h
3) flags arguments are all unsigned.
Item (1) caused changes in most of the patches, so I just regenerated
the entire set. Is this the proper/expected thing to do, or should I
be making patches of patches?
3:07 p.m.
New subject: [libvirt] [PATCH 1/5] Public API for new virInterface* functions, which facilitate
From: Laine Stump <laine(a)redhat.com>
---
include/libvirt/libvirt.h | 84 ++++++++++++++++++++++++++++++++++++++++++
include/libvirt/libvirt.h.in | 84 ++++++++++++++++++++++++++++++++++++++++++
2 files changed, 168 insertions(+), 0 deletions(-)
diff --git a/include/libvirt/libvirt.h b/include/libvirt/libvirt.h
index 30f559d..91af6fd 100644
--- a/include/libvirt/libvirt.h
+++ b/include/libvirt/libvirt.h
@@ -854,6 +854,90 @@ int virNetworkGetAutostart (virNetworkPtr
network,
int virNetworkSetAutostart (virNetworkPtr network,
int autostart);
+/*
+ * Physical host interface configuration API
+ */
+
+/**
+ * virInterface:
+ *
+ * a virInterface is a private structure representing a virtual interface.
+ */
+typedef struct _virInterface virInterface;
+
+/**
+ * virInterfacePtr:
+ *
+ * a virInterfacePtr is pointer to a virInterface private structure, this is the
+ * type used to reference a virtual interface in the API.
+ */
+typedef virInterface *virInterfacePtr;
+
+/*
+ * Get connection from interface.
+ */
+virConnectPtr virInterfaceGetConnect (virInterfacePtr interface);
+
+/*
+ * List defined interfaces
+ */
+int virConnectNumOfInterfaces (virConnectPtr conn);
+int virConnectListInterfaces (virConnectPtr conn,
+ char **const names,
+ int maxnames);
+
+/*
+ * Lookup interface by name or MAC address
+ */
+virInterfacePtr virInterfaceLookupByName (virConnectPtr conn,
+ const char *name);
+virInterfacePtr virInterfaceLookupByMAC (virConnectPtr conn,
+ const unsigned char *mac);
+virInterfacePtr virInterfaceLookupByMACString (virConnectPtr conn,
+ const char *mac);
+
+/*
+ * Interface information
+ */
+const char* virInterfaceGetName (virInterfacePtr interface);
+int virInterfaceGetMAC (virInterfacePtr interface,
+ unsigned char *mac);
+int virInterfaceGetMACString (virInterfacePtr interface,
+ char *mac);
+
+char * virInterfaceGetXMLDesc (virInterfacePtr interface,
+ int flags);
+/*
+ * Define interface (or modify existing interface configuration)
+ */
+virInterfacePtr virInterfaceDefineXML (virConnectPtr conn,
+ const char *xmlDesc,
+ int flags);
+
+/*
+ * Delete interface
+ */
+int virInterfaceUndefine (virInterfacePtr interface);
+
+/*
+ * Activate interface (ie call "ifup")
+ */
+int virInterfaceCreate (virInterfacePtr interface,
+ int flags);
+
+/*
+ * De-activate interface (call "ifdown")
+ */
+int virInterfaceDestroy (virInterfacePtr interface,
+ int flags);
+
+/*
+ * interface object memory management - you must call
+ * virInterfaceFree() once for each call to virInterfaceRef, or any
+ * API function that returns a virInterfacePtr.
+ */
+int virInterfaceRef (virInterfacePtr interface);
+int virInterfaceFree (virInterfacePtr interface);
/**
* virStoragePool:
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index 2f7076f..cee3d94 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -854,6 +854,90 @@ int virNetworkGetAutostart (virNetworkPtr
network,
int virNetworkSetAutostart (virNetworkPtr network,
int autostart);
+/*
+ * Physical host interface configuration API
+ */
+
+/**
+ * virInterface:
+ *
+ * a virInterface is a private structure representing a virtual interface.
+ */
+typedef struct _virInterface virInterface;
+
+/**
+ * virInterfacePtr:
+ *
+ * a virInterfacePtr is pointer to a virInterface private structure, this is the
+ * type used to reference a virtual interface in the API.
+ */
+typedef virInterface *virInterfacePtr;
+
+/*
+ * Get connection from interface.
+ */
+virConnectPtr virInterfaceGetConnect (virInterfacePtr interface);
+
+/*
+ * List defined interfaces
+ */
+int virConnectNumOfInterfaces (virConnectPtr conn);
+int virConnectListInterfaces (virConnectPtr conn,
+ char **const names,
+ int maxnames);
+
+/*
+ * Lookup interface by name or MAC address
+ */
+virInterfacePtr virInterfaceLookupByName (virConnectPtr conn,
+ const char *name);
+virInterfacePtr virInterfaceLookupByMAC (virConnectPtr conn,
+ const unsigned char *mac);
+virInterfacePtr virInterfaceLookupByMACString (virConnectPtr conn,
+ const char *mac);
+
+/*
+ * Interface information
+ */
+const char* virInterfaceGetName (virInterfacePtr interface);
+int virInterfaceGetMAC (virInterfacePtr interface,
+ unsigned char *mac);
+int virInterfaceGetMACString (virInterfacePtr interface,
+ char *mac);
+
+char * virInterfaceGetXMLDesc (virInterfacePtr interface,
+ int flags);
+/*
+ * Define interface (or modify existing interface configuration)
+ */
+virInterfacePtr virInterfaceDefineXML (virConnectPtr conn,
+ const char *xmlDesc,
+ int flags);
+
+/*
+ * Delete interface
+ */
+int virInterfaceUndefine (virInterfacePtr interface);
+
+/*
+ * Activate interface (ie call "ifup")
+ */
+int virInterfaceCreate (virInterfacePtr interface,
+ int flags);
+
+/*
+ * De-activate interface (call "ifdown")
+ */
+int virInterfaceDestroy (virInterfacePtr interface,
+ int flags);
+
+/*
+ * interface object memory management - you must call
+ * virInterfaceFree() once for each call to virInterfaceRef, or any
+ * API function that returns a virInterfacePtr.
+ */
+int virInterfaceRef (virInterfacePtr interface);
+int virInterfaceFree (virInterfacePtr interface);
/**
* virStoragePool:
--
1.6.0.6
3:07 p.m.
New subject: [libvirt] [PATCH 2/5] First level of plumbing for virInterface*.
From: Laine Stump <laine(a)redhat.com>
---
include/libvirt/libvirt.h | 18 ++
include/libvirt/libvirt.h.in | 18 ++
include/libvirt/virterror.h | 4 +
src/datatypes.h | 25 ++
src/driver.h | 60 ++++
src/libvirt.c | 695 ++++++++++++++++++++++++++++++++++++++++++
src/util.h | 2 -
src/virterror.c | 21 ++
8 files changed, 841 insertions(+), 2 deletions(-)
diff --git a/include/libvirt/libvirt.h b/include/libvirt/libvirt.h
index 91af6fd..b0d93a2 100644
--- a/include/libvirt/libvirt.h
+++ b/include/libvirt/libvirt.h
@@ -433,6 +433,24 @@ extern virConnectAuthPtr virConnectAuthPtrDefault;
#define VIR_UUID_STRING_BUFLEN (36+1)
+/**
+ * VIR_MAC_BUFLEN:
+ *
+ * This macro provides the length of the buffer required
+ * for an interface MAC address
+ */
+
+#define VIR_MAC_BUFLEN (6)
+
+/**
+ * VIR_MAC_STRING_BUFLEN:
+ *
+ * This macro provides the length of the buffer required
+ * for virInterfaceGetMACString()
+ */
+
+#define VIR_MAC_STRING_BUFLEN (VIR_MAC_BUFLEN * 3)
+
/* library versioning */
/**
diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
index cee3d94..fbaf212 100644
--- a/include/libvirt/libvirt.h.in
+++ b/include/libvirt/libvirt.h.in
@@ -433,6 +433,24 @@ extern virConnectAuthPtr virConnectAuthPtrDefault;
#define VIR_UUID_STRING_BUFLEN (36+1)
+/**
+ * VIR_MAC_BUFLEN:
+ *
+ * This macro provides the length of the buffer required
+ * for an interface MAC address
+ */
+
+#define VIR_MAC_BUFLEN (6)
+
+/**
+ * VIR_MAC_STRING_BUFLEN:
+ *
+ * This macro provides the length of the buffer required
+ * for virInterfaceGetMACString()
+ */
+
+#define VIR_MAC_STRING_BUFLEN (VIR_MAC_BUFLEN * 3)
+
/* library versioning */
/**
diff --git a/include/libvirt/virterror.h b/include/libvirt/virterror.h
index faf3f61..766cbad 100644
--- a/include/libvirt/virterror.h
+++ b/include/libvirt/virterror.h
@@ -63,6 +63,7 @@ typedef enum {
VIR_FROM_XEN_INOTIFY, /* Error from xen inotify layer */
VIR_FROM_SECURITY, /* Error from security framework */
VIR_FROM_VBOX, /* Error from VirtualBox driver */
+ VIR_FROM_INTERFACE, /* Error when operating on an interface */
} virErrorDomain;
@@ -157,6 +158,9 @@ typedef enum {
VIR_ERR_INVALID_NODE_DEVICE,/* invalid node device object */
VIR_ERR_NO_NODE_DEVICE,/* node device not found */
VIR_ERR_NO_SECURITY_MODEL, /* security model not found */
+ VIR_WAR_NO_INTERFACE, /* failed to start interface driver */
+ VIR_ERR_NO_INTERFACE, /* interface driver not running */
+ VIR_ERR_INVALID_INTERFACE, /* invalid interface object */
} virErrorNumber;
/**
diff --git a/src/datatypes.h b/src/datatypes.h
index 5956c5d..deac9df 100644
--- a/src/datatypes.h
+++ b/src/datatypes.h
@@ -59,6 +59,16 @@
#define VIR_IS_CONNECTED_NETWORK(obj) (VIR_IS_NETWORK(obj) &&
VIR_IS_CONNECT((obj)->conn))
/**
+ * VIR_INTERFACE_MAGIC:
+ *
+ * magic value used to protect the API when pointers to interface structures
+ * are passed down by the users.
+ */
+#define VIR_INTERFACE_MAGIC 0xDEAD5309
+#define VIR_IS_INTERFACE(obj) ((obj) && (obj)->magic==VIR_INTERFACE_MAGIC)
+#define VIR_IS_CONNECTED_INTERFACE(obj) (VIR_IS_INTERFACE(obj) &&
VIR_IS_CONNECT((obj)->conn))
+
+/**
* VIR_STORAGE_POOL_MAGIC:
*
* magic value used to protect the API when pointers to storage pool structures
@@ -106,6 +116,7 @@ struct _virConnect {
/* The underlying hypervisor driver and network driver. */
virDriverPtr driver;
virNetworkDriverPtr networkDriver;
+ virInterfaceDriverPtr interfaceDriver;
virStorageDriverPtr storageDriver;
virDeviceMonitorPtr deviceMonitor;
@@ -115,6 +126,7 @@ struct _virConnect {
*/
void * privateData;
void * networkPrivateData;
+ void * interfacePrivateData;
void * storagePrivateData;
void * devMonPrivateData;
@@ -167,6 +179,19 @@ struct _virNetwork {
};
/**
+* _virInterface:
+*
+* Internal structure associated to a physical host interface
+*/
+struct _virInterface {
+ unsigned int magic; /* specific value to check */
+ int refs; /* reference count */
+ virConnectPtr conn; /* pointer back to the connection */
+ char *name; /* the network external name */
+ unsigned char mac[VIR_MAC_BUFLEN]; /* the interface MAC address */
+};
+
+/**
* _virStoragePool:
*
* Internal structure associated to a storage pool
diff --git a/src/driver.h b/src/driver.h
index c357b76..30905c0 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -488,6 +488,65 @@ struct _virNetworkDriver {
virDrvNetworkSetAutostart networkSetAutostart;
};
+/*-------*/
+typedef int
+ (*virDrvNumOfInterfaces) (virConnectPtr conn);
+typedef int
+ (*virDrvListInterfaces) (virConnectPtr conn,
+ char **const names,
+ int maxnames);
+typedef virInterfacePtr
+ (*virDrvInterfaceLookupByName) (virConnectPtr conn,
+ const char *name);
+typedef virInterfacePtr
+ (*virDrvInterfaceLookupByMAC) (virConnectPtr conn,
+ const unsigned char *mac);
+
+typedef char *
+ (*virDrvInterfaceGetXMLDesc) (virInterfacePtr interface,
+ int flags);
+
+typedef virInterfacePtr
+ (*virDrvInterfaceDefineXML) (virConnectPtr conn,
+ const char *xmlDesc,
+ int flags);
+typedef int
+ (*virDrvInterfaceUndefine) (virInterfacePtr interface);
+typedef int
+ (*virDrvInterfaceCreate) (virInterfacePtr interface,
+ int flags);
+typedef int
+ (*virDrvInterfaceDestroy) (virInterfacePtr interface,
+ int flags);
+
+typedef struct _virInterfaceDriver virInterfaceDriver;
+typedef virInterfaceDriver *virInterfaceDriverPtr;
+
+/**
+ * _virInterfaceDriver:
+ *
+ * Structure associated to a network virtualization driver, defining the various
+ * entry points for it.
+ *
+ * All drivers must support the following fields/methods:
+ * - open
+ * - close
+ */
+struct _virInterfaceDriver {
+ const char *name; /* the name of the driver */
+ virDrvOpen open;
+ virDrvClose close;
+ virDrvNumOfInterfaces numOfInterfaces;
+ virDrvListInterfaces listInterfaces;
+ virDrvInterfaceLookupByName interfaceLookupByName;
+ virDrvInterfaceLookupByMAC interfaceLookupByMAC;
+ virDrvInterfaceGetXMLDesc interfaceGetXMLDesc;
+ virDrvInterfaceDefineXML interfaceDefineXML;
+ virDrvInterfaceUndefine interfaceUndefine;
+ virDrvInterfaceCreate interfaceCreate;
+ virDrvInterfaceDestroy interfaceDestroy;
+};
+
typedef int
(*virDrvConnectNumOfStoragePools) (virConnectPtr conn);
@@ -718,6 +777,7 @@ struct _virDeviceMonitor {
*/
int virRegisterDriver(virDriverPtr);
int virRegisterNetworkDriver(virNetworkDriverPtr);
+int virRegisterInterfaceDriver(virInterfaceDriverPtr);
int virRegisterStorageDriver(virStorageDriverPtr);
int virRegisterDeviceMonitor(virDeviceMonitorPtr);
#ifdef WITH_LIBVIRTD
diff --git a/src/libvirt.c b/src/libvirt.c
index ded18a7..4bd85a7 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -74,6 +74,8 @@ static virDriverPtr virDriverTab[MAX_DRIVERS];
static int virDriverTabCount = 0;
static virNetworkDriverPtr virNetworkDriverTab[MAX_DRIVERS];
static int virNetworkDriverTabCount = 0;
+static virInterfaceDriverPtr virInterfaceDriverTab[MAX_DRIVERS];
+static int virInterfaceDriverTabCount = 0;
static virStorageDriverPtr virStorageDriverTab[MAX_DRIVERS];
static int virStorageDriverTabCount = 0;
static virDeviceMonitorPtr virDeviceMonitorTab[MAX_DRIVERS];
@@ -462,6 +464,32 @@ virLibNetworkError(virNetworkPtr network, virErrorNumber error,
}
/**
+ * virLibInterfaceError:
+ * @conn: the connection if available
+ * @error: the error number
+ * @info: extra information string
+ *
+ * Handle an error at the connection level
+ */
+static void
+virLibInterfaceError(virInterfacePtr interface, virErrorNumber error,
+ const char *info)
+{
+ virConnectPtr conn = NULL;
+ const char *errmsg;
+
+ if (error == VIR_ERR_OK)
+ return;
+
+ errmsg = virErrorMsg(error, info);
+ if (error != VIR_ERR_INVALID_INTERFACE) {
+ conn = interface->conn;
+ }
+ virRaiseError(conn, NULL, NULL, VIR_FROM_INTERFACE, error, VIR_ERR_ERROR,
+ errmsg, info, NULL, 0, 0, errmsg, info);
+}
+
+/**
* virLibStoragePoolError:
* @conn: the connection if available
* @error: the error number
@@ -571,6 +599,37 @@ virRegisterNetworkDriver(virNetworkDriverPtr driver)
}
/**
+ * virRegisterInterfaceDriver:
+ * @driver: pointer to a interface driver block
+ *
+ * Register a interface virtualization driver
+ *
+ * Returns the driver priority or -1 in case of error.
+ */
+int
+virRegisterInterfaceDriver(virInterfaceDriverPtr driver)
+{
+ if (virInitialize() < 0)
+ return -1;
+
+ if (driver == NULL) {
+ virLibConnError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ return(-1);
+ }
+
+ if (virInterfaceDriverTabCount >= MAX_DRIVERS) {
+ virLibConnError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ return(-1);
+ }
+
+ DEBUG ("registering %s as interface driver %d",
+ driver->name, virInterfaceDriverTabCount);
+
+ virInterfaceDriverTab[virInterfaceDriverTabCount] = driver;
+ return virInterfaceDriverTabCount++;
+}
+
+/**
* virRegisterStorageDriver:
* @driver: pointer to a storage driver block
*
@@ -966,6 +1025,24 @@ do_open (const char *name,
}
}
+ for (i = 0; i < virInterfaceDriverTabCount; i++) {
+ res = virInterfaceDriverTab[i]->open (ret, auth, flags);
+ DEBUG("interface driver %d %s returned %s",
+ i, virInterfaceDriverTab[i]->name,
+ res == VIR_DRV_OPEN_SUCCESS ? "SUCCESS" :
+ (res == VIR_DRV_OPEN_DECLINED ? "DECLINED" :
+ (res == VIR_DRV_OPEN_ERROR ? "ERROR" : "unknown
status")));
+ if (res == VIR_DRV_OPEN_ERROR) {
+ if (STREQ(virInterfaceDriverTab[i]->name, "remote")) {
+ virLibConnWarning (NULL, VIR_WAR_NO_INTERFACE,
+ "Is the daemon running ?");
+ }
+ break;
+ } else if (res == VIR_DRV_OPEN_SUCCESS) {
+ ret->interfaceDriver = virInterfaceDriverTab[i];
+ break;
+ }
+ }
/* Secondary driver for storage. Optional */
for (i = 0; i < virStorageDriverTabCount; i++) {
@@ -1126,6 +1203,8 @@ virConnectClose(virConnectPtr conn)
if (conn->networkDriver)
conn->networkDriver->close (conn);
+ if (conn->interfaceDriver)
+ conn->interfaceDriver->close (conn);
if (conn->storageDriver)
conn->storageDriver->close (conn);
if (conn->deviceMonitor)
@@ -5278,6 +5357,622 @@ error:
return -1;
}
+/**
+ * virInterfaceGetConnect:
+ * @net: pointer to a interface
+ *
+ * Provides the connection pointer associated with an interface. The
+ * reference counter on the connection is not increased by this
+ * call.
+ *
+ * WARNING: When writing libvirt bindings in other languages, do
+ * not use this function. Instead, store the connection and
+ * the interface object together.
+ *
+ * Returns the virConnectPtr or NULL in case of failure.
+ */
+virConnectPtr
+virInterfaceGetConnect (virInterfacePtr interface)
+{
+ DEBUG("interface=%p", interface);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_INTERFACE (interface)) {
+ virLibInterfaceError (NULL, VIR_ERR_INVALID_INTERFACE, __FUNCTION__);
+ return NULL;
+ }
+ return interface->conn;
+}
+
+/**
+ * virConnectNumOfInterfaces:
+ * @conn: pointer to the hypervisor connection
+ *
+ * Provides the number of interfaces on the physical host.
+ *
+ * Returns the number of interface found or -1 in case of error
+ */
+int
+virConnectNumOfInterfaces(virConnectPtr conn)
+{
+ DEBUG("conn=%p", conn);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECT(conn)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ if (conn->interfaceDriver && conn->interfaceDriver->numOfInterfaces)
{
+ int ret;
+ ret = conn->interfaceDriver->numOfInterfaces (conn);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(conn);
+ return -1;
+}
+
+/**
+ * virConnectListInterfaces:
+ * @conn: pointer to the hypervisor connection
+ * @names: array to collect the list of names of interfaces
+ * @maxnames: size of @names
+ *
+ * Collect the list of physical host interfaces, and store their names in @names
+ *
+ * Returns the number of interfaces found or -1 in case of error
+ */
+int
+virConnectListInterfaces(virConnectPtr conn, char **const names, int maxnames)
+{
+ DEBUG("conn=%p, names=%p, maxnames=%d", conn, names, maxnames);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECT(conn)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (-1);
+ }
+
+ if ((names == NULL) || (maxnames < 0)) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->interfaceDriver && conn->interfaceDriver->listInterfaces)
{
+ int ret;
+ ret = conn->interfaceDriver->listInterfaces (conn, names, maxnames);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(conn);
+ return -1;
+}
+
+/**
+ * virInterfaceLookupByName:
+ * @conn: pointer to the hypervisor connection
+ * @name: name for the interface
+ *
+ * Try to lookup an interface on the given hypervisor based on its name.
+ *
+ * Returns a new interface object or NULL in case of failure. If the
+ * interface cannot be found, then VIR_ERR_NO_INTERFACE error is raised.
+ */
+virInterfacePtr
+virInterfaceLookupByName(virConnectPtr conn, const char *name)
+{
+ DEBUG("conn=%p, name=%s", conn, name);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECT(conn)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (NULL);
+ }
+ if (name == NULL) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->interfaceDriver &&
conn->interfaceDriver->interfaceLookupByName) {
+ virInterfacePtr ret;
+ ret = conn->interfaceDriver->interfaceLookupByName (conn, name);
+ if (!ret)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(conn);
+ return NULL;
+}
+
+/**
+ * virInterfaceLookupByMAC:
+ * @conn: pointer to the hypervisor connection
+ * @mac: the raw MAC for the interface
+ *
+ * Try to lookup an interface on the given hypervisor based on its MAC.
+ *
+ * Returns a new interface object or NULL in case of failure. If the
+ * interface cannot be found, then VIR_ERR_NO_INTERFACE error is raised.
+ */
+virInterfacePtr
+virInterfaceLookupByMAC(virConnectPtr conn, const unsigned char *mac)
+{
+ DEBUG("conn=%p, mac=%02X:%02X:%02X:%02X:%02X:%02X", conn, mac[0], mac[1],
mac[2], mac[3], mac[4], mac[5]);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECT(conn)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (NULL);
+ }
+ if (mac == NULL) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->interfaceDriver &&
conn->interfaceDriver->interfaceLookupByMAC){
+ virInterfacePtr ret;
+ ret = conn->interfaceDriver->interfaceLookupByMAC (conn, mac);
+ if (!ret)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(conn);
+ return NULL;
+}
+
+/**
+ * virInterfaceLookupByMACString:
+ * @conn: pointer to the hypervisor connection
+ * @macstr: the string MAC for the interface
+ *
+ * Try to lookup an interface on the given hypervisor based on its MAC.
+ *
+ * Returns a new interface object or NULL in case of failure. If the
+ * interface cannot be found, then VIR_ERR_NO_INTERFACE error is raised.
+ */
+virInterfacePtr
+virInterfaceLookupByMACString(virConnectPtr conn, const char *macstr)
+{
+ unsigned char mac[VIR_MAC_BUFLEN];
+ int ret;
+ DEBUG("conn=%p, macstr=%s", conn, macstr);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECT(conn)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (NULL);
+ }
+ if (macstr == NULL) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ ret = virParseMacAddr (macstr, mac);
+ if (ret == -1) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ return virInterfaceLookupByMAC(conn, &mac[0]);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(conn);
+ return NULL;
+}
+
+/**
+ * virInterfaceGetName:
+ * @interface: a interface object
+ *
+ * Get the public name for that interface
+ *
+ * Returns a pointer to the name or NULL, the string need not be deallocated
+ * its lifetime will be the same as the interface object.
+ */
+const char *
+virInterfaceGetName(virInterfacePtr interface)
+{
+ DEBUG("interface=%p", interface);
+
+ virResetLastError();
+
+ if (!VIR_IS_INTERFACE(interface)) {
+ virLibInterfaceError(NULL, VIR_ERR_INVALID_INTERFACE, __FUNCTION__);
+ return (NULL);
+ }
+ return (interface->name);
+}
+
+/**
+ * virInterfaceGetMAC:
+ * @interface: a interface object
+ * @mac: pointer to a VIR_MAC_BUFLEN bytes array
+ *
+ * Get the MAC for a interface
+ *
+ * Returns -1 in case of error, 0 in case of success
+ */
+int
+virInterfaceGetMAC(virInterfacePtr interface, unsigned char *mac)
+{
+ DEBUG("interface=%p, mac=%p", interface, mac);
+
+ virResetLastError();
+
+ if (!VIR_IS_INTERFACE(interface)) {
+ virLibInterfaceError(NULL, VIR_ERR_INVALID_INTERFACE, __FUNCTION__);
+ return (-1);
+ }
+ if (mac == NULL) {
+ virLibInterfaceError(interface, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ memcpy(mac, &interface->mac[0], VIR_MAC_BUFLEN);
+
+ return (0);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(interface->conn);
+ return -1;
+}
+
+/**
+ * virInterfaceGetMACString:
+ * @interface: a interface object
+ * @buf: pointer to a VIR_MAC_STRING_BUFLEN bytes array
+ *
+ * Get the MAC for a interface as string. For more information about
+ * MAC see RFC4122.
+ *
+ * Returns -1 in case of error, 0 in case of success
+ */
+int
+virInterfaceGetMACString(virInterfacePtr interface, char *buf)
+{
+ unsigned char mac[VIR_MAC_BUFLEN];
+ DEBUG("interface=%p, buf=%p", interface, buf);
+
+ virResetLastError();
+
+ if (!VIR_IS_INTERFACE(interface)) {
+ virLibInterfaceError(NULL, VIR_ERR_INVALID_INTERFACE, __FUNCTION__);
+ return (-1);
+ }
+ if (buf == NULL) {
+ virLibInterfaceError(interface, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ if (virInterfaceGetMAC(interface, &mac[0]))
+ return (-1);
+
+ virFormatMacAddr(mac, buf);
+ return (0);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(interface->conn);
+ return -1;
+}
+
+/**
+ * virInterfaceGetXMLDesc:
+ * @interface: a interface object
+ * @flags: and OR'ed set of extraction flags, not used yet
+ *
+ * Provide an XML description of the interface. The description may be reused
+ * later to relaunch the interface with virInterfaceCreateXML().
+ *
+ * Returns a 0 terminated UTF-8 encoded XML instance, or NULL in case of error.
+ * the caller must free() the returned value.
+ */
+char *
+virInterfaceGetXMLDesc(virInterfacePtr interface, int flags)
+{
+ virConnectPtr conn;
+ DEBUG("interface=%p, flags=%d", interface, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_INTERFACE(interface)) {
+ virLibInterfaceError(NULL, VIR_ERR_INVALID_INTERFACE, __FUNCTION__);
+ return (NULL);
+ }
+ if (flags != 0) {
+ virLibInterfaceError(interface, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ conn = interface->conn;
+
+ if (conn->interfaceDriver &&
conn->interfaceDriver->interfaceGetXMLDesc) {
+ char *ret;
+ ret = conn->interfaceDriver->interfaceGetXMLDesc (interface, flags);
+ if (!ret)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(interface->conn);
+ return NULL;
+}
+
+/**
+ * virInterfaceDefineXML:
+ * @conn: pointer to the hypervisor connection
+ * @xml: the XML description for the interface, preferably in UTF-8
+ *
+ * Define an interface (or modify existing interface configuration)
+ *
+ * Returns NULL in case of error, a pointer to the interface otherwise
+ */
+virInterfacePtr
+virInterfaceDefineXML(virConnectPtr conn, const char *xml, int flags)
+{
+ DEBUG("conn=%p, xml=%s, flags=%d", conn, xml, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECT(conn)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_CONN, __FUNCTION__);
+ return (NULL);
+ }
+ if (conn->flags & VIR_CONNECT_RO) {
+ virLibConnError(conn, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
+ goto error;
+ }
+ if (xml == NULL) {
+ virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->interfaceDriver &&
conn->interfaceDriver->interfaceDefineXML) {
+ virInterfacePtr ret;
+ ret = conn->interfaceDriver->interfaceDefineXML (conn, xml, flags);
+ if (!ret)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(conn);
+ return NULL;
+}
+
+/**
+ * virInterfaceUndefine:
+ * @interface: pointer to a defined interface
+ *
+ * Undefine an interface, ie remove it from the config
+ *
+ * Returns 0 in case of success, -1 in case of error
+ */
+int
+virInterfaceUndefine(virInterfacePtr interface) {
+ virConnectPtr conn;
+ DEBUG("interface=%p", interface);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_INTERFACE(interface)) {
+ virLibInterfaceError(NULL, VIR_ERR_INVALID_INTERFACE, __FUNCTION__);
+ return (-1);
+ }
+ conn = interface->conn;
+ if (conn->flags & VIR_CONNECT_RO) {
+ virLibInterfaceError(interface, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->interfaceDriver &&
conn->interfaceDriver->interfaceUndefine) {
+ int ret;
+ ret = conn->interfaceDriver->interfaceUndefine (interface);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(interface->conn);
+ return -1;
+}
+
+/**
+ * virInterfaceCreate:
+ * @interface: pointer to a defined interface
+ *
+ * Activate an interface (ie call "ifup")
+ *
+ * Returns 0 in case of success, -1 in case of error
+ */
+int
+virInterfaceCreate(virInterfacePtr interface, int flags)
+{
+ virConnectPtr conn;
+ DEBUG("interface=%p, flags=%d", interface, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_INTERFACE(interface)) {
+ virLibInterfaceError(NULL, VIR_ERR_INVALID_INTERFACE, __FUNCTION__);
+ return (-1);
+ }
+ conn = interface->conn;
+ if (conn->flags & VIR_CONNECT_RO) {
+ virLibInterfaceError(interface, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->interfaceDriver && conn->interfaceDriver->interfaceCreate)
{
+ int ret;
+ ret = conn->interfaceDriver->interfaceCreate (interface, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(interface->conn);
+ return -1;
+}
+
+/**
+ * virInterfaceDestroy:
+ * @interface: an interface object
+ *
+ * Destroy the interface object. The running instance is shutdown if not down
+ * already and all resources used by it are given back to the hypervisor. This
+ * does not free the associated virInterfacePtr object.
+ * This function may require privileged access
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+int
+virInterfaceDestroy(virInterfacePtr interface, int flags)
+{
+ virConnectPtr conn;
+ DEBUG("interface=%p, flags=%d", interface, flags);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_INTERFACE(interface)) {
+ virLibInterfaceError(NULL, VIR_ERR_INVALID_INTERFACE, __FUNCTION__);
+ return (-1);
+ }
+
+ conn = interface->conn;
+ if (conn->flags & VIR_CONNECT_RO) {
+ virLibInterfaceError(interface, VIR_ERR_OPERATION_DENIED, __FUNCTION__);
+ goto error;
+ }
+
+ if (conn->interfaceDriver &&
conn->interfaceDriver->interfaceDestroy) {
+ int ret;
+ ret = conn->interfaceDriver->interfaceDestroy (interface, flags);
+ if (ret < 0)
+ goto error;
+ return ret;
+ }
+
+ virLibConnError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
+
+error:
+ /* Copy to connection error object for back compatability */
+ virSetConnError(interface->conn);
+ return -1;
+}
+
+/**
+ * virInterfaceRef:
+ * @interface: the interface to hold a reference on
+ *
+ * Increment the reference count on the interface. For each
+ * additional call to this method, there shall be a corresponding
+ * call to virInterfaceFree 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 interface would increment
+ * the reference count.
+ *
+ * Returns 0 in case of success, -1 in case of failure.
+ */
+int
+virInterfaceRef(virInterfacePtr interface)
+{
+ if ((!VIR_IS_CONNECTED_INTERFACE(interface))) {
+ virLibConnError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ return(-1);
+ }
+ virMutexLock(&interface->conn->lock);
+ DEBUG("interface=%p refs=%d", interface, interface->refs);
+ interface->refs++;
+ virMutexUnlock(&interface->conn->lock);
+ return 0;
+}
+
+/**
+ * virInterfaceFree:
+ * @interface: a interface object
+ *
+ * Free the interface object. The running instance is kept alive.
+ * The data structure is freed and should not be used thereafter.
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+int
+virInterfaceFree(virInterfacePtr interface)
+{
+ DEBUG("interface=%p", interface);
+
+ virResetLastError();
+
+ if (!VIR_IS_CONNECTED_INTERFACE(interface)) {
+ virLibInterfaceError(NULL, VIR_ERR_INVALID_INTERFACE, __FUNCTION__);
+ return (-1);
+ }
+#if 0
+ /*
+ * FIXME: This needs to be uncommented when the stubs are replaced
+ * with actual functionality.
+ */
+
+ if (virUnrefInterface(interface) < 0)
+ return (-1);
+#else
+ interface->refs--;
+#endif
+
+ return(0);
+}
+
/**
* virStoragePoolGetConnect:
diff --git a/src/util.h b/src/util.h
index 4bed077..2bb45bf 100644
--- a/src/util.h
+++ b/src/util.h
@@ -146,9 +146,7 @@ int virParseNumber(const char **str);
int virAsprintf(char **strp, const char *fmt, ...)
ATTRIBUTE_FORMAT(printf, 2, 3);
-#define VIR_MAC_BUFLEN 6
#define VIR_MAC_PREFIX_BUFLEN 3
-#define VIR_MAC_STRING_BUFLEN VIR_MAC_BUFLEN * 3
int virParseMacAddr(const char* str,
unsigned char *addr);
diff --git a/src/virterror.c b/src/virterror.c
index c9db91f..0f4a9eb 100644
--- a/src/virterror.c
+++ b/src/virterror.c
@@ -157,6 +157,9 @@ static const char *virErrorDomainName(virErrorDomain domain) {
case VIR_FROM_VBOX:
dom = "VBOX ";
break;
+ case VIR_FROM_INTERFACE:
+ dom = "Interface ";
+ break;
}
return(dom);
}
@@ -1018,6 +1021,24 @@ virErrorMsg(virErrorNumber error, const char *info)
else
errmsg = _("Security model not found: %s");
break;
+ case VIR_WAR_NO_INTERFACE:
+ if (info == NULL)
+ errmsg = _("Failed to find the interface");
+ else
+ errmsg = _("Failed to find the interface: %s");
+ break;
+ case VIR_ERR_NO_INTERFACE:
+ if (info == NULL)
+ errmsg = _("Interface not found");
+ else
+ errmsg = _("Interface not found: %s");
+ break;
+ case VIR_ERR_INVALID_INTERFACE:
+ if (info == NULL)
+ errmsg = _("invalid interface pointer in");
+ else
+ errmsg = _("invalid interface pointer in %s");
+ break;
}
return (errmsg);
}
--
1.6.0.6
3:07 p.m.
New subject: [libvirt] [PATCH 3/5] Implement RPC part of interface config API.
---
qemud/remote.c | 235 ++++++++++++++++++++++++
qemud/remote_dispatch_args.h | 8 +
qemud/remote_dispatch_prototypes.h | 63 +++++++
qemud/remote_dispatch_ret.h | 6 +
qemud/remote_dispatch_table.h | 50 +++++
qemud/remote_protocol.c | 156 ++++++++++++++++
qemud/remote_protocol.h | 127 +++++++++++++
qemud/remote_protocol.x | 90 +++++++++-
src/datatypes.c | 154 ++++++++++++++++
src/datatypes.h | 6 +
src/libvirt.c | 10 -
src/remote_internal.c | 351 ++++++++++++++++++++++++++++++++++++
12 files changed, 1245 insertions(+), 11 deletions(-)
diff --git a/qemud/remote.c b/qemud/remote.c
index 8d24a3a..6dfd83a 100644
--- a/qemud/remote.c
+++ b/qemud/remote.c
@@ -60,10 +60,12 @@ static void remoteDispatchFormatError (remote_error *rerr,
ATTRIBUTE_FORMAT(printf, 2, 3);
static virDomainPtr get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain
domain);
static virNetworkPtr get_nonnull_network (virConnectPtr conn, remote_nonnull_network
network);
+static virInterfacePtr get_nonnull_interface (virConnectPtr conn,
remote_nonnull_interface interface);
static virStoragePoolPtr get_nonnull_storage_pool (virConnectPtr conn,
remote_nonnull_storage_pool pool);
static virStorageVolPtr get_nonnull_storage_vol (virConnectPtr conn,
remote_nonnull_storage_vol vol);
static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr
net_src);
+static void make_nonnull_interface (remote_nonnull_interface *interface_dst,
virInterfacePtr interface_src);
static void make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst,
virStoragePoolPtr pool_src);
static void make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst,
virStorageVolPtr vol_src);
static void make_nonnull_node_device (remote_nonnull_node_device *dev_dst,
virNodeDevicePtr dev_src);
@@ -2559,6 +2561,225 @@ remoteDispatchNumOfNetworks (struct qemud_server *server
ATTRIBUTE_UNUSED,
}
+/*-------------------------------------------------------------*/
+static int
+remoteDispatchNumOfInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ void *args ATTRIBUTE_UNUSED,
+ remote_num_of_interfaces_ret *ret)
+{
+
+ ret->num = virConnectNumOfInterfaces (conn);
+ if (ret->num == -1) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchListInterfaces (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_list_interfaces_args *args,
+ remote_list_interfaces_ret *ret)
+{
+
+ if (args->maxnames > REMOTE_INTERFACE_NAME_LIST_MAX) {
+ remoteDispatchFormatError (rerr,
+ "%s", _("maxnames >
REMOTE_INTERFACE_NAME_LIST_MAX"));
+ return -1;
+ }
+
+ /* Allocate return buffer. */
+ if (VIR_ALLOC_N(ret->names.names_val, args->maxnames) < 0) {
+ remoteDispatchOOMError(rerr);
+ return -1;
+ }
+
+ ret->names.names_len =
+ virConnectListInterfaces (conn,
+ ret->names.names_val, args->maxnames);
+ if (ret->names.names_len == -1) {
+ VIR_FREE(ret->names.names_len);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceLookupByName (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_lookup_by_name_args *args,
+ remote_interface_lookup_by_name_ret *ret)
+{
+ virInterfacePtr interface;
+
+ interface = virInterfaceLookupByName (conn, args->name);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_interface (&ret->interface, interface);
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceLookupByMac (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_lookup_by_mac_args *args,
+ remote_interface_lookup_by_mac_ret *ret)
+{
+ virInterfacePtr interface;
+
+ interface = virInterfaceLookupByMAC (conn, (unsigned char *) args->mac);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_interface (&ret->interface, interface);
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceGetXmlDesc (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_get_xml_desc_args *args,
+ remote_interface_get_xml_desc_ret *ret)
+{
+ virInterfacePtr interface;
+
+ interface = get_nonnull_interface (conn, args->interface);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ /* remoteDispatchClientRequest will free this. */
+ ret->xml = virInterfaceGetXMLDesc (interface, args->flags);
+ if (!ret->xml) {
+ virInterfaceFree(interface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceDefineXml (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_define_xml_args *args,
+ remote_interface_define_xml_ret *ret)
+{
+ virInterfacePtr interface;
+
+ interface = virInterfaceDefineXML (conn, args->xml, args->flags);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ make_nonnull_interface (&ret->interface, interface);
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceUndefine (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_undefine_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virInterfacePtr interface;
+
+ interface = get_nonnull_interface (conn, args->interface);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virInterfaceUndefine (interface) == -1) {
+ virInterfaceFree(interface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceCreate (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_create_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virInterfacePtr interface;
+
+ interface = get_nonnull_interface (conn, args->interface);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virInterfaceCreate (interface, args->flags) == -1) {
+ virInterfaceFree(interface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(interface);
+ return 0;
+}
+
+static int
+remoteDispatchInterfaceDestroy (struct qemud_server *server ATTRIBUTE_UNUSED,
+ struct qemud_client *client ATTRIBUTE_UNUSED,
+ virConnectPtr conn,
+ remote_error *rerr,
+ remote_interface_destroy_args *args,
+ void *ret ATTRIBUTE_UNUSED)
+{
+ virInterfacePtr interface;
+
+ interface = get_nonnull_interface (conn, args->interface);
+ if (interface == NULL) {
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+
+ if (virInterfaceDestroy (interface, args->flags) == -1) {
+ virInterfaceFree(interface);
+ remoteDispatchConnError(rerr, conn);
+ return -1;
+ }
+ virInterfaceFree(interface);
+ return 0;
+}
+
+/*-------------------------------------------------------------*/
+
static int
remoteDispatchAuthList (struct qemud_server *server,
struct qemud_client *client,
@@ -4527,6 +4748,12 @@ get_nonnull_network (virConnectPtr conn, remote_nonnull_network
network)
return virGetNetwork (conn, network.name, BAD_CAST network.uuid);
}
+static virInterfacePtr
+get_nonnull_interface (virConnectPtr conn, remote_nonnull_interface interface)
+{
+ return virGetInterface (conn, interface.name, BAD_CAST interface.mac);
+}
+
static virStoragePoolPtr
get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool)
{
@@ -4558,6 +4785,14 @@ make_nonnull_network (remote_nonnull_network *net_dst,
virNetworkPtr net_src)
}
static void
+make_nonnull_interface (remote_nonnull_interface *interface_dst,
+ virInterfacePtr interface_src)
+{
+ interface_dst->name = strdup (interface_src->name);
+ memcpy (interface_dst->mac, interface_src->mac, VIR_MAC_BUFLEN);
+}
+
+static void
make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr
pool_src)
{
pool_dst->name = strdup (pool_src->name);
diff --git a/qemud/remote_dispatch_args.h b/qemud/remote_dispatch_args.h
index 58eccf5..2297a48 100644
--- a/qemud/remote_dispatch_args.h
+++ b/qemud/remote_dispatch_args.h
@@ -105,3 +105,11 @@
remote_domain_get_security_label_args val_remote_domain_get_security_label_args;
remote_node_device_create_xml_args val_remote_node_device_create_xml_args;
remote_node_device_destroy_args val_remote_node_device_destroy_args;
+ remote_list_interfaces_args val_remote_list_interfaces_args;
+ remote_interface_lookup_by_name_args val_remote_interface_lookup_by_name_args;
+ remote_interface_lookup_by_mac_args val_remote_interface_lookup_by_mac_args;
+ remote_interface_get_xml_desc_args val_remote_interface_get_xml_desc_args;
+ remote_interface_define_xml_args val_remote_interface_define_xml_args;
+ remote_interface_undefine_args val_remote_interface_undefine_args;
+ remote_interface_create_args val_remote_interface_create_args;
+ remote_interface_destroy_args val_remote_interface_destroy_args;
diff --git a/qemud/remote_dispatch_prototypes.h b/qemud/remote_dispatch_prototypes.h
index 96dcb2a..80044c1 100644
--- a/qemud/remote_dispatch_prototypes.h
+++ b/qemud/remote_dispatch_prototypes.h
@@ -408,6 +408,55 @@ static int remoteDispatchGetVersion(
remote_error *err,
void *args,
remote_get_version_ret *ret);
+static int remoteDispatchInterfaceCreate(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_create_args *args,
+ void *ret);
+static int remoteDispatchInterfaceDefineXml(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_define_xml_args *args,
+ remote_interface_define_xml_ret *ret);
+static int remoteDispatchInterfaceDestroy(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_destroy_args *args,
+ void *ret);
+static int remoteDispatchInterfaceGetXmlDesc(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_get_xml_desc_args *args,
+ remote_interface_get_xml_desc_ret *ret);
+static int remoteDispatchInterfaceLookupByMac(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_lookup_by_mac_args *args,
+ remote_interface_lookup_by_mac_ret *ret);
+static int remoteDispatchInterfaceLookupByName(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_lookup_by_name_args *args,
+ remote_interface_lookup_by_name_ret *ret);
+static int remoteDispatchInterfaceUndefine(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_interface_undefine_args *args,
+ void *ret);
static int remoteDispatchListDefinedDomains(
struct qemud_server *server,
struct qemud_client *client,
@@ -436,6 +485,13 @@ static int remoteDispatchListDomains(
remote_error *err,
remote_list_domains_args *args,
remote_list_domains_ret *ret);
+static int remoteDispatchListInterfaces(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ remote_list_interfaces_args *args,
+ remote_list_interfaces_ret *ret);
static int remoteDispatchListNetworks(
struct qemud_server *server,
struct qemud_client *client,
@@ -667,6 +723,13 @@ static int remoteDispatchNumOfDomains(
remote_error *err,
void *args,
remote_num_of_domains_ret *ret);
+static int remoteDispatchNumOfInterfaces(
+ struct qemud_server *server,
+ struct qemud_client *client,
+ virConnectPtr conn,
+ remote_error *err,
+ void *args,
+ remote_num_of_interfaces_ret *ret);
static int remoteDispatchNumOfNetworks(
struct qemud_server *server,
struct qemud_client *client,
diff --git a/qemud/remote_dispatch_ret.h b/qemud/remote_dispatch_ret.h
index 3325c8b..1c5380a 100644
--- a/qemud/remote_dispatch_ret.h
+++ b/qemud/remote_dispatch_ret.h
@@ -89,3 +89,9 @@
remote_domain_get_security_label_ret val_remote_domain_get_security_label_ret;
remote_node_get_security_model_ret val_remote_node_get_security_model_ret;
remote_node_device_create_xml_ret val_remote_node_device_create_xml_ret;
+ remote_num_of_interfaces_ret val_remote_num_of_interfaces_ret;
+ remote_list_interfaces_ret val_remote_list_interfaces_ret;
+ remote_interface_lookup_by_name_ret val_remote_interface_lookup_by_name_ret;
+ remote_interface_lookup_by_mac_ret val_remote_interface_lookup_by_mac_ret;
+ remote_interface_get_xml_desc_ret val_remote_interface_get_xml_desc_ret;
+ remote_interface_define_xml_ret val_remote_interface_define_xml_ret;
diff --git a/qemud/remote_dispatch_table.h b/qemud/remote_dispatch_table.h
index ac7f9b9..68e67e5 100644
--- a/qemud/remote_dispatch_table.h
+++ b/qemud/remote_dispatch_table.h
@@ -627,3 +627,53 @@
.args_filter = (xdrproc_t) xdr_remote_node_device_destroy_args,
.ret_filter = (xdrproc_t) xdr_void,
},
+{ /* (unused) => 125 */
+ .fn = NULL,
+ .args_filter = (xdrproc_t) xdr_void,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
+{ /* NumOfInterfaces => 126 */
+ .fn = (dispatch_fn) remoteDispatchNumOfInterfaces,
+ .args_filter = (xdrproc_t) xdr_void,
+ .ret_filter = (xdrproc_t) xdr_remote_num_of_interfaces_ret,
+},
+{ /* ListInterfaces => 127 */
+ .fn = (dispatch_fn) remoteDispatchListInterfaces,
+ .args_filter = (xdrproc_t) xdr_remote_list_interfaces_args,
+ .ret_filter = (xdrproc_t) xdr_remote_list_interfaces_ret,
+},
+{ /* InterfaceLookupByName => 128 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceLookupByName,
+ .args_filter = (xdrproc_t) xdr_remote_interface_lookup_by_name_args,
+ .ret_filter = (xdrproc_t) xdr_remote_interface_lookup_by_name_ret,
+},
+{ /* InterfaceLookupByMac => 129 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceLookupByMac,
+ .args_filter = (xdrproc_t) xdr_remote_interface_lookup_by_mac_args,
+ .ret_filter = (xdrproc_t) xdr_remote_interface_lookup_by_mac_ret,
+},
+{ /* InterfaceGetXmlDesc => 130 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceGetXmlDesc,
+ .args_filter = (xdrproc_t) xdr_remote_interface_get_xml_desc_args,
+ .ret_filter = (xdrproc_t) xdr_remote_interface_get_xml_desc_ret,
+},
+{ /* InterfaceDefineXml => 131 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceDefineXml,
+ .args_filter = (xdrproc_t) xdr_remote_interface_define_xml_args,
+ .ret_filter = (xdrproc_t) xdr_remote_interface_define_xml_ret,
+},
+{ /* InterfaceUndefine => 132 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceUndefine,
+ .args_filter = (xdrproc_t) xdr_remote_interface_undefine_args,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
+{ /* InterfaceCreate => 133 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceCreate,
+ .args_filter = (xdrproc_t) xdr_remote_interface_create_args,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
+{ /* InterfaceDestroy => 134 */
+ .fn = (dispatch_fn) remoteDispatchInterfaceDestroy,
+ .args_filter = (xdrproc_t) xdr_remote_interface_destroy_args,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
diff --git a/qemud/remote_protocol.c b/qemud/remote_protocol.c
index af3c792..578857d 100644
--- a/qemud/remote_protocol.c
+++ b/qemud/remote_protocol.c
@@ -36,6 +36,15 @@ xdr_remote_uuid (XDR *xdrs, remote_uuid objp)
}
bool_t
+xdr_remote_mac (XDR *xdrs, remote_mac objp)
+{
+
+ if (!xdr_opaque (xdrs, objp, VIR_MAC_BUFLEN))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
xdr_remote_nonnull_domain (XDR *xdrs, remote_nonnull_domain *objp)
{
@@ -60,6 +69,17 @@ xdr_remote_nonnull_network (XDR *xdrs, remote_nonnull_network *objp)
}
bool_t
+xdr_remote_nonnull_interface (XDR *xdrs, remote_nonnull_interface *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ if (!xdr_remote_mac (xdrs, objp->mac))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
xdr_remote_nonnull_storage_pool (XDR *xdrs, remote_nonnull_storage_pool *objp)
{
@@ -1478,6 +1498,142 @@ xdr_remote_network_set_autostart_args (XDR *xdrs,
remote_network_set_autostart_a
}
bool_t
+xdr_remote_num_of_interfaces_ret (XDR *xdrs, remote_num_of_interfaces_ret *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->num))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_interfaces_args (XDR *xdrs, remote_list_interfaces_args *objp)
+{
+
+ if (!xdr_int (xdrs, &objp->maxnames))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_list_interfaces_ret (XDR *xdrs, remote_list_interfaces_ret *objp)
+{
+ char **objp_cpp0 = (char **) (void *) &objp->names.names_val;
+
+ if (!xdr_array (xdrs, objp_cpp0, (u_int *) &objp->names.names_len,
REMOTE_INTERFACE_NAME_LIST_MAX,
+ sizeof (remote_nonnull_string), (xdrproc_t) xdr_remote_nonnull_string))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_name_args (XDR *xdrs, remote_interface_lookup_by_name_args
*objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->name))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_name_ret (XDR *xdrs, remote_interface_lookup_by_name_ret
*objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_mac_args (XDR *xdrs, remote_interface_lookup_by_mac_args
*objp)
+{
+
+ if (!xdr_remote_mac (xdrs, objp->mac))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_lookup_by_mac_ret (XDR *xdrs, remote_interface_lookup_by_mac_ret
*objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_get_xml_desc_args (XDR *xdrs, remote_interface_get_xml_desc_args
*objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_get_xml_desc_ret (XDR *xdrs, remote_interface_get_xml_desc_ret
*objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_define_xml_args (XDR *xdrs, remote_interface_define_xml_args *objp)
+{
+
+ if (!xdr_remote_nonnull_string (xdrs, &objp->xml))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_define_xml_ret (XDR *xdrs, remote_interface_define_xml_ret *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_undefine_args (XDR *xdrs, remote_interface_undefine_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_create_args (XDR *xdrs, remote_interface_create_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
+xdr_remote_interface_destroy_args (XDR *xdrs, remote_interface_destroy_args *objp)
+{
+
+ if (!xdr_remote_nonnull_interface (xdrs, &objp->interface))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->flags))
+ return FALSE;
+ return TRUE;
+}
+
+bool_t
xdr_remote_auth_list_ret (XDR *xdrs, remote_auth_list_ret *objp)
{
char **objp_cpp0 = (char **) (void *) &objp->types.types_val;
diff --git a/qemud/remote_protocol.h b/qemud/remote_protocol.h
index 9d67e58..7201720 100644
--- a/qemud/remote_protocol.h
+++ b/qemud/remote_protocol.h
@@ -28,6 +28,7 @@ typedef remote_nonnull_string *remote_string;
#define REMOTE_CPUMAPS_MAX 16384
#define REMOTE_MIGRATE_COOKIE_MAX 256
#define REMOTE_NETWORK_NAME_LIST_MAX 256
+#define REMOTE_INTERFACE_NAME_LIST_MAX 256
#define REMOTE_STORAGE_POOL_NAME_LIST_MAX 256
#define REMOTE_STORAGE_VOL_NAME_LIST_MAX 1024
#define REMOTE_NODE_DEVICE_NAME_LIST_MAX 16384
@@ -44,6 +45,8 @@ typedef remote_nonnull_string *remote_string;
typedef char remote_uuid[VIR_UUID_BUFLEN];
+typedef char remote_mac[VIR_MAC_BUFLEN];
+
struct remote_nonnull_domain {
remote_nonnull_string name;
remote_uuid uuid;
@@ -57,6 +60,12 @@ struct remote_nonnull_network {
};
typedef struct remote_nonnull_network remote_nonnull_network;
+struct remote_nonnull_interface {
+ remote_nonnull_string name;
+ remote_mac mac;
+};
+typedef struct remote_nonnull_interface remote_nonnull_interface;
+
struct remote_nonnull_storage_pool {
remote_nonnull_string name;
remote_uuid uuid;
@@ -822,6 +831,83 @@ struct remote_network_set_autostart_args {
};
typedef struct remote_network_set_autostart_args remote_network_set_autostart_args;
+struct remote_num_of_interfaces_ret {
+ int num;
+};
+typedef struct remote_num_of_interfaces_ret remote_num_of_interfaces_ret;
+
+struct remote_list_interfaces_args {
+ int maxnames;
+};
+typedef struct remote_list_interfaces_args remote_list_interfaces_args;
+
+struct remote_list_interfaces_ret {
+ struct {
+ u_int names_len;
+ remote_nonnull_string *names_val;
+ } names;
+};
+typedef struct remote_list_interfaces_ret remote_list_interfaces_ret;
+
+struct remote_interface_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+typedef struct remote_interface_lookup_by_name_args
remote_interface_lookup_by_name_args;
+
+struct remote_interface_lookup_by_name_ret {
+ remote_nonnull_interface interface;
+};
+typedef struct remote_interface_lookup_by_name_ret remote_interface_lookup_by_name_ret;
+
+struct remote_interface_lookup_by_mac_args {
+ remote_mac mac;
+};
+typedef struct remote_interface_lookup_by_mac_args remote_interface_lookup_by_mac_args;
+
+struct remote_interface_lookup_by_mac_ret {
+ remote_nonnull_interface interface;
+};
+typedef struct remote_interface_lookup_by_mac_ret remote_interface_lookup_by_mac_ret;
+
+struct remote_interface_get_xml_desc_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+typedef struct remote_interface_get_xml_desc_args remote_interface_get_xml_desc_args;
+
+struct remote_interface_get_xml_desc_ret {
+ remote_nonnull_string xml;
+};
+typedef struct remote_interface_get_xml_desc_ret remote_interface_get_xml_desc_ret;
+
+struct remote_interface_define_xml_args {
+ remote_nonnull_string xml;
+ int flags;
+};
+typedef struct remote_interface_define_xml_args remote_interface_define_xml_args;
+
+struct remote_interface_define_xml_ret {
+ remote_nonnull_interface interface;
+};
+typedef struct remote_interface_define_xml_ret remote_interface_define_xml_ret;
+
+struct remote_interface_undefine_args {
+ remote_nonnull_interface interface;
+};
+typedef struct remote_interface_undefine_args remote_interface_undefine_args;
+
+struct remote_interface_create_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+typedef struct remote_interface_create_args remote_interface_create_args;
+
+struct remote_interface_destroy_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+typedef struct remote_interface_destroy_args remote_interface_destroy_args;
+
struct remote_auth_list_ret {
struct {
u_int types_len;
@@ -1415,6 +1501,15 @@ enum remote_procedure {
REMOTE_PROC_NODE_GET_SECURITY_MODEL = 122,
REMOTE_PROC_NODE_DEVICE_CREATE_XML = 123,
REMOTE_PROC_NODE_DEVICE_DESTROY = 124,
+ REMOTE_PROC_NUM_OF_INTERFACES = 126,
+ REMOTE_PROC_LIST_INTERFACES = 127,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME = 128,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC = 129,
+ REMOTE_PROC_INTERFACE_GET_XML_DESC = 130,
+ REMOTE_PROC_INTERFACE_DEFINE_XML = 131,
+ REMOTE_PROC_INTERFACE_UNDEFINE = 132,
+ REMOTE_PROC_INTERFACE_CREATE = 133,
+ REMOTE_PROC_INTERFACE_DESTROY = 134,
};
typedef enum remote_procedure remote_procedure;
@@ -1448,8 +1543,10 @@ typedef struct remote_message_header remote_message_header;
extern bool_t xdr_remote_nonnull_string (XDR *, remote_nonnull_string*);
extern bool_t xdr_remote_string (XDR *, remote_string*);
extern bool_t xdr_remote_uuid (XDR *, remote_uuid);
+extern bool_t xdr_remote_mac (XDR *, remote_mac);
extern bool_t xdr_remote_nonnull_domain (XDR *, remote_nonnull_domain*);
extern bool_t xdr_remote_nonnull_network (XDR *, remote_nonnull_network*);
+extern bool_t xdr_remote_nonnull_interface (XDR *, remote_nonnull_interface*);
extern bool_t xdr_remote_nonnull_storage_pool (XDR *, remote_nonnull_storage_pool*);
extern bool_t xdr_remote_nonnull_storage_vol (XDR *, remote_nonnull_storage_vol*);
extern bool_t xdr_remote_nonnull_node_device (XDR *, remote_nonnull_node_device*);
@@ -1573,6 +1670,20 @@ extern bool_t xdr_remote_network_get_bridge_name_ret (XDR *,
remote_network_get
extern bool_t xdr_remote_network_get_autostart_args (XDR *,
remote_network_get_autostart_args*);
extern bool_t xdr_remote_network_get_autostart_ret (XDR *,
remote_network_get_autostart_ret*);
extern bool_t xdr_remote_network_set_autostart_args (XDR *,
remote_network_set_autostart_args*);
+extern bool_t xdr_remote_num_of_interfaces_ret (XDR *, remote_num_of_interfaces_ret*);
+extern bool_t xdr_remote_list_interfaces_args (XDR *, remote_list_interfaces_args*);
+extern bool_t xdr_remote_list_interfaces_ret (XDR *, remote_list_interfaces_ret*);
+extern bool_t xdr_remote_interface_lookup_by_name_args (XDR *,
remote_interface_lookup_by_name_args*);
+extern bool_t xdr_remote_interface_lookup_by_name_ret (XDR *,
remote_interface_lookup_by_name_ret*);
+extern bool_t xdr_remote_interface_lookup_by_mac_args (XDR *,
remote_interface_lookup_by_mac_args*);
+extern bool_t xdr_remote_interface_lookup_by_mac_ret (XDR *,
remote_interface_lookup_by_mac_ret*);
+extern bool_t xdr_remote_interface_get_xml_desc_args (XDR *,
remote_interface_get_xml_desc_args*);
+extern bool_t xdr_remote_interface_get_xml_desc_ret (XDR *,
remote_interface_get_xml_desc_ret*);
+extern bool_t xdr_remote_interface_define_xml_args (XDR *,
remote_interface_define_xml_args*);
+extern bool_t xdr_remote_interface_define_xml_ret (XDR *,
remote_interface_define_xml_ret*);
+extern bool_t xdr_remote_interface_undefine_args (XDR *,
remote_interface_undefine_args*);
+extern bool_t xdr_remote_interface_create_args (XDR *, remote_interface_create_args*);
+extern bool_t xdr_remote_interface_destroy_args (XDR *,
remote_interface_destroy_args*);
extern bool_t xdr_remote_auth_list_ret (XDR *, remote_auth_list_ret*);
extern bool_t xdr_remote_auth_sasl_init_ret (XDR *, remote_auth_sasl_init_ret*);
extern bool_t xdr_remote_auth_sasl_start_args (XDR *, remote_auth_sasl_start_args*);
@@ -1662,8 +1773,10 @@ extern bool_t xdr_remote_message_header (XDR *,
remote_message_header*);
extern bool_t xdr_remote_nonnull_string ();
extern bool_t xdr_remote_string ();
extern bool_t xdr_remote_uuid ();
+extern bool_t xdr_remote_mac ();
extern bool_t xdr_remote_nonnull_domain ();
extern bool_t xdr_remote_nonnull_network ();
+extern bool_t xdr_remote_nonnull_interface ();
extern bool_t xdr_remote_nonnull_storage_pool ();
extern bool_t xdr_remote_nonnull_storage_vol ();
extern bool_t xdr_remote_nonnull_node_device ();
@@ -1787,6 +1900,20 @@ extern bool_t xdr_remote_network_get_bridge_name_ret ();
extern bool_t xdr_remote_network_get_autostart_args ();
extern bool_t xdr_remote_network_get_autostart_ret ();
extern bool_t xdr_remote_network_set_autostart_args ();
+extern bool_t xdr_remote_num_of_interfaces_ret ();
+extern bool_t xdr_remote_list_interfaces_args ();
+extern bool_t xdr_remote_list_interfaces_ret ();
+extern bool_t xdr_remote_interface_lookup_by_name_args ();
+extern bool_t xdr_remote_interface_lookup_by_name_ret ();
+extern bool_t xdr_remote_interface_lookup_by_mac_args ();
+extern bool_t xdr_remote_interface_lookup_by_mac_ret ();
+extern bool_t xdr_remote_interface_get_xml_desc_args ();
+extern bool_t xdr_remote_interface_get_xml_desc_ret ();
+extern bool_t xdr_remote_interface_define_xml_args ();
+extern bool_t xdr_remote_interface_define_xml_ret ();
+extern bool_t xdr_remote_interface_undefine_args ();
+extern bool_t xdr_remote_interface_create_args ();
+extern bool_t xdr_remote_interface_destroy_args ();
extern bool_t xdr_remote_auth_list_ret ();
extern bool_t xdr_remote_auth_sasl_init_ret ();
extern bool_t xdr_remote_auth_sasl_start_args ();
diff --git a/qemud/remote_protocol.x b/qemud/remote_protocol.x
index 2c79949..6abc908 100644
--- a/qemud/remote_protocol.x
+++ b/qemud/remote_protocol.x
@@ -79,6 +79,9 @@ const REMOTE_MIGRATE_COOKIE_MAX = 256;
/* Upper limit on lists of network names. */
const REMOTE_NETWORK_NAME_LIST_MAX = 256;
+/* Upper limit on lists of interface names. */
+const REMOTE_INTERFACE_NAME_LIST_MAX = 256;
+
/* Upper limit on lists of storage pool names. */
const REMOTE_STORAGE_POOL_NAME_LIST_MAX = 256;
@@ -133,6 +136,9 @@ const REMOTE_SECURITY_DOI_MAX = VIR_SECURITY_DOI_BUFLEN;
/* UUID. VIR_UUID_BUFLEN definition comes from libvirt.h */
typedef opaque remote_uuid[VIR_UUID_BUFLEN];
+/* MAC. VIR_MAC_BUFLEN definition comes from libvirt.h */
+typedef opaque remote_mac[VIR_MAC_BUFLEN];
+
/* A domain which may not be NULL. */
struct remote_nonnull_domain {
remote_nonnull_string name;
@@ -146,6 +152,12 @@ struct remote_nonnull_network {
remote_uuid uuid;
};
+/* An interface which may not be NULL. */
+struct remote_nonnull_interface {
+ remote_nonnull_string name;
+ remote_mac mac;
+};
+
/* A storage pool which may not be NULL. */
struct remote_nonnull_storage_pool {
remote_nonnull_string name;
@@ -770,6 +782,71 @@ struct remote_network_set_autostart_args {
};
+/* Interface calls: */
+
+struct remote_num_of_interfaces_ret {
+ int num;
+};
+
+struct remote_list_interfaces_args {
+ int maxnames;
+};
+
+struct remote_list_interfaces_ret {
+ remote_nonnull_string names<REMOTE_INTERFACE_NAME_LIST_MAX>;
+};
+
+struct remote_interface_lookup_by_name_args {
+ remote_nonnull_string name;
+};
+
+struct remote_interface_lookup_by_name_ret {
+ remote_nonnull_interface interface;
+};
+
+struct remote_interface_lookup_by_mac_args {
+ remote_mac mac;
+};
+
+struct remote_interface_lookup_by_mac_ret {
+ remote_nonnull_interface interface;
+};
+
+struct remote_interface_get_xml_desc_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+
+struct remote_interface_get_xml_desc_ret {
+ remote_nonnull_string xml;
+};
+
+struct remote_interface_define_xml_args {
+ remote_nonnull_string xml;
+ int flags;
+};
+
+struct remote_interface_define_xml_ret {
+ remote_nonnull_interface interface;
+};
+
+struct remote_interface_undefine_args {
+ remote_nonnull_interface interface;
+};
+
+struct remote_interface_create_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+
+struct remote_interface_destroy_args {
+ remote_nonnull_interface interface;
+ int flags;
+};
+
+
+/* Auth calls: */
+
struct remote_auth_list_ret {
remote_auth_type types<REMOTE_AUTH_TYPE_LIST_MAX>;
};
@@ -1286,7 +1363,18 @@ enum remote_procedure {
REMOTE_PROC_NODE_GET_SECURITY_MODEL = 122,
REMOTE_PROC_NODE_DEVICE_CREATE_XML = 123,
- REMOTE_PROC_NODE_DEVICE_DESTROY = 124
+ REMOTE_PROC_NODE_DEVICE_DESTROY = 124,
+
+ REMOTE_PROC_NUM_OF_INTERFACES = 126,
+ REMOTE_PROC_LIST_INTERFACES = 127,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME = 128,
+ REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC = 129,
+ REMOTE_PROC_INTERFACE_GET_XML_DESC = 130,
+ REMOTE_PROC_INTERFACE_DEFINE_XML = 131,
+ REMOTE_PROC_INTERFACE_UNDEFINE = 132,
+ REMOTE_PROC_INTERFACE_CREATE = 133,
+ REMOTE_PROC_INTERFACE_DESTROY = 134
+
};
/* Custom RPC structure. */
diff --git a/src/datatypes.c b/src/datatypes.c
index b1013f2..8593e2b 100644
--- a/src/datatypes.c
+++ b/src/datatypes.c
@@ -67,6 +67,20 @@ virNetworkFreeName(virNetworkPtr network, const char *name
ATTRIBUTE_UNUSED)
}
/**
+ * virInterfaceFreeName:
+ * @interface: a interface object
+ *
+ * Destroy the interface object, this is just used by the interface hash callback.
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+static int
+virInterfaceFreeName(virInterfacePtr interface, const char *name ATTRIBUTE_UNUSED)
+{
+ return (virUnrefInterface(interface));
+}
+
+/**
* virStoragePoolFreeName:
* @pool: a pool object
*
@@ -119,12 +133,16 @@ virGetConnect(void) {
ret->networkDriver = NULL;
ret->privateData = NULL;
ret->networkPrivateData = NULL;
+ ret->interfacePrivateData = NULL;
ret->domains = virHashCreate(20);
if (ret->domains == NULL)
goto failed;
ret->networks = virHashCreate(20);
if (ret->networks == NULL)
goto failed;
+ ret->interfaces = virHashCreate(20);
+ if (ret->interfaces == NULL)
+ goto failed;
ret->storagePools = virHashCreate(20);
if (ret->storagePools == NULL)
goto failed;
@@ -144,6 +162,8 @@ failed:
virHashFree(ret->domains, (virHashDeallocator) virDomainFreeName);
if (ret->networks != NULL)
virHashFree(ret->networks, (virHashDeallocator) virNetworkFreeName);
+ if (ret->interfaces != NULL)
+ virHashFree(ret->interfaces, (virHashDeallocator) virInterfaceFreeName);
if (ret->storagePools != NULL)
virHashFree(ret->storagePools, (virHashDeallocator)
virStoragePoolFreeName);
if (ret->storageVols != NULL)
@@ -173,6 +193,8 @@ virReleaseConnect(virConnectPtr conn) {
virHashFree(conn->domains, (virHashDeallocator) virDomainFreeName);
if (conn->networks != NULL)
virHashFree(conn->networks, (virHashDeallocator) virNetworkFreeName);
+ if (conn->interfaces != NULL)
+ virHashFree(conn->interfaces, (virHashDeallocator) virInterfaceFreeName);
if (conn->storagePools != NULL)
virHashFree(conn->storagePools, (virHashDeallocator) virStoragePoolFreeName);
if (conn->storageVols != NULL)
@@ -488,6 +510,138 @@ virUnrefNetwork(virNetworkPtr network) {
/**
+ * virGetInterface:
+ * @conn: the hypervisor connection
+ * @name: pointer to the interface name
+ * @mac: pointer to the mac
+ *
+ * Lookup if the interface is already registered for that connection,
+ * if yes return a new pointer to it, if no allocate a new structure,
+ * and register it in the table. In any case a corresponding call to
+ * virUnrefInterface() is needed to not leak data.
+ *
+ * Returns a pointer to the interface, or NULL in case of failure
+ */
+virInterfacePtr
+virGetInterface(virConnectPtr conn, const char *name, const unsigned char *mac) {
+ virInterfacePtr ret = NULL;
+
+ if ((!VIR_IS_CONNECT(conn)) || (name == NULL) || (mac == NULL)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ return(NULL);
+ }
+ virMutexLock(&conn->lock);
+
+ /* TODO search by MAC first as they are better differentiators */
+
+ ret = (virInterfacePtr) virHashLookup(conn->interfaces, name);
+ /* TODO check the MAC */
+ if (ret == NULL) {
+ if (VIR_ALLOC(ret) < 0) {
+ virReportOOMError(conn);
+ goto error;
+ }
+ ret->name = strdup(name);
+ if (ret->name == NULL) {
+ virReportOOMError(conn);
+ goto error;
+ }
+ ret->magic = VIR_INTERFACE_MAGIC;
+ ret->conn = conn;
+ if (mac != NULL)
+ memcpy(&(ret->mac[0]), mac, VIR_MAC_BUFLEN);
+
+ if (virHashAddEntry(conn->interfaces, name, ret) < 0) {
+ virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+ _("failed to add interface to connection hash
table"));
+ goto error;
+ }
+ conn->refs++;
+ }
+ ret->refs++;
+ virMutexUnlock(&conn->lock);
+ return(ret);
+
+ error:
+ virMutexUnlock(&conn->lock);
+ if (ret != NULL) {
+ VIR_FREE(ret->name);
+ VIR_FREE(ret);
+ }
+ return(NULL);
+}
+
+/**
+ * virReleaseInterface:
+ * @interface: the interface to release
+ *
+ * Unconditionally release all memory associated with a interface.
+ * The conn.lock mutex must be held prior to calling this, and will
+ * be released prior to this returning. The interface obj must not
+ * be used once this method returns.
+ *
+ * It will also unreference the associated connection object,
+ * which may also be released if its ref count hits zero.
+ */
+static void
+virReleaseInterface(virInterfacePtr interface) {
+ virConnectPtr conn = interface->conn;
+ DEBUG("release interface %p %s", interface, interface->name);
+
+ /* TODO search by MAC first as they are better differenciators */
+ if (virHashRemoveEntry(conn->interfaces, interface->name, NULL) < 0)
+ virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+ _("interface missing from connection hash table"));
+
+ interface->magic = -1;
+ VIR_FREE(interface->name);
+ VIR_FREE(interface);
+
+ DEBUG("unref connection %p %d", conn, conn->refs);
+ conn->refs--;
+ if (conn->refs == 0) {
+ virReleaseConnect(conn);
+ /* Already unlocked mutex */
+ return;
+ }
+
+ virMutexUnlock(&conn->lock);
+}
+
+
+/**
+ * virUnrefInterface:
+ * @interface: the interface to unreference
+ *
+ * Unreference the interface. If the use count drops to zero, the structure is
+ * actually freed.
+ *
+ * Returns the reference count or -1 in case of failure.
+ */
+int
+virUnrefInterface(virInterfacePtr interface) {
+ int refs;
+
+ if (!VIR_IS_CONNECTED_INTERFACE(interface)) {
+ virLibConnError(NULL, VIR_ERR_INVALID_ARG, __FUNCTION__);
+ return(-1);
+ }
+ virMutexLock(&interface->conn->lock);
+ DEBUG("unref interface %p %s %d", interface, interface->name,
interface->refs);
+ interface->refs--;
+ refs = interface->refs;
+ if (refs == 0) {
+ virReleaseInterface(interface);
+ /* Already unlocked mutex */
+ return (0);
+ }
+
+ virMutexUnlock(&interface->conn->lock);
+ return (refs);
+}
+
+
+/**
* virGetStoragePool:
* @conn: the hypervisor connection
* @name: pointer to the storage pool name
diff --git a/src/datatypes.h b/src/datatypes.h
index deac9df..e56755b 100644
--- a/src/datatypes.h
+++ b/src/datatypes.h
@@ -145,6 +145,7 @@ struct _virConnect {
virHashTablePtr domains; /* hash table for known domains */
virHashTablePtr networks; /* hash table for known domains */
+ virHashTablePtr interfaces; /* hash table for known interfaces */
virHashTablePtr storagePools;/* hash table for known storage pools */
virHashTablePtr storageVols;/* hash table for known storage vols */
virHashTablePtr nodeDevices; /* hash table for known node devices */
@@ -250,6 +251,11 @@ virNetworkPtr virGetNetwork(virConnectPtr conn,
const unsigned char *uuid);
int virUnrefNetwork(virNetworkPtr network);
+virInterfacePtr virGetInterface(virConnectPtr conn,
+ const char *name,
+ const unsigned char *mac);
+int virUnrefInterface(virInterfacePtr interface);
+
virStoragePoolPtr virGetStoragePool(virConnectPtr conn,
const char *name,
const unsigned char *uuid);
diff --git a/src/libvirt.c b/src/libvirt.c
index 4bd85a7..15f107a 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -5958,18 +5958,8 @@ virInterfaceFree(virInterfacePtr interface)
virLibInterfaceError(NULL, VIR_ERR_INVALID_INTERFACE, __FUNCTION__);
return (-1);
}
-#if 0
- /*
- * FIXME: This needs to be uncommented when the stubs are replaced
- * with actual functionality.
- */
-
if (virUnrefInterface(interface) < 0)
return (-1);
-#else
- interface->refs--;
-#endif
-
return(0);
}
diff --git a/src/remote_internal.c b/src/remote_internal.c
index 24226e5..6bc2b9c 100644
--- a/src/remote_internal.c
+++ b/src/remote_internal.c
@@ -211,11 +211,13 @@ static void errorf (virConnectPtr conn, virErrorNumber code,
static void server_error (virConnectPtr conn, remote_error *err);
static virDomainPtr get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain
domain);
static virNetworkPtr get_nonnull_network (virConnectPtr conn, remote_nonnull_network
network);
+static virInterfacePtr get_nonnull_interface (virConnectPtr conn,
remote_nonnull_interface interface);
static virStoragePoolPtr get_nonnull_storage_pool (virConnectPtr conn,
remote_nonnull_storage_pool pool);
static virStorageVolPtr get_nonnull_storage_vol (virConnectPtr conn,
remote_nonnull_storage_vol vol);
static virNodeDevicePtr get_nonnull_node_device (virConnectPtr conn,
remote_nonnull_node_device dev);
static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr
net_src);
+static void make_nonnull_interface (remote_nonnull_interface *interface_dst,
virInterfacePtr interface_src);
static void make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst,
virStoragePoolPtr vol_src);
static void make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst,
virStorageVolPtr vol_src);
void remoteDomainEventFired(int watch, int fd, int event, void *data);
@@ -3684,6 +3686,325 @@ done:
/*----------------------------------------------------------------------*/
static virDrvOpenStatus
+remoteInterfaceOpen (virConnectPtr conn,
+ virConnectAuthPtr auth,
+ int flags)
+{
+ if (inside_daemon)
+ return VIR_DRV_OPEN_DECLINED;
+
+ if (conn &&
+ conn->driver &&
+ STREQ (conn->driver->name, "remote")) {
+ struct private_data *priv;
+
+ /* If we're here, the remote driver is already
+ * in use due to a) a QEMU uri, or b) a remote
+ * URI. So we can re-use existing connection
+ */
+ priv = conn->privateData;
+ remoteDriverLock(priv);
+ priv->localUses++;
+ conn->interfacePrivateData = priv;
+ remoteDriverUnlock(priv);
+ return VIR_DRV_OPEN_SUCCESS;
+ } else {
+ /* Using a non-remote driver, so we need to open a
+ * new connection for interface APIs, forcing it to
+ * use the UNIX transport. This handles Xen driver
+ * which doesn't have its own impl of the interface APIs.
+ */
+ struct private_data *priv;
+ int ret;
+ ret = remoteOpenSecondaryDriver(conn,
+ auth,
+ flags,
+ &priv);
+ if (ret == VIR_DRV_OPEN_SUCCESS)
+ conn->interfacePrivateData = priv;
+ return ret;
+ }
+}
+
+static int
+remoteInterfaceClose (virConnectPtr conn)
+{
+ int rv = 0;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+ priv->localUses--;
+ if (!priv->localUses) {
+ rv = doRemoteClose(conn, priv);
+ conn->interfacePrivateData = NULL;
+ remoteDriverUnlock(priv);
+ virMutexDestroy(&priv->lock);
+ VIR_FREE(priv);
+ }
+ if (priv)
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNumOfInterfaces (virConnectPtr conn)
+{
+ int rv = -1;
+ remote_num_of_interfaces_ret ret;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_INTERFACES,
+ (xdrproc_t) xdr_void, (char *) NULL,
+ (xdrproc_t) xdr_remote_num_of_interfaces_ret, (char *) &ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteListInterfaces (virConnectPtr conn, char **const names, int maxnames)
+{
+ int rv = -1;
+ int i;
+ remote_list_interfaces_args args;
+ remote_list_interfaces_ret ret;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ if (maxnames > REMOTE_INTERFACE_NAME_LIST_MAX) {
+ errorf (conn, VIR_ERR_RPC,
+ _("too many remote interfaces: %d > %d"),
+ maxnames, REMOTE_INTERFACE_NAME_LIST_MAX);
+ goto done;
+ }
+ args.maxnames = maxnames;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_LIST_INTERFACES,
+ (xdrproc_t) xdr_remote_list_interfaces_args, (char *) &args,
+ (xdrproc_t) xdr_remote_list_interfaces_ret, (char *) &ret) == -1)
+ goto done;
+
+ if (ret.names.names_len > maxnames) {
+ errorf (conn, VIR_ERR_RPC,
+ _("too many remote interfaces: %d > %d"),
+ ret.names.names_len, maxnames);
+ goto cleanup;
+ }
+
+ /* This call is caller-frees (although that isn't clear from
+ * the documentation). However xdr_free will free up both the
+ * names and the list of pointers, so we have to strdup the
+ * names here.
+ */
+ for (i = 0; i < ret.names.names_len; ++i)
+ names[i] = strdup (ret.names.names_val[i]);
+
+ rv = ret.names.names_len;
+
+cleanup:
+ xdr_free ((xdrproc_t) xdr_remote_list_interfaces_ret, (char *) &ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virInterfacePtr
+remoteInterfaceLookupByName (virConnectPtr conn,
+ const char *name)
+{
+ virInterfacePtr interface = NULL;
+ remote_interface_lookup_by_name_args args;
+ remote_interface_lookup_by_name_ret ret;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ args.name = (char *) name;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME,
+ (xdrproc_t) xdr_remote_interface_lookup_by_name_args, (char *) &args,
+ (xdrproc_t) xdr_remote_interface_lookup_by_name_ret, (char *) &ret) ==
-1)
+ goto done;
+
+ interface = get_nonnull_interface (conn, ret.interface);
+ xdr_free ((xdrproc_t) &xdr_remote_interface_lookup_by_name_ret, (char *)
&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return interface;
+}
+
+static virInterfacePtr
+remoteInterfaceLookupByMAC (virConnectPtr conn,
+ const unsigned char *mac)
+{
+ virInterfacePtr interface = NULL;
+ remote_interface_lookup_by_mac_args args;
+ remote_interface_lookup_by_mac_ret ret;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ memcpy (args.mac, mac, VIR_MAC_BUFLEN);
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC,
+ (xdrproc_t) xdr_remote_interface_lookup_by_mac_args, (char *) &args,
+ (xdrproc_t) xdr_remote_interface_lookup_by_mac_ret, (char *) &ret) ==
-1)
+ goto done;
+
+ interface = get_nonnull_interface (conn, ret.interface);
+ xdr_free ((xdrproc_t) &xdr_remote_interface_lookup_by_mac_ret, (char *)
&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return interface;
+}
+
+static char *
+remoteInterfaceGetXMLDesc (virInterfacePtr interface,
+ int flags)
+{
+ char *rv = NULL;
+ remote_interface_get_xml_desc_args args;
+ remote_interface_get_xml_desc_ret ret;
+ struct private_data *priv = interface->conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface (&args.interface, interface);
+ args.flags = flags;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (interface->conn, priv, 0, REMOTE_PROC_INTERFACE_GET_XML_DESC,
+ (xdrproc_t) xdr_remote_interface_get_xml_desc_args, (char *) &args,
+ (xdrproc_t) xdr_remote_interface_get_xml_desc_ret, (char *) &ret) ==
-1)
+ goto done;
+
+ /* Caller frees. */
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virInterfacePtr
+remoteInterfaceDefineXML (virConnectPtr conn,
+ const char *xmlDesc,
+ int flags)
+{
+ virInterfacePtr interface = NULL;
+ remote_interface_define_xml_args args;
+ remote_interface_define_xml_ret ret;
+ struct private_data *priv = conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ args.xml = (char *) xmlDesc;
+ args.flags = flags;
+
+ memset (&ret, 0, sizeof ret);
+ if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_DEFINE_XML,
+ (xdrproc_t) xdr_remote_interface_define_xml_args, (char *) &args,
+ (xdrproc_t) xdr_remote_interface_define_xml_ret, (char *) &ret) == -1)
+ goto done;
+
+ interface = get_nonnull_interface (conn, ret.interface);
+ xdr_free ((xdrproc_t) &xdr_remote_interface_define_xml_ret, (char *) &ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return interface;
+}
+
+static int
+remoteInterfaceUndefine (virInterfacePtr interface)
+{
+ int rv = -1;
+ remote_interface_undefine_args args;
+ struct private_data *priv = interface->conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface (&args.interface, interface);
+
+ if (call (interface->conn, priv, 0, REMOTE_PROC_INTERFACE_UNDEFINE,
+ (xdrproc_t) xdr_remote_interface_undefine_args, (char *) &args,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteInterfaceCreate (virInterfacePtr interface,
+ int flags)
+{
+ int rv = -1;
+ remote_interface_create_args args;
+ struct private_data *priv = interface->conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface (&args.interface, interface);
+ args.flags = flags;
+
+ if (call (interface->conn, priv, 0, REMOTE_PROC_INTERFACE_CREATE,
+ (xdrproc_t) xdr_remote_interface_create_args, (char *) &args,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteInterfaceDestroy (virInterfacePtr interface,
+ int flags)
+{
+ int rv = -1;
+ remote_interface_destroy_args args;
+ struct private_data *priv = interface->conn->interfacePrivateData;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface (&args.interface, interface);
+ args.flags = flags;
+
+ if (call (interface->conn, priv, 0, REMOTE_PROC_INTERFACE_DESTROY,
+ (xdrproc_t) xdr_remote_interface_destroy_args, (char *) &args,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/*----------------------------------------------------------------------*/
+
+static virDrvOpenStatus
remoteStorageOpen (virConnectPtr conn,
virConnectAuthPtr auth,
int flags)
@@ -6851,6 +7172,12 @@ get_nonnull_network (virConnectPtr conn, remote_nonnull_network
network)
return virGetNetwork (conn, network.name, BAD_CAST network.uuid);
}
+static virInterfacePtr
+get_nonnull_interface (virConnectPtr conn, remote_nonnull_interface interface)
+{
+ return virGetInterface (conn, interface.name, BAD_CAST interface.mac);
+}
+
static virStoragePoolPtr
get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool)
{
@@ -6886,6 +7213,14 @@ make_nonnull_network (remote_nonnull_network *net_dst,
virNetworkPtr net_src)
}
static void
+make_nonnull_interface (remote_nonnull_interface *interface_dst,
+ virInterfacePtr interface_src)
+{
+ interface_dst->name = interface_src->name;
+ memcpy (interface_dst->mac, interface_src->mac, VIR_MAC_BUFLEN);
+}
+
+static void
make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr
pool_src)
{
pool_dst->name = pool_src->name;
@@ -6996,6 +7331,21 @@ static virNetworkDriver network_driver = {
.networkSetAutostart = remoteNetworkSetAutostart,
};
+static virInterfaceDriver interface_driver = {
+ .name = "remote",
+ .open = remoteInterfaceOpen,
+ .close = remoteInterfaceClose,
+ .numOfInterfaces = remoteNumOfInterfaces,
+ .listInterfaces = remoteListInterfaces,
+ .interfaceLookupByName = remoteInterfaceLookupByName,
+ .interfaceLookupByMAC = remoteInterfaceLookupByMAC,
+ .interfaceGetXMLDesc = remoteInterfaceGetXMLDesc,
+ .interfaceDefineXML = remoteInterfaceDefineXML,
+ .interfaceUndefine = remoteInterfaceUndefine,
+ .interfaceCreate = remoteInterfaceCreate,
+ .interfaceDestroy = remoteInterfaceDestroy,
+};
+
static virStorageDriver storage_driver = {
.name = "remote",
.open = remoteStorageOpen,
@@ -7067,6 +7417,7 @@ remoteRegister (void)
{
if (virRegisterDriver (&driver) == -1) return -1;
if (virRegisterNetworkDriver (&network_driver) == -1) return -1;
+ if (virRegisterInterfaceDriver (&interface_driver) == -1) return -1;
if (virRegisterStorageDriver (&storage_driver) == -1) return -1;
if (virRegisterDeviceMonitor (&dev_monitor) == -1) return -1;
#ifdef WITH_LIBVIRTD
--
1.6.0.6
3:07 p.m.
New subject: [libvirt] [PATCH 4/5] Publish the new Interface config API beginning with 0.6.4.
---
src/libvirt_public.syms | 20 ++++++++++++++++++++
1 files changed, 20 insertions(+), 0 deletions(-)
diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms
index b8f9128..cd369cb 100644
--- a/src/libvirt_public.syms
+++ b/src/libvirt_public.syms
@@ -264,4 +264,24 @@ LIBVIRT_0.6.3 {
virNodeDeviceDestroy;
} LIBVIRT_0.6.1;
+LIBVIRT_0.6.4 {
+ global:
+ virInterfaceGetConnect;
+ virConnectNumOfInterfaces;
+ virConnectListInterfaces;
+ virInterfaceLookupByName;
+ virInterfaceLookupByMAC;
+ virInterfaceLookupByMACString;
+ virInterfaceGetName;
+ virInterfaceGetMAC;
+ virInterfaceGetMACString;
+ virInterfaceGetXMLDesc;
+ virInterfaceRef;
+ virInterfaceFree;
+ virInterfaceDefineXML;
+ virInterfaceUndefine;
+ virInterfaceCreate;
+ virInterfaceDestroy;
+
+} LIBVIRT_0.6.3;
# .... define new API here using predicted next version number ....
--
1.6.0.6
3:07 p.m.
New subject: [libvirt] [PATCH 5/5] Use pkg_config in configure.in to detect presence of libnetcf and
From: Laine Stump <laine(a)redhat.com>
---
configure.in | 35 ++++++++++++++++++++++++++++++++---
src/Makefile.am | 5 +++++
2 files changed, 37 insertions(+), 3 deletions(-)
diff --git a/configure.in b/configure.in
index 1cdb64c..4ce4342 100644
--- a/configure.in
+++ b/configure.in
@@ -28,6 +28,7 @@ GNUTLS_REQUIRED="1.0.25"
AVAHI_REQUIRED="0.6.0"
POLKIT_REQUIRED="0.6"
PARTED_REQUIRED="1.8.0"
+NETCF_REQUIRED="0.0.1"
dnl Checks for C compiler.
AC_PROG_CC
@@ -789,9 +790,31 @@ if test "$with_qemu:$with_lxc:$with_network" !=
"no:no:no"; then
fi
AM_CONDITIONAL([WITH_BRIDGE], [test "$with_bridge" = "yes"])
-dnl
-dnl Storage driver checks
-dnl
+dnl netcf library
+AC_ARG_WITH([netcf],
+[ --with-netcf libnetcf support to configure physical host network interfaces],
+[], [with_netcf=check])
+
+NETCF_CFLAGS=
+NETCF_LIBS=
+if test "$with_netcf" = "yes" -o "$with_netcf" =
"check"; then
+ PKG_CHECK_MODULES(NETCF, netcf >= $NETCF_REQUIRED,
+ [with_netcf=yes], [
+ if test "$with_netcf" = "check" ; then
+ with_netcf=no
+ else
+ AC_MSG_ERROR(
+ [You must install libnetcf >= $NETCF_REQUIRED to compile libvirt])
+ fi
+ ])
+ if test "$with_netcf" = "yes" ; then
+ AC_DEFINE_UNQUOTED([WITH_NETCF], 1,
+ [whether libnetcf is available to configure physical host network interfaces])
+ fi
+fi
+AM_CONDITIONAL([WITH_NETCF], [test "$with_netcf" = "yes"])
+AC_SUBST([NETCF_CFLAGS])
+AC_SUBST([NETCF_LIBS])
AC_ARG_WITH([storage-fs],
[ --with-storage-fs with FileSystem backend for the storage driver
(on)],[],[with_storage_fs=check])
@@ -1376,6 +1399,7 @@ AC_MSG_NOTICE([ Test: $with_test])
AC_MSG_NOTICE([ Remote: $with_remote])
AC_MSG_NOTICE([ Network: $with_network])
AC_MSG_NOTICE([Libvirtd: $with_libvirtd])
+AC_MSG_NOTICE([ netcf: $with_netcf])
AC_MSG_NOTICE([])
AC_MSG_NOTICE([Storage Drivers])
AC_MSG_NOTICE([])
@@ -1443,6 +1467,11 @@ AC_MSG_NOTICE([ devkit: $DEVKIT_CFLAGS $DEVKIT_LIBS])
else
AC_MSG_NOTICE([ devkit: no])
fi
+if test "$with_netcf" = "yes" ; then
+AC_MSG_NOTICE([ netcf: $NETCF_CFLAGS $NETCF_LIBS])
+else
+AC_MSG_NOTICE([ netcf: no])
+fi
AC_MSG_NOTICE([])
AC_MSG_NOTICE([Test suite])
AC_MSG_NOTICE([])
diff --git a/src/Makefile.am b/src/Makefile.am
index fd692b4..7d7ef74 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -351,6 +351,11 @@ endif
libvirt_driver_network_la_SOURCES = $(NETWORK_DRIVER_SOURCES)
endif
+if WITH_NETCF
+libvirt_driver_interface_la_CFLAGS = $(NETCF_CFLAGS)
+libvirt_driver_interface_la_LDFLAGS = $(NETCF_LIBS)
+endif
+
# Needed to keep automake quiet about conditionals
libvirt_driver_storage_la_SOURCES =
if WITH_STORAGE_DIR
--
1.6.0.6
3:11 p.m.
New subject: [libvirt] [PATCH 0/5] Interface Config Public APIs and remote stubs, with MAC addresses in string format
On Mon, May 18, 2009 at 04:07:29PM -0400, Laine Stump wrote:
These patches are based on those I sent last week (the public
virInterface*() API definition, the local plumbing, and the RPC glue),
but with suggestions incorporated:
1) MAC address is always used in null-terminated ASCII string
format. This eliminates any potential problems with extra long
addresses.
2) no comments in libvirt.h
3) flags arguments are all unsigned.
Item (1) caused changes in most of the patches, so I just regenerated
the entire set. Is this the proper/expected thing to do, or should I
be making patches of patches?
If the number of lines changes is > 5-10, then I prefer to see whole
new patch sets as you've just posted, so I can review the whole set
of changes with full context instead of having correlate incremental
patches.
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
3:21 p.m.
New subject: [libvirt] [PATCH 0/5] Interface Config Public APIs and remote stubs, with MAC addresses in string format
why these mail send to libvir-list(a)laine.org?
this breaks all mail filters...:-(
Daniel P. Berrange wrote:
On Mon, May 18, 2009 at 04:07:29PM -0400, Laine Stump wrote:
> These patches are based on those I sent last week (the public
> virInterface*() API definition, the local plumbing, and the RPC glue),
> but with suggestions incorporated:
>
> 1) MAC address is always used in null-terminated ASCII string
> format. This eliminates any potential problems with extra long
> addresses.
>
> 2) no comments in libvirt.h
>
> 3) flags arguments are all unsigned.
>
>
> Item (1) caused changes in most of the patches, so I just regenerated
> the entire set. Is this the proper/expected thing to do, or should I
> be making patches of patches?
If the number of lines changes is > 5-10, then I prefer to see whole
new patch sets as you've just posted, so I can review the whole set
of changes with full context instead of having correlate incremental
patches.
Daniel
--
Levente "Si vis pacem para bellum!"
3:27 p.m.
New subject: [libvirt] [PATCH 0/5] Interface Config Public APIs and remote stubs, with MAC addresses in string format
On Mon, May 18, 2009 at 10:21:50PM +0200, Farkas Levente wrote:
why these mail send to libvir-list(a)laine.org?
this breaks all mail filters...:-(
For a reliable filter, you're probably better off hooking onto the
standard List-ID header which mailman guarentees will always be
set correctly for message on this list. The 'To:' field will always
have potential for variance, particularly with mails cross-posted
between lists.
List-Id: This list is about the libvirt library <libvir-list.redhat.com>
Regards,
Daniel
--
|: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :|
|: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|
9:24 p.m.
New subject: [libvirt] [PATCH 0/5] Interface Config Public APIs and remote stubs, with MAC addresses in string format
On 05/18/2009 04:21 PM, Farkas Levente wrote:
why these mail send to libvir-list(a)laine.org?
this breaks all mail filters...:-(
Sorry, that was a rushed mistype on my part that I tried to fix by just
bouncing the mail rather than regenerating it; I hadn't considered that
people might be using the To: address for filtering rather than the
"[libvirt]" in the Subject: line.
I can't promise I will never do anything fat-fingered like this again,
but I can promise that I will *try* not to ;-)
5665
days inactive
5666
days old
9 comments
3 participants
participants (3)
-
Daniel P. Berrange -
Farkas Levente -
Laine Stump