lib/tnl-ports.c

   1 /*
   2  * Copyright (c) 2014, 2015 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include <stddef.h>
  19 #include <stdint.h>
  20
  21 #include "classifier.h"
  22 #include "dynamic-string.h"
  23 #include "hash.h"
  24 #include "ofpbuf.h"
  25 #include "ovs-thread.h"
  26 #include "odp-util.h"
  27 #include "tnl-arp-cache.h"
  28 #include "tnl-ports.h"
  29 #include "ovs-thread.h"
  30 #include "unixctl.h"
  31 #include "util.h"
  32
  33 static struct ovs_mutex mutex = OVS_MUTEX_INITIALIZER;
  34 static struct classifier cls;   /* Tunnel ports. */
  35
  36 struct tnl_port_in {
  37     struct cls_rule cr;
  38     odp_port_t portno;
  39     struct ovs_refcount ref_cnt;
  40     char dev_name[IFNAMSIZ];
  41 };
  42
  43 static struct tnl_port_in *
  44 tnl_port_cast(const struct cls_rule *cr)
  45 {
  46     BUILD_ASSERT_DECL(offsetof(struct tnl_port_in, cr) == 0);
  47
  48     return CONTAINER_OF(cr, struct tnl_port_in, cr);
  49 }
  50
  51 static void
  52 tnl_port_free(struct tnl_port_in *p)
  53 {
  54     cls_rule_destroy(&p->cr);
  55     free(p);
  56 }
  57
  58 static void
  59 tnl_port_init_flow(struct flow *flow, ovs_be16 udp_port)
  60 {
  61     memset(flow, 0, sizeof *flow);
  62     flow->dl_type = htons(ETH_TYPE_IP);
  63     if (udp_port) {
  64         flow->nw_proto = IPPROTO_UDP;
  65     } else {
  66         flow->nw_proto = IPPROTO_GRE;
  67     }
  68     flow->tp_dst = udp_port;
  69 }
  70
  71 void
  72 tnl_port_map_insert(odp_port_t port, ovs_be16 udp_port, const char dev_name[])
  73 {
  74     const struct cls_rule *cr;
  75     struct tnl_port_in *p;
  76     struct match match;
  77
  78     memset(&match, 0, sizeof match);
  79     tnl_port_init_flow(&match.flow, udp_port);
  80
  81     ovs_mutex_lock(&mutex);
  82     do {
  83         cr = classifier_lookup(&cls, CLS_MAX_VERSION, &match.flow, NULL);
  84         p = tnl_port_cast(cr);
  85         /* Try again if the rule was released before we get the reference. */
  86     } while (p && !ovs_refcount_try_ref_rcu(&p->ref_cnt));
  87
  88     if (!p) {
  89         p = xzalloc(sizeof *p);
  90         p->portno = port;
  91
  92         match.wc.masks.dl_type = OVS_BE16_MAX;
  93         match.wc.masks.nw_proto = 0xff;
  94         match.wc.masks.nw_frag = 0xff;      /* XXX: No fragments support. */
  95         match.wc.masks.tp_dst = OVS_BE16_MAX;
  96
  97         cls_rule_init(&p->cr, &match, 0, CLS_MIN_VERSION); /* Priority == 0. */
  98         ovs_refcount_init(&p->ref_cnt);
  99         ovs_strlcpy(p->dev_name, dev_name, sizeof p->dev_name);
 100
 101         classifier_insert(&cls, &p->cr, NULL, 0);
 102     }
 103     ovs_mutex_unlock(&mutex);
 104 }
 105
 106 static void
 107 tnl_port_unref(const struct cls_rule *cr)
 108 {
 109     struct tnl_port_in *p = tnl_port_cast(cr);
 110
 111     if (cr && ovs_refcount_unref_relaxed(&p->ref_cnt) == 1) {
 112         ovs_mutex_lock(&mutex);
 113         if (classifier_remove(&cls, cr)) {
 114             ovsrcu_postpone(tnl_port_free, p);
 115         }
 116         ovs_mutex_unlock(&mutex);
 117     }
 118 }
 119
 120 void
 121 tnl_port_map_delete(ovs_be16 udp_port)
 122 {
 123     const struct cls_rule *cr;
 124     struct flow flow;
 125
 126     tnl_port_init_flow(&flow, udp_port);
 127
 128     cr = classifier_lookup(&cls, CLS_MAX_VERSION, &flow, NULL);
 129     tnl_port_unref(cr);
 130 }
 131
 132 /* 'flow' is non-const to allow for temporary modifications during the lookup.
 133  * Any changes are restored before returning. */
 134 odp_port_t
 135 tnl_port_map_lookup(struct flow *flow, struct flow_wildcards *wc)
 136 {
 137     const struct cls_rule *cr = classifier_lookup(&cls, CLS_MAX_VERSION, flow,
 138                                                   wc);
 139
 140     return (cr) ? tnl_port_cast(cr)->portno : ODPP_NONE;
 141 }
 142
 143 static void
 144 tnl_port_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
 145               const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
 146 {
 147     struct ds ds = DS_EMPTY_INITIALIZER;
 148     const struct tnl_port_in *p;
 149
 150     ds_put_format(&ds, "Listening ports:\n");
 151     CLS_FOR_EACH(p, cr, &cls) {
 152         struct odputil_keybuf keybuf;
 153         struct odputil_keybuf maskbuf;
 154         struct flow flow;
 155         const struct nlattr *key, *mask;
 156         size_t key_len, mask_len;
 157         struct flow_wildcards wc;
 158         struct ofpbuf buf;
 159         struct odp_flow_key_parms odp_parms = {
 160             .flow = &flow,
 161             .mask = &wc.masks,
 162         };
 163
 164         ds_put_format(&ds, "%s (%"PRIu32") : ", p->dev_name, p->portno);
 165         minimask_expand(&p->cr.match.mask, &wc);
 166         miniflow_expand(&p->cr.match.flow, &flow);
 167
 168         /* Key. */
 169         odp_parms.odp_in_port = flow.in_port.odp_port;
 170         odp_parms.support.recirc = true;
 171         ofpbuf_use_stack(&buf, &keybuf, sizeof keybuf);
 172         odp_flow_key_from_flow(&odp_parms, &buf);
 173         key = buf.data;
 174         key_len = buf.size;
 175
 176         /* mask*/
 177         odp_parms.odp_in_port = wc.masks.in_port.odp_port;
 178         odp_parms.support.recirc = false;
 179         ofpbuf_use_stack(&buf, &maskbuf, sizeof maskbuf);
 180         odp_flow_key_from_mask(&odp_parms, &buf);
 181         mask = buf.data;
 182         mask_len = buf.size;
 183
 184         /* build string. */
 185         odp_flow_format(key, key_len, mask, mask_len, NULL, &ds, false);
 186         ds_put_format(&ds, "\n");
 187     }
 188     unixctl_command_reply(conn, ds_cstr(&ds));
 189     ds_destroy(&ds);
 190 }
 191
 192 void
 193 tnl_port_map_init(void)
 194 {
 195     classifier_init(&cls, flow_segment_u64s);
 196     unixctl_command_register("tnl/ports/show", "", 0, 0, tnl_port_show, NULL);
 197 }