X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Froute-table.c;h=2986d3d9a186715f744cd3048bb4ef3792d22c82;hb=41ca1e0afb4b261a217c9fdaf672ef606e8434f9;hp=83a666ef3636ca7c0c15e02c175e0725b7c1bced;hpb=cceb11f5b12d09cc8afc87ca4fd03e941234d439;p=sliver-openvswitch.git diff --git a/lib/route-table.c b/lib/route-table.c index 83a666ef3..2986d3d9a 100644 --- a/lib/route-table.c +++ b/lib/route-table.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011 Nicira Networks. + * Copyright (c) 2011, 2012, 2013, 2014 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,7 +18,6 @@ #include "route-table.h" -#include #include #include #include @@ -27,9 +26,10 @@ #include "hash.h" #include "hmap.h" #include "netlink.h" +#include "netlink-notifier.h" #include "netlink-socket.h" #include "ofpbuf.h" -#include "rtnetlink.h" +#include "rtnetlink-link.h" #include "vlog.h" VLOG_DEFINE_THIS_MODULE(route_table); @@ -56,15 +56,29 @@ struct route_node { struct route_data rd; /* Data associated with this node. */ }; +struct name_node { + struct hmap_node node; /* Node in name_map. */ + uint32_t ifi_index; /* Kernel interface index. */ + + char ifname[IFNAMSIZ]; /* Interface name. */ +}; + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20); +/* Global change number for route-table, which should be incremented + * every time route_table_reset() is called. */ +static uint64_t rt_change_seq; + static unsigned int register_count = 0; -static struct rtnetlink *rtn = NULL; +static struct nln *nln = NULL; static struct route_table_msg rtmsg; -static struct rtnetlink_notifier notifier; +static struct nln_notifier *route_notifier = NULL; +static struct nln_notifier *name_notifier = NULL; static bool route_table_valid = false; +static bool name_table_valid = false; static struct hmap route_map; +static struct hmap name_map; static int route_table_reset(void); static void route_table_handle_msg(const struct route_table_msg *); @@ -75,6 +89,39 @@ static struct route_node *route_node_lookup_by_ip(uint32_t ip); static void route_map_clear(void); static uint32_t hash_route_data(const struct route_data *); +static void name_table_init(void); +static void name_table_uninit(void); +static int name_table_reset(void); +static void name_table_change(const struct rtnetlink_link_change *, void *); +static void name_map_clear(void); +static struct name_node *name_node_lookup(int ifi_index); + +/* Populates 'name' with the name of the interface traffic destined for 'ip' + * is likely to egress out of (see route_table_get_ifindex). + * + * Returns true if successful, otherwise false. */ +bool +route_table_get_name(ovs_be32 ip, char name[IFNAMSIZ]) +{ + int ifindex; + + if (!name_table_valid) { + name_table_reset(); + } + + if (route_table_get_ifindex(ip, &ifindex)) { + struct name_node *nn; + + nn = name_node_lookup(ifindex); + if (nn) { + ovs_strlcpy(name, nn->ifname, IFNAMSIZ); + return true; + } + } + + return false; +} + /* Populates 'ifindex' with the interface index traffic destined for 'ip' is * likely to egress. There is no hard guarantee that traffic destined for 'ip' * will egress out the specified interface. 'ifindex' may refer to an @@ -111,25 +158,31 @@ route_table_get_ifindex(ovs_be32 ip_, int *ifindex) return false; } +uint64_t +route_table_get_change_seq(void) +{ + return rt_change_seq; +} + /* Users of the route_table module should register themselves with this * function before making any other route_table function calls. */ void route_table_register(void) { if (!register_count) { - rtnetlink_parse_func *pf; - rtnetlink_notify_func *nf; - - assert(!rtn); + ovs_assert(!nln); + ovs_assert(!route_notifier); - pf = (rtnetlink_parse_func *) route_table_parse; - nf = (rtnetlink_notify_func *) route_table_change; + nln = nln_create(NETLINK_ROUTE, RTNLGRP_IPV4_ROUTE, + (nln_parse_func *) route_table_parse, &rtmsg); - rtn = rtnetlink_create(RTNLGRP_IPV4_ROUTE, pf, &rtmsg); - rtnetlink_notifier_register(rtn, ¬ifier, nf, NULL); + route_notifier = + nln_notifier_create(nln, (nln_notify_func *) route_table_change, + NULL); hmap_init(&route_map); route_table_reset(); + name_table_init(); } register_count++; @@ -144,11 +197,14 @@ route_table_unregister(void) register_count--; if (!register_count) { - rtnetlink_destroy(rtn); - rtn = NULL; + nln_notifier_destroy(route_notifier); + route_notifier = NULL; + nln_destroy(nln); + nln = NULL; route_map_clear(); hmap_destroy(&route_map); + name_table_uninit(); } } @@ -156,8 +212,13 @@ route_table_unregister(void) void route_table_run(void) { - if (rtn) { - rtnetlink_notifier_run(rtn); + if (nln) { + rtnetlink_link_run(); + nln_run(nln); + + if (!route_table_valid) { + route_table_reset(); + } } } @@ -165,29 +226,23 @@ route_table_run(void) void route_table_wait(void) { - if (rtn) { - rtnetlink_notifier_wait(rtn); + if (nln) { + rtnetlink_link_wait(); + nln_wait(nln); } } static int route_table_reset(void) { - int error; struct nl_dump dump; struct rtgenmsg *rtmsg; - struct ofpbuf request, reply; - static struct nl_sock *rtnl_sock; + uint64_t reply_stub[NL_DUMP_BUFSIZE / 8]; + struct ofpbuf request, reply, buf; route_map_clear(); route_table_valid = true; - - error = nl_sock_create(NETLINK_ROUTE, &rtnl_sock); - if (error) { - VLOG_WARN_RL(&rl, "failed to reset routing table, " - "cannot create RTNETLINK_ROUTE socket"); - return error; - } + rt_change_seq++; ofpbuf_init(&request, 0); @@ -196,20 +251,20 @@ route_table_reset(void) rtmsg = ofpbuf_put_zeros(&request, sizeof *rtmsg); rtmsg->rtgen_family = AF_INET; - nl_dump_start(&dump, rtnl_sock, &request); + nl_dump_start(&dump, NETLINK_ROUTE, &request); + ofpbuf_uninit(&request); - while (nl_dump_next(&dump, &reply)) { + ofpbuf_use_stub(&buf, reply_stub, sizeof reply_stub); + while (nl_dump_next(&dump, &reply, &buf)) { struct route_table_msg msg; if (route_table_parse(&reply, &msg)) { route_table_handle_msg(&msg); } } + ofpbuf_uninit(&buf); - error = nl_dump_done(&dump); - nl_sock_destroy(rtnl_sock); - - return error; + return nl_dump_done(&dump); } @@ -223,7 +278,7 @@ route_table_parse(struct ofpbuf *buf, struct route_table_msg *change) [RTA_OIF] = { .type = NL_A_U32, .optional = false }, }; - static struct nlattr *attrs[ARRAY_SIZE(policy)]; + struct nlattr *attrs[ARRAY_SIZE(policy)]; parsed = nl_policy_parse(buf, NLMSG_HDRLEN + sizeof(struct rtmsg), policy, attrs, ARRAY_SIZE(policy)); @@ -232,8 +287,8 @@ route_table_parse(struct ofpbuf *buf, struct route_table_msg *change) const struct rtmsg *rtm; const struct nlmsghdr *nlmsg; - nlmsg = buf->data; - rtm = (const struct rtmsg *) ((const char *) buf->data + NLMSG_HDRLEN); + nlmsg = ofpbuf_data(buf); + rtm = ofpbuf_at(buf, NLMSG_HDRLEN, sizeof *rtm); if (rtm->rtm_family != AF_INET) { VLOG_DBG_RL(&rl, "received non AF_INET rtnetlink route message"); @@ -345,3 +400,95 @@ hash_route_data(const struct route_data *rd) { return hash_bytes(rd, sizeof *rd, 0); } + +/* name_table . */ + +static void +name_table_init(void) +{ + hmap_init(&name_map); + name_notifier = rtnetlink_link_notifier_create(name_table_change, NULL); + name_table_valid = false; +} + +static void +name_table_uninit(void) +{ + rtnetlink_link_notifier_destroy(name_notifier); + name_notifier = NULL; + name_map_clear(); + hmap_destroy(&name_map); +} + +static int +name_table_reset(void) +{ + struct nl_dump dump; + struct rtgenmsg *rtmsg; + uint64_t reply_stub[NL_DUMP_BUFSIZE / 8]; + struct ofpbuf request, reply, buf; + + name_table_valid = true; + name_map_clear(); + + ofpbuf_init(&request, 0); + nl_msg_put_nlmsghdr(&request, sizeof *rtmsg, RTM_GETLINK, NLM_F_REQUEST); + rtmsg = ofpbuf_put_zeros(&request, sizeof *rtmsg); + rtmsg->rtgen_family = AF_INET; + + nl_dump_start(&dump, NETLINK_ROUTE, &request); + ofpbuf_uninit(&request); + + ofpbuf_use_stub(&buf, reply_stub, sizeof reply_stub); + while (nl_dump_next(&dump, &reply, &buf)) { + struct rtnetlink_link_change change; + + if (rtnetlink_link_parse(&reply, &change) + && change.nlmsg_type == RTM_NEWLINK + && !name_node_lookup(change.ifi_index)) { + struct name_node *nn; + + nn = xzalloc(sizeof *nn); + nn->ifi_index = change.ifi_index; + ovs_strlcpy(nn->ifname, change.ifname, IFNAMSIZ); + hmap_insert(&name_map, &nn->node, hash_int(nn->ifi_index, 0)); + } + } + ofpbuf_uninit(&buf); + return nl_dump_done(&dump); +} + +static void +name_table_change(const struct rtnetlink_link_change *change OVS_UNUSED, + void *aux OVS_UNUSED) +{ + /* Changes to interface status can cause routing table changes that some + * versions of the linux kernel do not advertise for some reason. */ + route_table_valid = false; + name_table_valid = false; +} + +static struct name_node * +name_node_lookup(int ifi_index) +{ + struct name_node *nn; + + HMAP_FOR_EACH_WITH_HASH(nn, node, hash_int(ifi_index, 0), &name_map) { + if (nn->ifi_index == ifi_index) { + return nn; + } + } + + return NULL; +} + +static void +name_map_clear(void) +{ + struct name_node *nn, *nn_next; + + HMAP_FOR_EACH_SAFE(nn, nn_next, node, &name_map) { + hmap_remove(&name_map, &nn->node); + free(nn); + } +}