lib/odp-execute.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
   3  * Copyright (c) 2013 Simon Horman
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <config.h>
  19 #include "odp-execute.h"
  20 #include <stdlib.h>
  21 #include <string.h>
  22
  23 #include "dpif.h"
  24 #include "netlink.h"
  25 #include "ofpbuf.h"
  26 #include "odp-netlink.h"
  27 #include "odp-util.h"
  28 #include "packet-dpif.h"
  29 #include "packets.h"
  30 #include "flow.h"
  31 #include "unaligned.h"
  32 #include "util.h"
  33
  34 static void
  35 odp_eth_set_addrs(struct ofpbuf *packet,
  36                   const struct ovs_key_ethernet *eth_key)
  37 {
  38     struct eth_header *eh = ofpbuf_l2(packet);
  39
  40     if (eh) {
  41         memcpy(eh->eth_src, eth_key->eth_src, sizeof eh->eth_src);
  42         memcpy(eh->eth_dst, eth_key->eth_dst, sizeof eh->eth_dst);
  43     }
  44 }
  45
  46 static void
  47 odp_set_tunnel_action(const struct nlattr *a, struct flow_tnl *tun_key)
  48 {
  49     enum odp_key_fitness fitness;
  50
  51     fitness = odp_tun_key_from_attr(a, tun_key);
  52     ovs_assert(fitness != ODP_FIT_ERROR);
  53 }
  54
  55 static void
  56 set_arp(struct ofpbuf *packet, const struct ovs_key_arp *arp_key)
  57 {
  58     struct arp_eth_header *arp = ofpbuf_l3(packet);
  59
  60     arp->ar_op = arp_key->arp_op;
  61     memcpy(arp->ar_sha, arp_key->arp_sha, ETH_ADDR_LEN);
  62     put_16aligned_be32(&arp->ar_spa, arp_key->arp_sip);
  63     memcpy(arp->ar_tha, arp_key->arp_tha, ETH_ADDR_LEN);
  64     put_16aligned_be32(&arp->ar_tpa, arp_key->arp_tip);
  65 }
  66
  67 static void
  68 odp_execute_set_action(struct dpif_packet *packet, const struct nlattr *a,
  69                        struct pkt_metadata *md)
  70 {
  71     enum ovs_key_attr type = nl_attr_type(a);
  72     const struct ovs_key_ipv4 *ipv4_key;
  73     const struct ovs_key_ipv6 *ipv6_key;
  74     const struct ovs_key_tcp *tcp_key;
  75     const struct ovs_key_udp *udp_key;
  76     const struct ovs_key_sctp *sctp_key;
  77
  78     switch (type) {
  79     case OVS_KEY_ATTR_PRIORITY:
  80         md->skb_priority = nl_attr_get_u32(a);
  81         break;
  82
  83     case OVS_KEY_ATTR_TUNNEL:
  84         odp_set_tunnel_action(a, &md->tunnel);
  85         break;
  86
  87     case OVS_KEY_ATTR_SKB_MARK:
  88         md->pkt_mark = nl_attr_get_u32(a);
  89         break;
  90
  91     case OVS_KEY_ATTR_ETHERNET:
  92         odp_eth_set_addrs(&packet->ofpbuf,
  93                        nl_attr_get_unspec(a, sizeof(struct ovs_key_ethernet)));
  94         break;
  95
  96     case OVS_KEY_ATTR_IPV4:
  97         ipv4_key = nl_attr_get_unspec(a, sizeof(struct ovs_key_ipv4));
  98         packet_set_ipv4(&packet->ofpbuf, ipv4_key->ipv4_src,
  99                         ipv4_key->ipv4_dst, ipv4_key->ipv4_tos,
 100                         ipv4_key->ipv4_ttl);
 101         break;
 102
 103     case OVS_KEY_ATTR_IPV6:
 104         ipv6_key = nl_attr_get_unspec(a, sizeof(struct ovs_key_ipv6));
 105         packet_set_ipv6(&packet->ofpbuf, ipv6_key->ipv6_proto,
 106                         ipv6_key->ipv6_src, ipv6_key->ipv6_dst,
 107                         ipv6_key->ipv6_tclass, ipv6_key->ipv6_label,
 108                         ipv6_key->ipv6_hlimit);
 109         break;
 110
 111     case OVS_KEY_ATTR_TCP:
 112         tcp_key = nl_attr_get_unspec(a, sizeof(struct ovs_key_tcp));
 113         packet_set_tcp_port(&packet->ofpbuf, tcp_key->tcp_src,
 114                             tcp_key->tcp_dst);
 115         break;
 116
 117     case OVS_KEY_ATTR_UDP:
 118         udp_key = nl_attr_get_unspec(a, sizeof(struct ovs_key_udp));
 119         packet_set_udp_port(&packet->ofpbuf, udp_key->udp_src,
 120                             udp_key->udp_dst);
 121         break;
 122
 123     case OVS_KEY_ATTR_SCTP:
 124         sctp_key = nl_attr_get_unspec(a, sizeof(struct ovs_key_sctp));
 125         packet_set_sctp_port(&packet->ofpbuf, sctp_key->sctp_src,
 126                              sctp_key->sctp_dst);
 127         break;
 128
 129     case OVS_KEY_ATTR_MPLS:
 130          set_mpls_lse(&packet->ofpbuf, nl_attr_get_be32(a));
 131          break;
 132
 133     case OVS_KEY_ATTR_ARP:
 134         set_arp(&packet->ofpbuf,
 135                 nl_attr_get_unspec(a, sizeof(struct ovs_key_arp)));
 136         break;
 137
 138     case OVS_KEY_ATTR_DP_HASH:
 139         md->dp_hash = nl_attr_get_u32(a);
 140         dpif_packet_set_dp_hash(packet, md->dp_hash);
 141         break;
 142
 143     case OVS_KEY_ATTR_RECIRC_ID:
 144         md->recirc_id = nl_attr_get_u32(a);
 145         break;
 146
 147     case OVS_KEY_ATTR_UNSPEC:
 148     case OVS_KEY_ATTR_ENCAP:
 149     case OVS_KEY_ATTR_ETHERTYPE:
 150     case OVS_KEY_ATTR_IN_PORT:
 151     case OVS_KEY_ATTR_VLAN:
 152     case OVS_KEY_ATTR_ICMP:
 153     case OVS_KEY_ATTR_ICMPV6:
 154     case OVS_KEY_ATTR_ND:
 155     case OVS_KEY_ATTR_TCP_FLAGS:
 156     case __OVS_KEY_ATTR_MAX:
 157     default:
 158         OVS_NOT_REACHED();
 159     }
 160 }
 161
 162 static void
 163 odp_execute_actions__(void *dp, struct dpif_packet **packets, int cnt,
 164                       bool steal, struct pkt_metadata *,
 165                       const struct nlattr *actions, size_t actions_len,
 166                       odp_execute_cb dp_execute_action, bool more_actions);
 167
 168 static void
 169 odp_execute_sample(void *dp, struct dpif_packet *packet, bool steal,
 170                    struct pkt_metadata *md, const struct nlattr *action,
 171                    odp_execute_cb dp_execute_action, bool more_actions)
 172 {
 173     const struct nlattr *subactions = NULL;
 174     const struct nlattr *a;
 175     size_t left;
 176
 177     NL_NESTED_FOR_EACH_UNSAFE (a, left, action) {
 178         int type = nl_attr_type(a);
 179
 180         switch ((enum ovs_sample_attr) type) {
 181         case OVS_SAMPLE_ATTR_PROBABILITY:
 182             if (random_uint32() >= nl_attr_get_u32(a)) {
 183                 return;
 184             }
 185             break;
 186
 187         case OVS_SAMPLE_ATTR_ACTIONS:
 188             subactions = a;
 189             break;
 190
 191         case OVS_SAMPLE_ATTR_UNSPEC:
 192         case __OVS_SAMPLE_ATTR_MAX:
 193         default:
 194             OVS_NOT_REACHED();
 195         }
 196     }
 197
 198     odp_execute_actions__(dp, &packet, 1, steal, md, nl_attr_get(subactions),
 199                           nl_attr_get_size(subactions), dp_execute_action,
 200                           more_actions);
 201 }
 202
 203 static void
 204 odp_execute_actions__(void *dp, struct dpif_packet **packets, int cnt,
 205                       bool steal, struct pkt_metadata *md,
 206                       const struct nlattr *actions, size_t actions_len,
 207                       odp_execute_cb dp_execute_action, bool more_actions)
 208 {
 209     const struct nlattr *a;
 210     unsigned int left;
 211
 212     int i;
 213
 214     NL_ATTR_FOR_EACH_UNSAFE (a, left, actions, actions_len) {
 215         int type = nl_attr_type(a);
 216
 217         switch ((enum ovs_action_attr) type) {
 218             /* These only make sense in the context of a datapath. */
 219         case OVS_ACTION_ATTR_OUTPUT:
 220         case OVS_ACTION_ATTR_USERSPACE:
 221         case OVS_ACTION_ATTR_RECIRC:
 222             if (dp_execute_action) {
 223                 /* Allow 'dp_execute_action' to steal the packet data if we do
 224                  * not need it any more. */
 225                 bool may_steal = steal && (!more_actions
 226                                            && left <= NLA_ALIGN(a->nla_len)
 227                                            && type != OVS_ACTION_ATTR_RECIRC);
 228                 dp_execute_action(dp, packets, cnt, md, a, may_steal);
 229             }
 230             break;
 231
 232         case OVS_ACTION_ATTR_HASH: {
 233             const struct ovs_action_hash *hash_act = nl_attr_get(a);
 234
 235             /* Calculate a hash value directly.  This might not match the
 236              * value computed by the datapath, but it is much less expensive,
 237              * and the current use case (bonding) does not require a strict
 238              * match to work properly. */
 239             if (hash_act->hash_alg == OVS_HASH_ALG_L4) {
 240                 struct flow flow;
 241                 uint32_t hash;
 242
 243                 for (i = 0; i < cnt; i++) {
 244                     struct ofpbuf *buf = &packets[i]->ofpbuf;
 245
 246                     flow_extract(buf, md, &flow);
 247                     hash = flow_hash_5tuple(&flow, hash_act->hash_basis);
 248
 249                     /* The hash of the first packet is in shared metadata */
 250                     if (i == 0) {
 251                         md->dp_hash = hash ? hash : 1;
 252                     }
 253
 254                     /* We also store the hash value with each packet */
 255                     dpif_packet_set_dp_hash(packets[i], hash ? hash : 1);
 256                 }
 257             } else {
 258                 /* Assert on unknown hash algorithm.  */
 259                 OVS_NOT_REACHED();
 260             }
 261             break;
 262         }
 263
 264         case OVS_ACTION_ATTR_PUSH_VLAN: {
 265             const struct ovs_action_push_vlan *vlan = nl_attr_get(a);
 266
 267             for (i = 0; i < cnt; i++) {
 268                 struct ofpbuf *buf = &packets[i]->ofpbuf;
 269
 270                 eth_push_vlan(buf, htons(ETH_TYPE_VLAN), vlan->vlan_tci);
 271             }
 272             break;
 273         }
 274
 275         case OVS_ACTION_ATTR_POP_VLAN:
 276             for (i = 0; i < cnt; i++) {
 277                 struct ofpbuf *buf = &packets[i]->ofpbuf;
 278
 279                 eth_pop_vlan(buf);
 280             }
 281             break;
 282
 283         case OVS_ACTION_ATTR_PUSH_MPLS: {
 284             const struct ovs_action_push_mpls *mpls = nl_attr_get(a);
 285
 286             for (i = 0; i < cnt; i++) {
 287                 struct ofpbuf *buf = &packets[i]->ofpbuf;
 288
 289                 push_mpls(buf, mpls->mpls_ethertype, mpls->mpls_lse);
 290             }
 291             break;
 292          }
 293
 294         case OVS_ACTION_ATTR_POP_MPLS:
 295             for (i = 0; i < cnt; i++) {
 296                 struct ofpbuf *buf = &packets[i]->ofpbuf;
 297
 298                 pop_mpls(buf, nl_attr_get_be16(a));
 299             }
 300             break;
 301
 302         case OVS_ACTION_ATTR_SET:
 303             for (i = 0; i < cnt; i++) {
 304                 odp_execute_set_action(packets[i], nl_attr_get(a),
 305                                        md);
 306             }
 307             break;
 308
 309         case OVS_ACTION_ATTR_SAMPLE:
 310             for (i = 0; i < cnt; i++) {
 311                 odp_execute_sample(dp, packets[i], steal, md, a,
 312                                    dp_execute_action,
 313                                    more_actions ||
 314                                    left > NLA_ALIGN(a->nla_len));
 315             }
 316             break;
 317
 318         case OVS_ACTION_ATTR_UNSPEC:
 319         case __OVS_ACTION_ATTR_MAX:
 320             OVS_NOT_REACHED();
 321         }
 322     }
 323 }
 324
 325 void
 326 odp_execute_actions(void *dp, struct dpif_packet **packets, int cnt,
 327                     bool steal, struct pkt_metadata *md,
 328                     const struct nlattr *actions, size_t actions_len,
 329                     odp_execute_cb dp_execute_action)
 330 {
 331     odp_execute_actions__(dp, packets, cnt, steal, md, actions, actions_len,
 332                           dp_execute_action, false);
 333
 334     if (!actions_len && steal) {
 335         /* Drop action. */
 336         int i;
 337
 338         for (i = 0; i < cnt; i++) {
 339             dpif_packet_delete(packets[i]);
 340         }
 341     }
 342 }