X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Froute-table.c;h=2986d3d9a186715f744cd3048bb4ef3792d22c82;hb=41ca1e0afb4b261a217c9fdaf672ef606e8434f9;hp=440db8fd48ac02c9a4b7451c02775792b5d74b08;hpb=db2dede403921e8935b53a07c9e908c05edd4c85;p=sliver-openvswitch.git diff --git a/lib/route-table.c b/lib/route-table.c index 440db8fd4..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,32 @@ 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 *); static bool route_table_parse(struct ofpbuf *, struct route_table_msg *); static void route_table_change(const struct route_table_msg *, void *); static struct route_node *route_node_lookup(const struct route_data *); @@ -72,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 @@ -86,6 +136,10 @@ route_table_get_ifindex(ovs_be32 ip_, int *ifindex) *ifindex = 0; + if (!route_table_valid) { + route_table_reset(); + } + rn = route_node_lookup_by_ip(ip); if (rn) { @@ -104,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; + ovs_assert(!nln); + ovs_assert(!route_notifier); - assert(!rtn); + nln = nln_create(NETLINK_ROUTE, RTNLGRP_IPV4_ROUTE, + (nln_parse_func *) route_table_parse, &rtmsg); - pf = (rtnetlink_parse_func *) route_table_parse; - nf = (rtnetlink_notify_func *) route_table_change; - - 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++; @@ -137,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(); } } @@ -149,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(); + } } } @@ -158,28 +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(); - - error = nl_sock_create(NETLINK_ROUTE, 0, 0, 0, &rtnl_sock); - if (error) { - VLOG_WARN_RL(&rl, "failed to reset routing table, " - "cannot create RTNETLINK_ROUTE socket"); - return error; - } + route_table_valid = true; + rt_change_seq++; ofpbuf_init(&request, 0); @@ -188,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_change(&msg, NULL); + 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); } @@ -215,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)); @@ -224,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"); @@ -260,35 +323,23 @@ route_table_parse(struct ofpbuf *buf, struct route_table_msg *change) } static void -route_table_change(const struct route_table_msg *change, void *aux OVS_UNUSED) +route_table_change(const struct route_table_msg *change OVS_UNUSED, + void *aux OVS_UNUSED) { - if (!change) { - VLOG_DBG_RL(&rl, "received NULL change message"); - route_table_reset(); - } else if (!change->relevant) { - VLOG_DBG_RL(&rl, "ignoring irrelevant change message"); - } else if (change->nlmsg_type == RTM_NEWROUTE) { - if (!route_node_lookup(&change->rd)) { - struct route_node *rn; - - rn = xzalloc(sizeof *rn); - memcpy(&rn->rd, &change->rd, sizeof change->rd); - - hmap_insert(&route_map, &rn->node, hash_route_data(&rn->rd)); - } else { - VLOG_DBG_RL(&rl, "skipping insertion of duplicate route entry"); - } - } else if (change->nlmsg_type == RTM_DELROUTE) { + route_table_valid = false; +} + +static void +route_table_handle_msg(const struct route_table_msg *change) +{ + if (change->relevant && change->nlmsg_type == RTM_NEWROUTE && + !route_node_lookup(&change->rd)) { struct route_node *rn; - rn = route_node_lookup(&change->rd); + rn = xzalloc(sizeof *rn); + memcpy(&rn->rd, &change->rd, sizeof change->rd); - if (rn) { - hmap_remove(&route_map, &rn->node); - free(rn); - } else { - VLOG_DBG_RL(&rl, "skipping deletion of non-existent route entry"); - } + hmap_insert(&route_map, &rn->node, hash_route_data(&rn->rd)); } } @@ -349,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); + } +}