lib/netlink-socket.c \
lib/netlink-socket.h \
lib/rtnetlink.c \
- lib/rtnetlink.h
+ lib/rtnetlink.h \
+ lib/rtnetlink-link.c \
+ lib/rtnetlink-link.h
endif
if HAVE_OPENSSL
#include "openvswitch/tunnel.h"
#include "poll-loop.h"
#include "rtnetlink.h"
+#include "rtnetlink-link.h"
#include "shash.h"
#include "svec.h"
#include "util.h"
static int create_minor(const char *name, int minor, struct dpif **dpifp);
static int open_minor(int minor, struct dpif **dpifp);
static int make_openvswitch_device(int minor, char **fnp);
-static void dpif_linux_port_changed(const struct rtnetlink_change *,
+static void dpif_linux_port_changed(const struct rtnetlink_link_change *,
void *dpif);
static struct dpif_linux *
dpif_linux_close(struct dpif *dpif_)
{
struct dpif_linux *dpif = dpif_linux_cast(dpif_);
- rtnetlink_notifier_unregister(&dpif->port_notifier);
+ rtnetlink_link_notifier_unregister(&dpif->port_notifier);
shash_destroy(&dpif->changed_ports);
free(dpif->local_ifname);
close(dpif->fd);
if (!shash_is_empty(&dpif->changed_ports) || dpif->change_error) {
poll_immediate_wake();
} else {
- rtnetlink_notifier_wait();
+ rtnetlink_link_notifier_wait();
}
}
fd = open(fn, O_RDONLY | O_NONBLOCK);
if (fd >= 0) {
struct dpif_linux *dpif = xmalloc(sizeof *dpif);
- error = rtnetlink_notifier_register(&dpif->port_notifier,
- dpif_linux_port_changed, dpif);
+ error = rtnetlink_link_notifier_register(&dpif->port_notifier,
+ dpif_linux_port_changed,
+ dpif);
if (!error) {
char *name;
}
static void
-dpif_linux_port_changed(const struct rtnetlink_change *change, void *dpif_)
+dpif_linux_port_changed(const struct rtnetlink_link_change *change,
+ void *dpif_)
{
struct dpif_linux *dpif = dpif_;
#include "packets.h"
#include "poll-loop.h"
#include "rtnetlink.h"
+#include "rtnetlink-link.h"
#include "socket-util.h"
#include "shash.h"
#include "svec.h"
static void
netdev_linux_run(void)
{
- rtnetlink_notifier_run();
+ rtnetlink_link_notifier_run();
}
static void
netdev_linux_wait(void)
{
- rtnetlink_notifier_wait();
+ rtnetlink_link_notifier_wait();
}
static void
-netdev_linux_cache_cb(const struct rtnetlink_change *change,
+netdev_linux_cache_cb(const struct rtnetlink_link_change *change,
void *aux OVS_UNUSED)
{
struct netdev_dev_linux *dev;
}
if (!cache_notifier_refcount) {
- error = rtnetlink_notifier_register(&netdev_linux_cache_notifier,
- netdev_linux_cache_cb, NULL);
+ error = rtnetlink_link_notifier_register(&netdev_linux_cache_notifier,
+ netdev_linux_cache_cb, NULL);
if (error) {
return error;
}
cache_notifier_refcount--;
if (!cache_notifier_refcount) {
- rtnetlink_notifier_unregister(&netdev_linux_cache_notifier);
+ rtnetlink_link_notifier_unregister(&netdev_linux_cache_notifier);
}
} else if (class == &netdev_tap_class) {
destroy_tap(netdev_dev);
}
static void
-netdev_linux_poll_cb(const struct rtnetlink_change *change,
+netdev_linux_poll_cb(const struct rtnetlink_link_change *change,
void *aux OVS_UNUSED)
{
if (change) {
struct list *list;
if (shash_is_empty(&netdev_linux_notifiers)) {
- int error = rtnetlink_notifier_register(&netdev_linux_poll_notifier,
- netdev_linux_poll_cb, NULL);
+ int error;
+ error = rtnetlink_link_notifier_register(&netdev_linux_poll_notifier,
+ netdev_linux_poll_cb, NULL);
if (error) {
return error;
}
/* If that was the last notifier, unregister. */
if (shash_is_empty(&netdev_linux_notifiers)) {
- rtnetlink_notifier_unregister(&netdev_linux_poll_notifier);
+ rtnetlink_link_notifier_unregister(&netdev_linux_poll_notifier);
}
}
--- /dev/null
+/*
+ * Copyright (c) 2009, 2010 Nicira Networks.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <config.h>
+
+#include "rtnetlink-link.h"
+
+#include <sys/socket.h>
+#include <linux/rtnetlink.h>
+#include <net/if.h>
+
+#include "netlink.h"
+#include "ofpbuf.h"
+#include "rtnetlink.h"
+
+static struct rtnetlink *rtn = NULL;
+static struct rtnetlink_link_change rtn_change;
+
+static bool
+rtnetlink_link_parse(struct ofpbuf *buf,
+ struct rtnetlink_link_change *change)
+{
+ bool parsed;
+
+ /* Policy for RTNLGRP_LINK messages.
+ *
+ * There are *many* more fields in these messages, but currently we
+ * only care about these fields. */
+ static const struct nl_policy policy[] = {
+ [IFLA_IFNAME] = { .type = NL_A_STRING, .optional = false },
+ [IFLA_MASTER] = { .type = NL_A_U32, .optional = true },
+ };
+
+ static struct nlattr *attrs[ARRAY_SIZE(policy)];
+
+ parsed = nl_policy_parse(buf, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
+ policy, attrs, ARRAY_SIZE(policy));
+
+ if (parsed) {
+ const struct nlmsghdr *nlmsg;
+ const struct ifinfomsg *ifinfo;
+
+ nlmsg = buf->data;
+ ifinfo = ((const struct ifinfomsg *)
+ ((const char *) buf->data + NLMSG_HDRLEN));
+
+ change->nlmsg_type = nlmsg->nlmsg_type;
+ change->ifi_index = ifinfo->ifi_index;
+ change->ifname = nl_attr_get_string(attrs[IFLA_IFNAME]);
+ change->master_ifindex = (attrs[IFLA_MASTER]
+ ? nl_attr_get_u32(attrs[IFLA_MASTER])
+ : 0);
+ }
+
+ return parsed;
+}
+
+/* Registers 'cb' to be called with auxiliary data 'aux' with network device
+ * change notifications. The notifier is stored in 'notifier', which the
+ * caller must not modify or free.
+ *
+ * This is probably not the function that you want. You should probably be
+ * using dpif_port_poll() or netdev_monitor_create(), which unlike this
+ * function are not Linux-specific.
+ *
+ * Returns 0 if successful, otherwise a positive errno value. */
+int
+rtnetlink_link_notifier_register(struct rtnetlink_notifier *notifier,
+ rtnetlink_link_notify_func *cb, void *aux)
+{
+ rtnetlink_parse_func *pf = (rtnetlink_parse_func *) rtnetlink_link_parse;
+ rtnetlink_notify_func *nf = (rtnetlink_notify_func *) cb;
+
+ if (!rtn) {
+ rtn = rtnetlink_create(RTNLGRP_LINK, pf, &rtn_change);
+ }
+
+ return rtnetlink_notifier_register(rtn, notifier, nf, aux);
+}
+
+/* Cancels notification on 'notifier', which must have previously been
+ * registered with rtnetlink_link_notifier_register(). */
+void
+rtnetlink_link_notifier_unregister(struct rtnetlink_notifier *notifier)
+{
+ rtnetlink_notifier_unregister(rtn, notifier);
+}
+
+/* Calls all of the registered notifiers, passing along any as-yet-unreported
+ * netdev change events. */
+void
+rtnetlink_link_notifier_run(void)
+{
+ if (rtn) {
+ rtnetlink_notifier_run(rtn);
+ }
+}
+
+/* Causes poll_block() to wake up when network device change notifications are
+ * ready. */
+void
+rtnetlink_link_notifier_wait(void)
+{
+ if (rtn) {
+ rtnetlink_notifier_wait(rtn);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2009 Nicira Networks.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RTNETLINK_LINK_H
+#define RTNETLINK_LINK_H 1
+
+struct rtnetlink_notifier;
+
+/* These functions are Linux specific, so they should be used directly only by
+ * Linux-specific code. */
+
+/* A digested version of an rtnetlink_link message sent down by the kernel to
+ * indicate that a network device has been created, destroyed or changed. */
+struct rtnetlink_link_change {
+ /* Copied from struct nlmsghdr. */
+ int nlmsg_type; /* e.g. RTM_NEWLINK, RTM_DELLINK. */
+
+ /* Copied from struct ifinfomsg. */
+ int ifi_index; /* Index of network device. */
+
+ /* Extracted from Netlink attributes. */
+ const char *ifname; /* Name of network device. */
+ int master_ifindex; /* Ifindex of datapath master (0 if none). */
+};
+
+/* Function called to report that a netdev has changed. 'change' describes the
+ * specific change. It may be null if the buffer of change information
+ * overflowed, in which case the function must assume that every device may
+ * have changed. 'aux' is as specified in the call to
+ * rtnetlink_link_notifier_register(). */
+typedef
+void rtnetlink_link_notify_func(const struct rtnetlink_link_change *change,
+ void *aux);
+
+int rtnetlink_link_notifier_register(struct rtnetlink_notifier *,
+ rtnetlink_link_notify_func *, void *aux);
+void rtnetlink_link_notifier_unregister(struct rtnetlink_notifier *);
+void rtnetlink_link_notifier_run(void);
+void rtnetlink_link_notifier_wait(void);
+#endif /* rtnetlink-link.h */
#include "rtnetlink.h"
#include <errno.h>
-#include <sys/socket.h>
-#include <linux/rtnetlink.h>
-#include <net/if.h>
#include <poll.h>
#include "coverage.h"
COVERAGE_DEFINE(rtnetlink_changed);
-/* rtnetlink socket. */
-static struct nl_sock *notify_sock;
+static void rtnetlink_report(struct rtnetlink *rtn, void *change);
+
+struct rtnetlink {
+ struct nl_sock *notify_sock; /* Rtnetlink socket. */
+ struct list all_notifiers; /* All rtnetlink notifiers. */
+
+ /* Passed in by rtnetlink_create(). */
+ int multicast_group; /* Multicast group we listen on. */
+ rtnetlink_parse_func *parse; /* Message parsing function. */
+ void *change; /* Change passed to parse. */
+};
+
+/* Creates an rtnetlink handle which may be used to manage change
+ * notifications. The created handle will listen for rtnetlink messages on
+ * 'multicast_group'. Incoming messages will be parsed with 'parse' which will
+ * be passed 'change' as an argument. */
+struct rtnetlink *
+rtnetlink_create(int multicast_group, rtnetlink_parse_func *parse,
+ void *change)
+{
+ struct rtnetlink *rtn;
-/* All registered notifiers. */
-static struct list all_notifiers = LIST_INITIALIZER(&all_notifiers);
+ rtn = xzalloc(sizeof *rtn);
+ rtn->notify_sock = 0;
+ rtn->multicast_group = multicast_group;
+ rtn->parse = parse;
+ rtn->change = change;
-static void rtnetlink_report_change(const struct nlmsghdr *,
- const struct ifinfomsg *,
- struct nlattr *attrs[]);
-static void rtnetlink_report_notify_error(void);
+ list_init(&rtn->all_notifiers);
+ return rtn;
+}
-/* Registers 'cb' to be called with auxiliary data 'aux' with network device
- * change notifications. The notifier is stored in 'notifier', which the
- * caller must not modify or free.
+/* Registers 'cb' to be called with auxiliary data 'aux' with change
+ * notifications. The notifier is stored in 'notifier', which the caller must
+ * not modify or free.
*
- * This is probably not the function that you want. You should probably be
- * using dpif_port_poll() or netdev_monitor_create(), which unlike this
- * function are not Linux-specific.
+ * This is probably not the function you want. You should probably be using
+ * message specific notifiers like rtnetlink_link_notifier_register().
*
* Returns 0 if successful, otherwise a positive errno value. */
int
-rtnetlink_notifier_register(struct rtnetlink_notifier *notifier,
+rtnetlink_notifier_register(struct rtnetlink *rtn,
+ struct rtnetlink_notifier *notifier,
rtnetlink_notify_func *cb, void *aux)
{
- if (!notify_sock) {
- int error = nl_sock_create(NETLINK_ROUTE, RTNLGRP_LINK, 0, 0,
- ¬ify_sock);
+ if (!rtn->notify_sock) {
+ int error = nl_sock_create(NETLINK_ROUTE, rtn->multicast_group, 0, 0,
+ &rtn->notify_sock);
if (error) {
VLOG_WARN("could not create rtnetlink socket: %s",
strerror(error));
} else {
/* Catch up on notification work so that the new notifier won't
* receive any stale notifications. */
- rtnetlink_notifier_run();
+ rtnetlink_notifier_run(rtn);
}
- list_push_back(&all_notifiers, ¬ifier->node);
+ list_push_back(&rtn->all_notifiers, ¬ifier->node);
notifier->cb = cb;
notifier->aux = aux;
return 0;
/* Cancels notification on 'notifier', which must have previously been
* registered with rtnetlink_notifier_register(). */
void
-rtnetlink_notifier_unregister(struct rtnetlink_notifier *notifier)
+rtnetlink_notifier_unregister(struct rtnetlink *rtn,
+ struct rtnetlink_notifier *notifier)
{
list_remove(¬ifier->node);
- if (list_is_empty(&all_notifiers)) {
- nl_sock_destroy(notify_sock);
- notify_sock = NULL;
+ if (list_is_empty(&rtn->all_notifiers)) {
+ nl_sock_destroy(rtn->notify_sock);
+ rtn->notify_sock = NULL;
}
}
/* Calls all of the registered notifiers, passing along any as-yet-unreported
- * netdev change events. */
+ * change events. */
void
-rtnetlink_notifier_run(void)
+rtnetlink_notifier_run(struct rtnetlink *rtn)
{
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
- if (!notify_sock) {
+ if (!rtn->notify_sock) {
return;
}
for (;;) {
- /* Policy for RTNLGRP_LINK messages.
- *
- * There are *many* more fields in these messages, but currently we
- * only care about these fields. */
- static const struct nl_policy rtnetlink_policy[] = {
- [IFLA_IFNAME] = { .type = NL_A_STRING, .optional = false },
- [IFLA_MASTER] = { .type = NL_A_U32, .optional = true },
- };
-
- struct nlattr *attrs[ARRAY_SIZE(rtnetlink_policy)];
struct ofpbuf *buf;
int error;
- error = nl_sock_recv(notify_sock, &buf, false);
+ error = nl_sock_recv(rtn->notify_sock, &buf, false);
if (!error) {
- if (nl_policy_parse(buf, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
- rtnetlink_policy,
- attrs, ARRAY_SIZE(rtnetlink_policy))) {
- struct ifinfomsg *ifinfo;
-
- ifinfo = (void *) ((char *) buf->data + NLMSG_HDRLEN);
- rtnetlink_report_change(buf->data, ifinfo, attrs);
+ if (rtn->parse(buf, rtn->change)) {
+ rtnetlink_report(rtn, rtn->change);
} else {
VLOG_WARN_RL(&rl, "received bad rtnl message");
- rtnetlink_report_notify_error();
+ rtnetlink_report(rtn, NULL);
}
ofpbuf_delete(buf);
} else if (error == EAGAIN) {
VLOG_WARN_RL(&rl, "error reading rtnetlink socket: %s",
strerror(error));
}
- rtnetlink_report_notify_error();
+ rtnetlink_report(rtn, NULL);
}
}
}
-/* Causes poll_block() to wake up when network device change notifications are
- * ready. */
+/* Causes poll_block() to wake up when change notifications are ready. */
void
-rtnetlink_notifier_wait(void)
+rtnetlink_notifier_wait(struct rtnetlink *rtn)
{
- if (notify_sock) {
- nl_sock_wait(notify_sock, POLLIN);
+ if (rtn->notify_sock) {
+ nl_sock_wait(rtn->notify_sock, POLLIN);
}
}
static void
-rtnetlink_report_change(const struct nlmsghdr *nlmsg,
- const struct ifinfomsg *ifinfo,
- struct nlattr *attrs[])
+rtnetlink_report(struct rtnetlink *rtn, void *change)
{
struct rtnetlink_notifier *notifier;
- struct rtnetlink_change change;
- COVERAGE_INC(rtnetlink_changed);
-
- change.nlmsg_type = nlmsg->nlmsg_type;
- change.ifi_index = ifinfo->ifi_index;
- change.ifname = nl_attr_get_string(attrs[IFLA_IFNAME]);
- change.master_ifindex = (attrs[IFLA_MASTER]
- ? nl_attr_get_u32(attrs[IFLA_MASTER]) : 0);
-
- LIST_FOR_EACH (notifier, node, &all_notifiers) {
- notifier->cb(&change, notifier->aux);
+ if (change) {
+ COVERAGE_INC(rtnetlink_changed);
}
-}
-static void
-rtnetlink_report_notify_error(void)
-{
- struct rtnetlink_notifier *notifier;
-
- LIST_FOR_EACH (notifier, node, &all_notifiers) {
- notifier->cb(NULL, notifier->aux);
+ LIST_FOR_EACH (notifier, node, &rtn->all_notifiers) {
+ notifier->cb(change, notifier->aux);
}
}
+
#include "list.h"
-/* A digested version of an rtnetlink message sent down by the kernel to
- * indicate that a network device has been created or destroyed or changed. */
-struct rtnetlink_change {
- /* Copied from struct nlmsghdr. */
- int nlmsg_type; /* e.g. RTM_NEWLINK, RTM_DELLINK. */
-
- /* Copied from struct ifinfomsg. */
- int ifi_index; /* Index of network device. */
-
- /* Extracted from Netlink attributes. */
- const char *ifname; /* Name of network device. */
- int master_ifindex; /* Ifindex of datapath master (0 if none). */
-};
+struct rtnetlink;
+struct nlattr;
+struct ofpbuf;
+
+/* Function called to report rtnetlink notifications. 'change' describes the
+ * specific change filled out by an rtnetlink_parse_func. It may be null if
+ * the buffer of change information overflowed, in which case the function must
+ * assume that everything may have changed. 'aux' is as specified in
+ * rtnetlink_notifier_register().
+ */
+typedef void rtnetlink_notify_func(const void *change, void *aux);
-/* Function called to report that a netdev has changed. 'change' describes the
- * specific change. It may be null if the buffer of change information
- * overflowed, in which case the function must assume that every device may
- * have changed. 'aux' is as specified in the call to
- * rtnetlink_notifier_register(). */
-typedef void rtnetlink_notify_func(const struct rtnetlink_change *, void *aux);
+/* Function called to parse incoming rtnetlink notifications. The 'buf'
+ * message should be parsed into 'change' as specified in rtnetlink_create().
+ */
+typedef bool rtnetlink_parse_func(struct ofpbuf *buf, void *change);
struct rtnetlink_notifier {
struct list node;
void *aux;
};
-int rtnetlink_notifier_register(struct rtnetlink_notifier *,
+struct rtnetlink *rtnetlink_create(int multicast_group,
+ rtnetlink_parse_func *,
+ void *change);
+int rtnetlink_notifier_register(struct rtnetlink *,
+ struct rtnetlink_notifier *,
rtnetlink_notify_func *, void *aux);
-void rtnetlink_notifier_unregister(struct rtnetlink_notifier *);
-void rtnetlink_notifier_run(void);
-void rtnetlink_notifier_wait(void);
-
+void rtnetlink_notifier_unregister(struct rtnetlink *,
+ struct rtnetlink_notifier *);
+void rtnetlink_notifier_run(struct rtnetlink *);
+void rtnetlink_notifier_wait(struct rtnetlink *);
#endif /* rtnetlink.h */
projects / openvswitch / commitdiff