3:10 a.m.
This is hopefully the final spin of these patches, It squashes in all
the changes from:
https://www.redhat.com/archives/libvir-list/2012-February/msg01103.html
as well as:
https://www.redhat.com/archives/libvir-list/2012-February/msg01173.html
Dirk, please test these out and let me know if they're okay to push.
Thanks!
3:10 a.m.
New subject: [libvirt] [PATCHv7 1/2] util: Add netlink event handling to virnetlink.c
From: "D. Herrendoerfer" <d.herrendoerfer(a)herrendoerfer.name>
This code adds a netlink event interface to libvirt.
It is based upon the event_poll code and makes use of
it. An event is generated for each netlink message sent
to the libvirt pid.
Signed-off-by: D. Herrendoerfer <d.herrendoerfer(a)herrendoerfer.name>
---
daemon/libvirtd.c | 8 +
src/libvirt_private.syms | 6 +
src/util/virnetlink.c | 464 +++++++++++++++++++++++++++++++++++++++++++++-
src/util/virnetlink.h | 33 ++++
4 files changed, 506 insertions(+), 5 deletions(-)
diff --git a/daemon/libvirtd.c b/daemon/libvirtd.c
index b1b542b..ca8074d 100644
--- a/daemon/libvirtd.c
+++ b/daemon/libvirtd.c
@@ -47,6 +47,7 @@
#include "conf.h"
#include "memory.h"
#include "conf.h"
+#include "virnetlink.h"
#include "virnetserver.h"
#include "threads.h"
#include "remote.h"
@@ -1598,6 +1599,12 @@ int main(int argc, char **argv) {
goto cleanup;
}
+ /* Register the netlink event service */
+ if (virNetlinkEventServiceStart() < 0) {
+ ret = VIR_DAEMON_ERR_NETWORK;
+ goto cleanup;
+ }
+
/* Run event loop. */
virNetServerRun(srv);
@@ -1607,6 +1614,7 @@ int main(int argc, char **argv) {
0, "shutdown", NULL);
cleanup:
+ virNetlinkEventServiceStop();
virNetServerProgramFree(remoteProgram);
virNetServerProgramFree(qemuProgram);
virNetServerClose(srv);
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index b9baf9a..ce4b7f7 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -1271,6 +1271,12 @@ virNetDevVPortProfileOpTypeToString;
#virnetlink.h
virNetlinkCommand;
+virNetlinkEventServiceIsRunning;
+virNetlinkEventServiceStop;
+virNetlinkEventServiceStart;
+virNetlinkEventAddClient;
+virNetlinkEventRemoveClient;
+
# virnetmessage.h
diff --git a/src/util/virnetlink.c b/src/util/virnetlink.c
index d03d171..fd6f751 100644
--- a/src/util/virnetlink.c
+++ b/src/util/virnetlink.c
@@ -35,7 +35,10 @@
#include <sys/types.h>
#include "virnetlink.h"
+#include "logging.h"
#include "memory.h"
+#include "threads.h"
+#include "virmacaddr.h"
#include "virterror_internal.h"
#define VIR_FROM_THIS VIR_FROM_NET
@@ -46,6 +49,48 @@
#define NETLINK_ACK_TIMEOUT_S 2
+#if defined(__linux__) && defined(HAVE_LIBNL)
+/* State for a single netlink event handle */
+struct virNetlinkEventHandle {
+ int watch;
+ virNetlinkEventHandleCallback handleCB;
+ virNetlinkEventRemoveCallback removeCB;
+ void *opaque;
+ unsigned char macaddr[VIR_MAC_BUFLEN];
+ int deleted;
+};
+
+typedef struct _virNetlinkEventSrvPrivate virNetlinkEventSrvPrivate;
+typedef virNetlinkEventSrvPrivate *virNetlinkEventSrvPrivatePtr;
+struct _virNetlinkEventSrvPrivate {
+ /*Server*/
+ virMutex lock;
+ int eventwatch;
+ int netlinkfd;
+ struct nl_handle *netlinknh;
+ /*Events*/
+ int handled;
+ size_t handlesCount;
+ size_t handlesAlloc;
+ struct virNetlinkEventHandle *handles;
+};
+
+enum virNetlinkDeleteMode {
+ VIR_NETLINK_HANDLE_VALID,
+ VIR_NETLINK_HANDLE_DELETED,
+};
+
+/* Unique ID for the next netlink watch to be registered */
+static int nextWatch = 1;
+
+/* Allocate extra slots for virEventPollHandle/virEventPollTimeout
+ records in this multiple */
+# define NETLINK_EVENT_ALLOC_EXTENT 10
+
+static virNetlinkEventSrvPrivatePtr server = NULL;
+
+/* Function definitions */
+
/**
* virNetlinkCommand:
* @nlmsg: pointer to netlink message
@@ -58,7 +103,6 @@
* Returns 0 on success, -1 on error. In case of error, no response
* buffer will be returned.
*/
-#if defined(__linux__) && defined(HAVE_LIBNL)
int virNetlinkCommand(struct nl_msg *nl_msg,
unsigned char **respbuf, unsigned int *respbuflen,
int nl_pid)
@@ -89,7 +133,7 @@ int virNetlinkCommand(struct nl_msg *nl_msg,
virReportSystemError(errno,
"%s", _("cannot connect to netlink
socket"));
rc = -1;
- goto err_exit;
+ goto error;
}
nlmsg_set_dst(nl_msg, &nladdr);
@@ -101,7 +145,7 @@ int virNetlinkCommand(struct nl_msg *nl_msg,
virReportSystemError(errno,
"%s", _("cannot send to netlink
socket"));
rc = -1;
- goto err_exit;
+ goto error;
}
fd = nl_socket_get_fd(nlhandle);
@@ -118,7 +162,7 @@ int virNetlinkCommand(struct nl_msg *nl_msg,
virReportSystemError(ETIMEDOUT, "%s",
_("no valid netlink response was received"));
rc = -1;
- goto err_exit;
+ goto error;
}
*respbuflen = nl_recv(nlhandle, &nladdr, respbuf, NULL);
@@ -127,7 +171,7 @@ int virNetlinkCommand(struct nl_msg *nl_msg,
"%s", _("nl_recv failed"));
rc = -1;
}
-err_exit:
+error:
if (rc == -1) {
VIR_FREE(*respbuf);
*respbuf = NULL;
@@ -138,6 +182,345 @@ err_exit:
return rc;
}
+static void
+virNetlinkEventServerLock(virNetlinkEventSrvPrivatePtr driver)
+{
+ virMutexLock(&driver->lock);
+}
+
+static void
+virNetlinkEventServerUnlock(virNetlinkEventSrvPrivatePtr driver)
+{
+ virMutexUnlock(&driver->lock);
+}
+
+/**
+ * virNetlinkEventRemoveClientPrimitive:
+ *
+ * @i: index of the client to remove from the table
+ *
+ * This static function does the low level removal of a client from
+ * the table once its index is known, including calling the remove
+ * callback (which usually will free resources required by the
+ * handler). The event server lock *must* be locked before calling
+ * this function.
+ *
+ * assumes success, returns nothing.
+ */
+static void
+virNetlinkEventRemoveClientPrimitive(size_t i)
+{
+ virNetlinkEventRemoveCallback removeCB = server->handles[i].removeCB;
+
+ if (removeCB) {
+ (removeCB)(server->handles[i].watch,
+ server->handles[i].macaddr,
+ server->handles[i].opaque);
+ }
+ server->handles[i].deleted = VIR_NETLINK_HANDLE_DELETED;
+}
+
+static void
+virNetlinkEventCallback(int watch,
+ int fd ATTRIBUTE_UNUSED,
+ int events ATTRIBUTE_UNUSED,
+ void *opaque)
+{
+ virNetlinkEventSrvPrivatePtr srv = opaque;
+ unsigned char *msg;
+ struct sockaddr_nl peer;
+ struct ucred *creds = NULL;
+ int i, length;
+ bool handled = false;
+
+ length = nl_recv(srv->netlinknh, &peer, &msg, &creds);
+
+ if (length == 0)
+ return;
+ if (length < 0) {
+ netlinkError(errno,
+ "%s", _("nl_recv returned with error"));
+ return;
+ }
+
+ virNetlinkEventServerLock(srv);
+
+ VIR_DEBUG("dispatching to max %d clients, called from event watch %d",
+ (int)srv->handlesCount, watch);
+
+ for (i = 0; i < srv->handlesCount; i++) {
+ if (srv->handles[i].deleted != VIR_NETLINK_HANDLE_VALID)
+ continue;
+
+ VIR_DEBUG("dispatching client %d.", i);
+
+ (srv->handles[i].handleCB)(msg, length, &peer, &handled,
+ srv->handles[i].opaque);
+ }
+
+ if (!handled)
+ VIR_DEBUG("event not handled.");
+ VIR_FREE(msg);
+ virNetlinkEventServerUnlock(srv);
+}
+
+/**
+ * virNetlinkEventServiceStop:
+ *
+ * stop the monitor to receive netlink messages for libvirtd.
+ * This removes the netlink socket fd from the event handler.
+ *
+ * returns -1 if the monitor cannot be unregistered, 0 upon success
+ */
+int
+virNetlinkEventServiceStop(void)
+{
+ virNetlinkEventSrvPrivatePtr srv = server;
+ int i;
+
+ VIR_INFO("stopping netlink event service");
+
+ if (!server)
+ return 0;
+
+ virNetlinkEventServerLock(srv);
+ nl_close(srv->netlinknh);
+ nl_handle_destroy(srv->netlinknh);
+ virEventRemoveHandle(srv->eventwatch);
+
+ /* free any remaining clients on the list */
+ for (i = 0; i < srv->handlesCount; i++) {
+ if (srv->handles[i].deleted == VIR_NETLINK_HANDLE_VALID)
+ virNetlinkEventRemoveClientPrimitive(i);
+ }
+
+ server = 0;
+ virNetlinkEventServerUnlock(srv);
+
+ virMutexDestroy(&srv->lock);
+ VIR_FREE(srv);
+ return 0;
+}
+
+/**
+ * virNetlinkEventServiceIsRunning:
+ *
+ * returns if the netlink event service is running.
+ *
+ * returns 'true' if the service is running, 'false' if stopped.
+ */
+bool
+virNetlinkEventServiceIsRunning(void)
+{
+ return (server != NULL);
+}
+
+/**
+ * virNetlinkEventServiceStart:
+ *
+ * start a monitor to receive netlink messages for libvirtd.
+ * This registers a netlink socket with the event interface.
+ *
+ * returns -1 if the monitor cannot be registered, 0 upon success
+ */
+int
+virNetlinkEventServiceStart(void)
+{
+ virNetlinkEventSrvPrivatePtr srv;
+ int fd;
+ int ret = -1;
+
+ if (server)
+ return 0;
+
+ VIR_INFO("starting netlink event service");
+
+ if (VIR_ALLOC(srv) < 0) {
+ virReportOOMError();
+ goto error;
+ }
+
+ if (virMutexInit(&srv->lock) < 0)
+ goto error;
+
+ virNetlinkEventServerLock(srv);
+
+ /* Allocate a new socket and get fd */
+ srv->netlinknh = nl_handle_alloc();
+
+ if (!srv->netlinknh) {
+ netlinkError(errno,
+ "%s", _("cannot allocate nlhandle for virNetlinkEvent
server"));
+ goto error_locked;
+ }
+
+ if (nl_connect(srv->netlinknh, NETLINK_ROUTE) < 0) {
+ netlinkError(errno,
+ "%s", _("cannot connect to netlink socket"));
+ goto error_server;
+ }
+
+ fd = nl_socket_get_fd(srv->netlinknh);
+
+ if (fd < 0) {
+ netlinkError(errno,
+ "%s", _("cannot get netlink socket fd"));
+ goto error_server;
+ }
+
+ if (nl_socket_set_nonblocking(srv->netlinknh)) {
+ netlinkError(errno, "%s",
+ _("cannot set netlink socket nonblocking"));
+ goto error_server;
+ }
+
+ if ((srv->eventwatch = virEventAddHandle(fd,
+ VIR_EVENT_HANDLE_READABLE,
+ virNetlinkEventCallback,
+ srv, NULL)) < 0) {
+ netlinkError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("Failed to add netlink event handle watch"));
+ goto error_server;
+ }
+
+ srv->netlinkfd = fd;
+ VIR_DEBUG("netlink event listener on fd: %i running", fd);
+
+ ret = 0;
+ server = srv;
+
+error_server:
+ if (ret < 0) {
+ nl_close(srv->netlinknh);
+ nl_handle_destroy(srv->netlinknh);
+ }
+error_locked:
+ virNetlinkEventServerUnlock(srv);
+ if (ret < 0) {
+ virMutexDestroy(&srv->lock);
+ VIR_FREE(srv);
+ }
+error:
+ return ret;
+}
+
+/**
+ * virNetlinkEventAddClient:
+ *
+ * @handleCB: callback to invoke when an event occurs
+ * @removeCB: callback to invoke when removing a client
+ * @opaque: user data to pass to callback
+ * @macaddr: macaddr to store with the data. Used to identify callers. May be null.
+ *
+ * register a callback for handling of netlink messages. The
+ * registered function receives the entire netlink message and
+ * may choose to act upon it.
+ *
+ * returns -1 if the file handle cannot be registered, number of monitor upon success
+ */
+int
+virNetlinkEventAddClient(virNetlinkEventHandleCallback handleCB,
+ virNetlinkEventRemoveCallback removeCB,
+ void *opaque, const unsigned char *macaddr)
+{
+ int i, r, ret = -1;
+ virNetlinkEventSrvPrivatePtr srv = server;
+
+ if (handleCB == NULL)
+ return -1;
+
+ virNetlinkEventServerLock(srv);
+
+ VIR_DEBUG("adding client: %d.", nextWatch);
+
+ r = 0;
+ /* first try to re-use deleted free slots */
+ for (i = 0; i < srv->handlesCount; i++) {
+ if (srv->handles[i].deleted == VIR_NETLINK_HANDLE_DELETED) {
+ r = i;
+ goto addentry;
+ }
+ }
+ /* Resize the eventLoop array if needed */
+ if (srv->handlesCount == srv->handlesAlloc) {
+ VIR_DEBUG("Used %zu handle slots, adding at least %d more",
+ srv->handlesAlloc, NETLINK_EVENT_ALLOC_EXTENT);
+ if (VIR_RESIZE_N(srv->handles, srv->handlesAlloc,
+ srv->handlesCount, NETLINK_EVENT_ALLOC_EXTENT) < 0) {
+ goto error;
+ }
+ }
+ r = srv->handlesCount++;
+
+addentry:
+ srv->handles[r].watch = nextWatch;
+ srv->handles[r].handleCB = handleCB;
+ srv->handles[r].removeCB = removeCB;
+ srv->handles[r].opaque = opaque;
+ srv->handles[r].deleted = VIR_NETLINK_HANDLE_VALID;
+ if (macaddr)
+ memcpy(srv->handles[r].macaddr, macaddr, VIR_MAC_BUFLEN);
+ else
+ memset(srv->handles[r].macaddr, 0, VIR_MAC_BUFLEN);
+
+ VIR_DEBUG("added client to loop slot: %d. with macaddr ptr=%p", r,
macaddr);
+
+ ret = nextWatch++;
+error:
+ virNetlinkEventServerUnlock(srv);
+ return ret;
+}
+
+/**
+ * virNetlinkEventRemoveClient:
+ *
+ * @watch: watch whose handle to remove
+ * @macaddr: macaddr whose handle to remove
+ *
+ * Unregister a callback from a netlink monitor.
+ * The handler function referenced will no longer receive netlink messages.
+ * Either watch or macaddr may be used, the other should be null.
+ *
+ * returns -1 if the file handle was not registered, 0 upon success
+ */
+int
+virNetlinkEventRemoveClient(int watch, const unsigned char *macaddr)
+{
+ int i;
+ int ret = -1;
+ virNetlinkEventSrvPrivatePtr srv = server;
+
+ VIR_DEBUG("removing client watch=%d, mac=%p.", watch, macaddr);
+
+ if (watch <= 0 && !macaddr) {
+ VIR_WARN("Ignoring invalid netlink client id: %d", watch);
+ return -1;
+ }
+
+ virNetlinkEventServerLock(srv);
+
+ for (i = 0; i < srv->handlesCount; i++) {
+ if (srv->handles[i].deleted != VIR_NETLINK_HANDLE_VALID)
+ continue;
+
+ if ((watch && srv->handles[i].watch == watch) ||
+ (!watch &&
+ memcmp(macaddr, srv->handles[i].macaddr, VIR_MAC_BUFLEN) == 0)) {
+
+ virNetlinkEventRemoveClientPrimitive(i);
+ VIR_DEBUG("removed client: %d by %s.", srv->handles[i].watch,
+ srv->handles[i].watch ? "index" : "mac");
+ ret = 0;
+ goto cleanup;
+ }
+ }
+ VIR_DEBUG("no client found to remove.");
+
+cleanup:
+ virNetlinkEventServerUnlock(srv);
+ return ret;
+}
+
#else
int virNetlinkCommand(struct nl_msg *nl_msg ATTRIBUTE_UNUSED,
@@ -154,4 +537,75 @@ int virNetlinkCommand(struct nl_msg *nl_msg ATTRIBUTE_UNUSED,
return -1;
}
+/**
+ * stopNetlinkEventServer: stop the monitor to receive netlink messages for libvirtd
+ */
+int virNetlinkEventServiceStop(void)
+{
+ netlinkError(VIR_ERR_INTERNAL_ERROR,
+ "%s",
+# if defined(__linux__) && !defined(HAVE_LIBNL)
+ _("virNetlinkEventServiceStop is not supported since libnl was not
available"));
+# endif
+ return 0;
+}
+
+/**
+ * startNetlinkEventServer: start a monitor to receive netlink messages for libvirtd
+ */
+int virNetlinkEventServiceStart(void)
+{
+# if defined(__linux__) && !defined(HAVE_LIBNL)
+ netlinkError(VIR_ERR_INTERNAL_ERROR,
+ "%s",
+ _("virNetlinkEventServiceStart is not supported since libnl was not
available"));
+# endif
+ return 0;
+}
+
+/**
+ * virNetlinkEventServiceIsRunning: returns if the netlink event service is running.
+ */
+int virNetlinkEventServiceIsRunning(void)
+{
+# if defined(__linux__) && !defined(HAVE_LIBNL)
+ netlinkError(VIR_ERR_INTERNAL_ERROR,
+ "%s",
+ _("virNetlinkEventServiceIsRunning is not supported since libnl was
not available"));
+# endif
+ return 0;
+}
+
+/**
+ * virNetlinkEventAddClient: register a callback for handling of netlink messages
+ */
+int virNetlinkEventAddClient(virNetlinkEventHandleCallback cb,
+ virNetlinkEventRemoveCallback cb,
+ void *opaque, const unsigned char *macaddr)
+{
+ netlinkError(VIR_ERR_INTERNAL_ERROR,
+ "%s",
+# if defined(__linux__) && !defined(HAVE_LIBNL)
+ _("virNetlinkEventServiceAddClient is not supported since libnl was
not available"));
+# else
+ _("virNetlinkEventServiceAddClient is not supported on non-linux
platforms"));
+# endif
+ return -1;
+}
+
+/**
+ * virNetlinkEventRemoveClient: unregister a callback from a netlink monitor
+ */
+int virNetlinkEventRemoveClient(int watch, const unsigned char *macaddr)
+{
+ netlinkError(VIR_ERR_INTERNAL_ERROR,
+ "%s",
+# if defined(__linux__) && !defined(HAVE_LIBNL)
+ _("virNetlinkEventRemoveClient is not supported since libnl was not
available"));
+# else
+ _("virNetlinkEventRemoveClient is not supported on non-linux
platforms"));
+# endif
+ return -1;
+}
+
#endif /* __linux__ */
diff --git a/src/util/virnetlink.h b/src/util/virnetlink.h
index a70abb6..75533a3 100644
--- a/src/util/virnetlink.h
+++ b/src/util/virnetlink.h
@@ -21,6 +21,7 @@
# define __VIR_NETLINK_H__
# include "config.h"
+# include "internal.h"
# if defined(__linux__) && defined(HAVE_LIBNL)
@@ -29,6 +30,7 @@
# else
struct nl_msg;
+struct sockaddr_nl;
# endif /* __linux__ */
@@ -36,4 +38,35 @@ int virNetlinkCommand(struct nl_msg *nl_msg,
unsigned char **respbuf, unsigned int *respbuflen,
int nl_pid);
+typedef void (*virNetlinkEventHandleCallback)(unsigned char *msg, int length, struct
sockaddr_nl *peer, bool *handled, void *opaque);
+
+typedef void (*virNetlinkEventRemoveCallback)(int watch, const unsigned char *macaddr,
void *opaque);
+
+/**
+ * stopNetlinkEventServer: stop the monitor to receive netlink messages for libvirtd
+ */
+int virNetlinkEventServiceStop(void);
+
+/**
+ * startNetlinkEventServer: start a monitor to receive netlink messages for libvirtd
+ */
+int virNetlinkEventServiceStart(void);
+
+/**
+ * virNetlinkEventServiceIsRunning: returns if the netlink event service is running.
+ */
+bool virNetlinkEventServiceIsRunning(void);
+
+/**
+ * virNetlinkEventAddClient: register a callback for handling of netlink messages
+ */
+int virNetlinkEventAddClient(virNetlinkEventHandleCallback handleCB,
+ virNetlinkEventRemoveCallback removeCB,
+ void *opaque, const unsigned char *macaddr);
+
+/**
+ * virNetlinkEventRemoveClient: unregister a callback from a netlink monitor
+ */
+int virNetlinkEventRemoveClient(int watch, const unsigned char *macaddr);
+
#endif /* __VIR_NETLINK_H__ */
--
1.7.7.6
3:10 a.m.
New subject: [libvirt] [PATCHv7 2/2] Add de-association handling to macvlan code
From: "D. Herrendoerfer" <d.herrendoerfer(a)herrendoerfer.name>
Add de-association handling for 802.1qbg (vepa) via lldpad
netlink messages. Also adds the possibility to perform an
association request without waiting for a confirmation.
Signed-off-by: D. Herrendoerfer <d.herrendoerfer(a)herrendoerfer.name>
---
src/qemu/qemu_migration.c | 2 +-
src/util/virnetdevmacvlan.c | 360 +++++++++++++++++++++++++++++++++++++-
src/util/virnetdevvportprofile.c | 33 +++-
src/util/virnetdevvportprofile.h | 3 +-
4 files changed, 383 insertions(+), 15 deletions(-)
diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index 7df2d4f..ea06e69 100644
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -2606,7 +2606,7 @@ qemuMigrationVPAssociatePortProfiles(virDomainDefPtr def) {
net->mac,
virDomainNetGetActualDirectDev(net),
def->uuid,
-
VIR_NETDEV_VPORT_PROFILE_OP_MIGRATE_IN_FINISH) < 0)
+
VIR_NETDEV_VPORT_PROFILE_OP_MIGRATE_IN_FINISH, false) < 0)
goto err_exit;
}
last_good_net = i;
diff --git a/src/util/virnetdevmacvlan.c b/src/util/virnetdevmacvlan.c
index 25d0846..d36b326 100644
--- a/src/util/virnetdevmacvlan.c
+++ b/src/util/virnetdevmacvlan.c
@@ -1,6 +1,6 @@
/*
* Copyright (C) 2010-2011 Red Hat, Inc.
- * Copyright (C) 2010 IBM Corporation
+ * Copyright (C) 2010-2012 IBM Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -46,7 +46,6 @@ VIR_ENUM_IMPL(virNetDevMacVLanMode, VIR_NETDEV_MACVLAN_MODE_LAST,
"passthrough")
#if WITH_MACVTAP
-
# include <stdint.h>
# include <stdio.h>
# include <errno.h>
@@ -68,6 +67,8 @@ VIR_ENUM_IMPL(virNetDevMacVLanMode, VIR_NETDEV_MACVLAN_MODE_LAST,
# include "virfile.h"
# include "virnetlink.h"
# include "virnetdev.h"
+# include "virpidfile.h"
+
# define MACVTAP_NAME_PREFIX "macvtap"
# define MACVTAP_NAME_PATTERN "macvtap%d"
@@ -445,6 +446,328 @@ static const uint32_t modeMap[VIR_NETDEV_MACVLAN_MODE_LAST] = {
[VIR_NETDEV_MACVLAN_MODE_PASSTHRU] = MACVLAN_MODE_PASSTHRU,
};
+/* Struct to hold the state and configuration of a 802.1qbg port */
+struct virNetlinkCallbackData {
+ char *cr_ifname;
+ virNetDevVPortProfilePtr virtPortProfile;
+ unsigned char *macaddress;
+ char *linkdev;
+ unsigned char *vmuuid;
+ enum virNetDevVPortProfileOp vmOp;
+ unsigned int linkState;
+};
+
+typedef struct virNetlinkCallbackData *virNetlinkCallbackDataPtr;
+
+# define INSTANCE_STRLEN 36
+
+static int instance2str(const unsigned char *p, char *dst, size_t size)
+{
+ if (dst && size > INSTANCE_STRLEN) {
+ snprintf(dst, size, "%02x%02x%02x%02x-%02x%02x-%02x%02x-"
+ "%02x%02x-%02x%02x%02x%02x%02x%02x",
+ p[0], p[1], p[2], p[3],
+ p[4], p[5], p[6], p[7],
+ p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15]);
+ return 0;
+ }
+ return -1;
+}
+
+# define LLDPAD_PID_FILE "/var/run/lldpad.pid"
+# define VIRIP_PID_FILE "/var/run/virip.pid"
+
+/**
+ * virNetDevMacVLanVPortProfileCallback:
+ *
+ * @msg: The buffer containing the received netlink message
+ * @length: The length of the received netlink message.
+ * @peer: The netling sockaddr containing the peer information
+ * @handled: Contains information if the message has been replied to yet
+ * @opaque: Contains vital information regarding the associated vm an interface
+ *
+ * This function is called when a netlink message is received. The function
+ * reads the message and responds if it is pertinent to the running VMs
+ * network interface.
+ */
+
+static void
+virNetDevMacVLanVPortProfileCallback(unsigned char *msg,
+ int length,
+ struct sockaddr_nl *peer,
+ bool *handled,
+ void *opaque)
+{
+ struct nla_policy ifla_vf_policy[IFLA_VF_MAX + 1] = {
+ [IFLA_VF_MAC] = {.minlen = sizeof(struct ifla_vf_mac),
+ .maxlen = sizeof(struct ifla_vf_mac)},
+ [IFLA_VF_VLAN] = {.minlen = sizeof(struct ifla_vf_vlan),
+ .maxlen = sizeof(struct ifla_vf_vlan)},
+ };
+
+ struct nla_policy ifla_port_policy[IFLA_PORT_MAX + 1] = {
+ [IFLA_PORT_RESPONSE] = {.type = NLA_U16},
+ };
+
+ struct nlattr *tb[IFLA_MAX + 1], *tb3[IFLA_PORT_MAX + 1],
+ *tb_vfinfo[IFLA_VF_MAX + 1], *tb_vfinfo_list;
+
+ struct ifinfomsg ifinfo;
+ struct nlmsghdr *hdr;
+ void *data;
+ int rem;
+ char *ifname;
+ bool indicate = false;
+ virNetlinkCallbackDataPtr calld = opaque;
+ pid_t lldpad_pid = 0;
+ pid_t virip_pid = 0;
+
+ hdr = (struct nlmsghdr *) msg;
+ data = nlmsg_data(hdr);
+
+ /* Quickly decide if we want this or not */
+
+ if (virPidFileReadPath(LLDPAD_PID_FILE, &lldpad_pid) < 0)
+ return;
+
+ ignore_value(virPidFileReadPath(VIRIP_PID_FILE, &virip_pid));
+
+ if (hdr->nlmsg_pid != lldpad_pid && hdr->nlmsg_pid != virip_pid)
+ return; /* we only care for lldpad and virip messages */
+ if (hdr->nlmsg_type != RTM_SETLINK)
+ return; /* we only care for RTM_SETLINK */
+ if (*handled)
+ return; /* if it has been handled - dont handle again */
+
+ /* DEBUG start */
+ VIR_INFO("netlink message nl_sockaddr: %p len: %d", peer, length);
+ VIR_DEBUG("nlmsg_type = 0x%02x", hdr->nlmsg_type);
+ VIR_DEBUG("nlmsg_len = 0x%04x", hdr->nlmsg_len);
+ VIR_DEBUG("nlmsg_pid = %d", hdr->nlmsg_pid);
+ VIR_DEBUG("nlmsg_seq = 0x%08x", hdr->nlmsg_seq);
+ VIR_DEBUG("nlmsg_flags = 0x%04x", hdr->nlmsg_flags);
+
+ VIR_DEBUG("lldpad pid = %d", lldpad_pid);
+
+ switch (hdr->nlmsg_type) {
+ case RTM_NEWLINK:
+ case RTM_DELLINK:
+ case RTM_SETLINK:
+ case RTM_GETLINK:
+ VIR_DEBUG(" IFINFOMSG\n");
+ VIR_DEBUG(" ifi_family = 0x%02x\n",
+ ((struct ifinfomsg *)data)->ifi_family);
+ VIR_DEBUG(" ifi_type = 0x%x\n",
+ ((struct ifinfomsg *)data)->ifi_type);
+ VIR_DEBUG(" ifi_index = %i\n",
+ ((struct ifinfomsg *)data)->ifi_index);
+ VIR_DEBUG(" ifi_flags = 0x%04x\n",
+ ((struct ifinfomsg *)data)->ifi_flags);
+ VIR_DEBUG(" ifi_change = 0x%04x\n",
+ ((struct ifinfomsg *)data)->ifi_change);
+ }
+ /* DEBUG end */
+
+ /* Parse netlink message assume a setlink with vfports */
+ memcpy(&ifinfo, NLMSG_DATA(hdr), sizeof ifinfo);
+ VIR_DEBUG("family:%#x type:%#x index:%d flags:%#x change:%#x",
+ ifinfo.ifi_family, ifinfo.ifi_type, ifinfo.ifi_index,
+ ifinfo.ifi_flags, ifinfo.ifi_change);
+ if (nlmsg_parse(hdr, sizeof ifinfo,
+ (struct nlattr **)&tb, IFLA_MAX, NULL)) {
+ VIR_DEBUG("error parsing request...");
+ return;
+ }
+
+ if (tb[IFLA_VFINFO_LIST]) {
+ VIR_DEBUG("FOUND IFLA_VFINFO_LIST!");
+
+ nla_for_each_nested(tb_vfinfo_list, tb[IFLA_VFINFO_LIST], rem) {
+ if (nla_type(tb_vfinfo_list) != IFLA_VF_INFO) {
+ VIR_DEBUG("nested parsing of"
+ "IFLA_VFINFO_LIST failed.");
+ return;
+ }
+ if (nla_parse_nested(tb_vfinfo, IFLA_VF_MAX,
+ tb_vfinfo_list, ifla_vf_policy)) {
+ VIR_DEBUG("nested parsing of "
+ "IFLA_VF_INFO failed.");
+ return;
+ }
+ }
+
+ if (tb_vfinfo[IFLA_VF_MAC]) {
+ struct ifla_vf_mac *mac = RTA_DATA(tb_vfinfo[IFLA_VF_MAC]);
+ unsigned char *m = mac->mac;
+
+ VIR_DEBUG("IFLA_VF_MAC = %2x:%2x:%2x:%2x:%2x:%2x",
+ m[0], m[1], m[2], m[3], m[4], m[5]);
+
+ if (memcmp(calld->macaddress, m, VIR_MAC_BUFLEN))
+ {
+ /* Repeat the same check for a broadcast mac */
+ int i;
+
+ for (i = 0;i < VIR_MAC_BUFLEN; i++) {
+ if (calld->macaddress[i] != 0xff) {
+ VIR_DEBUG("MAC address match failed (wasn't
broadcast)");
+ return;
+ }
+ }
+ }
+ }
+
+ if (tb_vfinfo[IFLA_VF_VLAN]) {
+ struct ifla_vf_vlan *vlan = RTA_DATA(tb_vfinfo[IFLA_VF_VLAN]);
+
+ VIR_DEBUG("IFLA_VF_VLAN = %d", vlan->vlan);
+ }
+ }
+
+ if (tb[IFLA_IFNAME]) {
+ ifname = (char *)RTA_DATA(tb[IFLA_IFNAME]);
+ VIR_DEBUG("IFLA_IFNAME = %s\n", ifname);
+ }
+
+ if (tb[IFLA_OPERSTATE]) {
+ rem = *(unsigned short *)RTA_DATA(tb[IFLA_OPERSTATE]);
+ VIR_DEBUG("IFLA_OPERSTATE = %d\n", rem);
+ }
+
+ if (tb[IFLA_VF_PORTS]) {
+ struct nlattr *tb_vf_ports;
+
+ VIR_DEBUG("found IFLA_VF_PORTS\n");
+ nla_for_each_nested(tb_vf_ports, tb[IFLA_VF_PORTS], rem) {
+
+ VIR_DEBUG("iterating\n");
+ if (nla_type(tb_vf_ports) != IFLA_VF_PORT) {
+ VIR_DEBUG("not a IFLA_VF_PORT. skipping\n");
+ continue;
+ }
+ if (nla_parse_nested(tb3, IFLA_PORT_MAX, tb_vf_ports,
+ ifla_port_policy)) {
+ VIR_DEBUG("nested parsing on level 2"
+ " failed.");
+ }
+ if (tb3[IFLA_PORT_VF]) {
+ VIR_DEBUG("IFLA_PORT_VF = %d",
+ *(uint32_t *) (RTA_DATA(tb3[IFLA_PORT_VF])));
+ }
+ if (tb3[IFLA_PORT_PROFILE]) {
+ VIR_DEBUG("IFLA_PORT_PROFILE = %s",
+ (char *) RTA_DATA(tb3[IFLA_PORT_PROFILE]));
+ }
+
+ if (tb3[IFLA_PORT_VSI_TYPE]) {
+ struct ifla_port_vsi *pvsi;
+ int tid = 0;
+
+ pvsi = (struct ifla_port_vsi *)
+ RTA_DATA(tb3[IFLA_PORT_VSI_TYPE]);
+ tid = ((pvsi->vsi_type_id[2] << 16) |
+ (pvsi->vsi_type_id[1] << 8) |
+ pvsi->vsi_type_id[0]);
+
+ VIR_DEBUG("mgr_id: %d", pvsi->vsi_mgr_id);
+ VIR_DEBUG("type_id: %d", tid);
+ VIR_DEBUG("type_version: %d",
+ pvsi->vsi_type_version);
+ }
+
+ if (tb3[IFLA_PORT_INSTANCE_UUID]) {
+ char instance[INSTANCE_STRLEN + 2];
+ unsigned char *uuid;
+
+ uuid = (unsigned char *)
+ RTA_DATA(tb3[IFLA_PORT_INSTANCE_UUID]);
+ instance2str(uuid, instance, sizeof(instance));
+ VIR_DEBUG("IFLA_PORT_INSTANCE_UUID = %s\n",
+ instance);
+ }
+
+ if (tb3[IFLA_PORT_REQUEST]) {
+ uint8_t req = *(uint8_t *) RTA_DATA(tb3[IFLA_PORT_REQUEST]);
+ VIR_DEBUG("IFLA_PORT_REQUEST = %d", req);
+
+ if (req == PORT_REQUEST_DISASSOCIATE) {
+ VIR_DEBUG("Set dissaccociated.");
+ indicate = true;
+ }
+ }
+
+ if (tb3[IFLA_PORT_RESPONSE]) {
+ VIR_DEBUG("IFLA_PORT_RESPONSE = %d\n", *(uint16_t *)
+ RTA_DATA(tb3[IFLA_PORT_RESPONSE]));
+ }
+ }
+ }
+
+ if (!indicate) {
+ return;
+ }
+
+ VIR_INFO("Re-send 802.1qbg associate request:");
+ VIR_INFO(" if: %s", calld->cr_ifname);
+ VIR_INFO(" lf: %s", calld->linkdev);
+ VIR_INFO(" mac: %02x:%02x:%02x:%02x:%02x:%02x",
+ calld->macaddress[0], calld->macaddress[1],
+ calld->macaddress[2], calld->macaddress[3],
+ calld->macaddress[4], calld->macaddress[5]);
+
+ ignore_value(virNetDevVPortProfileAssociate(calld->cr_ifname,
+ calld->virtPortProfile,
+ calld->macaddress,
+ calld->linkdev,
+ calld->vmuuid,
+ calld->vmOp, true));
+ *handled = true;
+ return;
+}
+
+/**
+ * virNetlinkCallbackDataFree
+ *
+ * @calld: pointer to a virNetlinkCallbackData object to free
+ *
+ * This function frees all the data associated with a virNetlinkCallbackData object
+ * as well as the object itself. If called with NULL, it does nothing.
+ *
+ * Returns nothing.
+ */
+static void
+virNetlinkCallbackDataFree(virNetlinkCallbackDataPtr calld)
+{
+ if (calld) {
+ VIR_FREE(calld->cr_ifname);
+ VIR_FREE(calld->virtPortProfile);
+ VIR_FREE(calld->macaddress);
+ VIR_FREE(calld->linkdev);
+ VIR_FREE(calld->vmuuid);
+ }
+ VIR_FREE(calld);
+}
+
+/**
+ * virNetDevMacVLanVPortProfileDestroyCallback:
+ *
+ * @watch: watch whose handle to remove
+ * @macaddr: macaddr whose handle to remove
+ * @opaque: Contains vital information regarding the associated vm
+ *
+ * This function is called when a netlink message handler is terminated.
+ * The function frees locally allocated data referenced in the opaque
+ * data, and the opaque object itself.
+ */
+static void
+virNetDevMacVLanVPortProfileDestroyCallback(int watch ATTRIBUTE_UNUSED,
+ const unsigned char *macaddr
ATTRIBUTE_UNUSED,
+ void *opaque)
+{
+ virNetlinkCallbackDataFree((virNetlinkCallbackDataPtr)opaque);
+}
+
+
/**
* virNetDevMacVLanCreateWithVPortProfile:
* Create an instance of a macvtap device and open its tap character
@@ -485,6 +808,7 @@ int virNetDevMacVLanCreateWithVPortProfile(const char *tgifname,
int retries, do_retry = 0;
uint32_t macvtapMode;
const char *cr_ifname;
+ virNetlinkCallbackDataPtr calld = NULL;
int ret;
macvtapMode = modeMap[mode];
@@ -547,7 +871,7 @@ create_name:
virtPortProfile,
macaddress,
linkdev,
- vmuuid, vmOp) < 0) {
+ vmuuid, vmOp, false) < 0) {
rc = -1;
goto link_del_exit;
}
@@ -589,9 +913,36 @@ create_name:
goto disassociate_exit;
}
+ if (virNetlinkEventServiceIsRunning()) {
+ if (VIR_ALLOC(calld) < 0)
+ goto memory_error;
+ if ((calld->cr_ifname = strdup(cr_ifname)) == NULL)
+ goto memory_error;
+ if (VIR_ALLOC(calld->virtPortProfile) < 0)
+ goto memory_error;
+ memcpy(calld->virtPortProfile, virtPortProfile, sizeof(*virtPortProfile));
+ if (VIR_ALLOC_N(calld->macaddress, VIR_MAC_BUFLEN) < 0)
+ goto memory_error;
+ memcpy(calld->macaddress, macaddress, VIR_MAC_BUFLEN);
+ if ((calld->linkdev = strdup(linkdev)) == NULL)
+ goto memory_error;
+ if (VIR_ALLOC_N(calld->vmuuid, VIR_UUID_BUFLEN) < 0)
+ goto memory_error;
+ memcpy(calld->vmuuid, vmuuid, VIR_UUID_BUFLEN);
+
+ calld->vmOp = vmOp;
+
+ virNetlinkEventAddClient(virNetDevMacVLanVPortProfileCallback,
+ virNetDevMacVLanVPortProfileDestroyCallback,
+ calld, macaddress);
+ }
return rc;
+ memory_error:
+ virReportOOMError();
+ virNetlinkCallbackDataFree(calld);
+
disassociate_exit:
ignore_value(virNetDevVPortProfileDisassociate(cr_ifname,
virtPortProfile,
@@ -638,6 +989,9 @@ int virNetDevMacVLanDeleteWithVPortProfile(const char *ifname,
if (virNetDevMacVLanDelete(ifname) < 0)
ret = -1;
}
+
+ virNetlinkEventRemoveClient(0, macaddr);
+
return ret;
}
diff --git a/src/util/virnetdevvportprofile.c b/src/util/virnetdevvportprofile.c
index 67fd7bc..00fd123 100644
--- a/src/util/virnetdevvportprofile.c
+++ b/src/util/virnetdevvportprofile.c
@@ -650,7 +650,8 @@ virNetDevVPortProfileOpCommon(const char *ifname, int ifindex,
const unsigned char *instanceId,
const unsigned char *hostUUID,
int32_t vf,
- uint8_t op)
+ uint8_t op,
+ bool setlink_only)
{
int rc;
unsigned char *recvbuf = NULL;
@@ -675,6 +676,9 @@ virNetDevVPortProfileOpCommon(const char *ifname, int ifindex,
return rc;
}
+ if (setlink_only) /*for re-associations on existing links*/
+ return 0;
+
while (--repeats >= 0) {
rc = virNetDevVPortProfileLinkDump(NULL, ifindex, nltarget_kernel, tb,
&recvbuf,
virNetDevVPortProfileGetLldpadPid);
@@ -751,7 +755,8 @@ static int
virNetDevVPortProfileOp8021Qbg(const char *ifname,
const unsigned char *macaddr,
const virNetDevVPortProfilePtr virtPort,
- enum virNetDevVPortProfileLinkOp virtPortOp)
+ enum virNetDevVPortProfileLinkOp virtPortOp,
+ bool setlink_only)
{
int rc = 0;
int op = PORT_REQUEST_ASSOCIATE;
@@ -804,7 +809,8 @@ virNetDevVPortProfileOp8021Qbg(const char *ifname,
virtPort->u.virtPort8021Qbg.instanceID,
NULL,
vf,
- op);
+ op,
+ setlink_only);
err_exit:
@@ -892,7 +898,8 @@ virNetDevVPortProfileOp8021Qbh(const char *ifname,
(virtPortOp ==
VIR_NETDEV_VPORT_PROFILE_LINK_OP_PREASSOCIATE_RR) ?
PORT_REQUEST_PREASSOCIATE_RR
- : PORT_REQUEST_ASSOCIATE);
+ : PORT_REQUEST_ASSOCIATE,
+ false);
if (rc == -2)
/* Association timed out, disassociate */
virNetDevVPortProfileOpCommon(NULL, ifindex,
@@ -904,7 +911,8 @@ virNetDevVPortProfileOp8021Qbh(const char *ifname,
NULL,
NULL,
vf,
- PORT_REQUEST_DISASSOCIATE);
+ PORT_REQUEST_DISASSOCIATE,
+ false);
break;
case VIR_NETDEV_VPORT_PROFILE_LINK_OP_DISASSOCIATE:
@@ -917,7 +925,8 @@ virNetDevVPortProfileOp8021Qbh(const char *ifname,
NULL,
NULL,
vf,
- PORT_REQUEST_DISASSOCIATE);
+ PORT_REQUEST_DISASSOCIATE,
+ false);
break;
default:
@@ -938,6 +947,7 @@ err_exit:
* @virtPort: pointer to the object holding port profile parameters
* @vmuuid : the UUID of the virtual machine
* @vmOp : The VM operation (i.e., create, no-op)
+ * @setlink_only : Only set the link - dont wait for the link to come up
*
* Associate a port on a swtich with a profile. This function
* may notify a kernel driver or an external daemon to run
@@ -954,7 +964,8 @@ virNetDevVPortProfileAssociate(const char *macvtap_ifname,
const unsigned char *macvtap_macaddr,
const char *linkdev,
const unsigned char *vmuuid,
- enum virNetDevVPortProfileOp vmOp)
+ enum virNetDevVPortProfileOp vmOp,
+ bool setlink_only)
{
int rc = 0;
@@ -977,7 +988,8 @@ virNetDevVPortProfileAssociate(const char *macvtap_ifname,
virtPort,
(vmOp ==
VIR_NETDEV_VPORT_PROFILE_OP_MIGRATE_IN_START)
?
VIR_NETDEV_VPORT_PROFILE_LINK_OP_PREASSOCIATE
- :
VIR_NETDEV_VPORT_PROFILE_LINK_OP_ASSOCIATE);
+ :
VIR_NETDEV_VPORT_PROFILE_LINK_OP_ASSOCIATE,
+ setlink_only);
break;
case VIR_NETDEV_VPORT_PROFILE_8021QBH:
@@ -1035,7 +1047,7 @@ virNetDevVPortProfileDisassociate(const char *macvtap_ifname,
case VIR_NETDEV_VPORT_PROFILE_8021QBG:
rc = virNetDevVPortProfileOp8021Qbg(macvtap_ifname, macvtap_macaddr,
virtPort,
-
VIR_NETDEV_VPORT_PROFILE_LINK_OP_DISASSOCIATE);
+
VIR_NETDEV_VPORT_PROFILE_LINK_OP_DISASSOCIATE, false);
break;
case VIR_NETDEV_VPORT_PROFILE_8021QBH:
@@ -1058,7 +1070,8 @@ int virNetDevVPortProfileAssociate(const char *macvtap_ifname
ATTRIBUTE_UNUSED,
const unsigned char *macvtap_macaddr ATTRIBUTE_UNUSED,
const char *linkdev ATTRIBUTE_UNUSED,
const unsigned char *vmuuid ATTRIBUTE_UNUSED,
- enum virNetDevVPortProfileOp vmOp ATTRIBUTE_UNUSED)
+ enum virNetDevVPortProfileOp vmOp ATTRIBUTE_UNUSED,
+ bool setlink_only)
{
virReportSystemError(ENOSYS, "%s",
_("Virtual port profile association not supported on this
platform"));
diff --git a/src/util/virnetdevvportprofile.h b/src/util/virnetdevvportprofile.h
index ec2d06d..eb9f2b1 100644
--- a/src/util/virnetdevvportprofile.h
+++ b/src/util/virnetdevvportprofile.h
@@ -86,7 +86,8 @@ int virNetDevVPortProfileAssociate(const char *ifname,
const unsigned char *macaddr,
const char *linkdev,
const unsigned char *vmuuid,
- enum virNetDevVPortProfileOp vmOp)
+ enum virNetDevVPortProfileOp vmOp,
+ bool setlink_only)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4)
ATTRIBUTE_NONNULL(5) ATTRIBUTE_RETURN_CHECK;
--
1.7.7.6
4650
days inactive
4650
days old
2 comments
1 participants
participants (1)
-
Laine Stump