Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Copyright (c) 2007-2017 Nicira, Inc.
0004  */
0005 
0006 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0007 
0008 #include <linux/skbuff.h>
0009 #include <linux/in.h>
0010 #include <linux/ip.h>
0011 #include <linux/openvswitch.h>
0012 #include <linux/sctp.h>
0013 #include <linux/tcp.h>
0014 #include <linux/udp.h>
0015 #include <linux/in6.h>
0016 #include <linux/if_arp.h>
0017 #include <linux/if_vlan.h>
0018 
0019 #include <net/dst.h>
0020 #include <net/ip.h>
0021 #include <net/ipv6.h>
0022 #include <net/ip6_fib.h>
0023 #include <net/checksum.h>
0024 #include <net/dsfield.h>
0025 #include <net/mpls.h>
0026 #include <net/sctp/checksum.h>
0027 
0028 #include "datapath.h"
0029 #include "flow.h"
0030 #include "conntrack.h"
0031 #include "vport.h"
0032 #include "flow_netlink.h"
0033 #include "openvswitch_trace.h"
0034 
0035 struct deferred_action {
0036     struct sk_buff *skb;
0037     const struct nlattr *actions;
0038     int actions_len;
0039 
0040     /* Store pkt_key clone when creating deferred action. */
0041     struct sw_flow_key pkt_key;
0042 };
0043 
0044 #define MAX_L2_LEN  (VLAN_ETH_HLEN + 3 * MPLS_HLEN)
0045 struct ovs_frag_data {
0046     unsigned long dst;
0047     struct vport *vport;
0048     struct ovs_skb_cb cb;
0049     __be16 inner_protocol;
0050     u16 network_offset; /* valid only for MPLS */
0051     u16 vlan_tci;
0052     __be16 vlan_proto;
0053     unsigned int l2_len;
0054     u8 mac_proto;
0055     u8 l2_data[MAX_L2_LEN];
0056 };
0057 
0058 static DEFINE_PER_CPU(struct ovs_frag_data, ovs_frag_data_storage);
0059 
0060 #define DEFERRED_ACTION_FIFO_SIZE 10
0061 #define OVS_RECURSION_LIMIT 5
0062 #define OVS_DEFERRED_ACTION_THRESHOLD (OVS_RECURSION_LIMIT - 2)
0063 struct action_fifo {
0064     int head;
0065     int tail;
0066     /* Deferred action fifo queue storage. */
0067     struct deferred_action fifo[DEFERRED_ACTION_FIFO_SIZE];
0068 };
0069 
0070 struct action_flow_keys {
0071     struct sw_flow_key key[OVS_DEFERRED_ACTION_THRESHOLD];
0072 };
0073 
0074 static struct action_fifo __percpu *action_fifos;
0075 static struct action_flow_keys __percpu *flow_keys;
0076 static DEFINE_PER_CPU(int, exec_actions_level);
0077 
0078 /* Make a clone of the 'key', using the pre-allocated percpu 'flow_keys'
0079  * space. Return NULL if out of key spaces.
0080  */
0081 static struct sw_flow_key *clone_key(const struct sw_flow_key *key_)
0082 {
0083     struct action_flow_keys *keys = this_cpu_ptr(flow_keys);
0084     int level = this_cpu_read(exec_actions_level);
0085     struct sw_flow_key *key = NULL;
0086 
0087     if (level <= OVS_DEFERRED_ACTION_THRESHOLD) {
0088         key = &keys->key[level - 1];
0089         *key = *key_;
0090     }
0091 
0092     return key;
0093 }
0094 
0095 static void action_fifo_init(struct action_fifo *fifo)
0096 {
0097     fifo->head = 0;
0098     fifo->tail = 0;
0099 }
0100 
0101 static bool action_fifo_is_empty(const struct action_fifo *fifo)
0102 {
0103     return (fifo->head == fifo->tail);
0104 }
0105 
0106 static struct deferred_action *action_fifo_get(struct action_fifo *fifo)
0107 {
0108     if (action_fifo_is_empty(fifo))
0109         return NULL;
0110 
0111     return &fifo->fifo[fifo->tail++];
0112 }
0113 
0114 static struct deferred_action *action_fifo_put(struct action_fifo *fifo)
0115 {
0116     if (fifo->head >= DEFERRED_ACTION_FIFO_SIZE - 1)
0117         return NULL;
0118 
0119     return &fifo->fifo[fifo->head++];
0120 }
0121 
0122 /* Return true if fifo is not full */
0123 static struct deferred_action *add_deferred_actions(struct sk_buff *skb,
0124                     const struct sw_flow_key *key,
0125                     const struct nlattr *actions,
0126                     const int actions_len)
0127 {
0128     struct action_fifo *fifo;
0129     struct deferred_action *da;
0130 
0131     fifo = this_cpu_ptr(action_fifos);
0132     da = action_fifo_put(fifo);
0133     if (da) {
0134         da->skb = skb;
0135         da->actions = actions;
0136         da->actions_len = actions_len;
0137         da->pkt_key = *key;
0138     }
0139 
0140     return da;
0141 }
0142 
0143 static void invalidate_flow_key(struct sw_flow_key *key)
0144 {
0145     key->mac_proto |= SW_FLOW_KEY_INVALID;
0146 }
0147 
0148 static bool is_flow_key_valid(const struct sw_flow_key *key)
0149 {
0150     return !(key->mac_proto & SW_FLOW_KEY_INVALID);
0151 }
0152 
0153 static int clone_execute(struct datapath *dp, struct sk_buff *skb,
0154              struct sw_flow_key *key,
0155              u32 recirc_id,
0156              const struct nlattr *actions, int len,
0157              bool last, bool clone_flow_key);
0158 
0159 static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
0160                   struct sw_flow_key *key,
0161                   const struct nlattr *attr, int len);
0162 
0163 static int push_mpls(struct sk_buff *skb, struct sw_flow_key *key,
0164              __be32 mpls_lse, __be16 mpls_ethertype, __u16 mac_len)
0165 {
0166     int err;
0167 
0168     err = skb_mpls_push(skb, mpls_lse, mpls_ethertype, mac_len, !!mac_len);
0169     if (err)
0170         return err;
0171 
0172     if (!mac_len)
0173         key->mac_proto = MAC_PROTO_NONE;
0174 
0175     invalidate_flow_key(key);
0176     return 0;
0177 }
0178 
0179 static int pop_mpls(struct sk_buff *skb, struct sw_flow_key *key,
0180             const __be16 ethertype)
0181 {
0182     int err;
0183 
0184     err = skb_mpls_pop(skb, ethertype, skb->mac_len,
0185                ovs_key_mac_proto(key) == MAC_PROTO_ETHERNET);
0186     if (err)
0187         return err;
0188 
0189     if (ethertype == htons(ETH_P_TEB))
0190         key->mac_proto = MAC_PROTO_ETHERNET;
0191 
0192     invalidate_flow_key(key);
0193     return 0;
0194 }
0195 
0196 static int set_mpls(struct sk_buff *skb, struct sw_flow_key *flow_key,
0197             const __be32 *mpls_lse, const __be32 *mask)
0198 {
0199     struct mpls_shim_hdr *stack;
0200     __be32 lse;
0201     int err;
0202 
0203     if (!pskb_may_pull(skb, skb_network_offset(skb) + MPLS_HLEN))
0204         return -ENOMEM;
0205 
0206     stack = mpls_hdr(skb);
0207     lse = OVS_MASKED(stack->label_stack_entry, *mpls_lse, *mask);
0208     err = skb_mpls_update_lse(skb, lse);
0209     if (err)
0210         return err;
0211 
0212     flow_key->mpls.lse[0] = lse;
0213     return 0;
0214 }
0215 
0216 static int pop_vlan(struct sk_buff *skb, struct sw_flow_key *key)
0217 {
0218     int err;
0219 
0220     err = skb_vlan_pop(skb);
0221     if (skb_vlan_tag_present(skb)) {
0222         invalidate_flow_key(key);
0223     } else {
0224         key->eth.vlan.tci = 0;
0225         key->eth.vlan.tpid = 0;
0226     }
0227     return err;
0228 }
0229 
0230 static int push_vlan(struct sk_buff *skb, struct sw_flow_key *key,
0231              const struct ovs_action_push_vlan *vlan)
0232 {
0233     if (skb_vlan_tag_present(skb)) {
0234         invalidate_flow_key(key);
0235     } else {
0236         key->eth.vlan.tci = vlan->vlan_tci;
0237         key->eth.vlan.tpid = vlan->vlan_tpid;
0238     }
0239     return skb_vlan_push(skb, vlan->vlan_tpid,
0240                  ntohs(vlan->vlan_tci) & ~VLAN_CFI_MASK);
0241 }
0242 
0243 /* 'src' is already properly masked. */
0244 static void ether_addr_copy_masked(u8 *dst_, const u8 *src_, const u8 *mask_)
0245 {
0246     u16 *dst = (u16 *)dst_;
0247     const u16 *src = (const u16 *)src_;
0248     const u16 *mask = (const u16 *)mask_;
0249 
0250     OVS_SET_MASKED(dst[0], src[0], mask[0]);
0251     OVS_SET_MASKED(dst[1], src[1], mask[1]);
0252     OVS_SET_MASKED(dst[2], src[2], mask[2]);
0253 }
0254 
0255 static int set_eth_addr(struct sk_buff *skb, struct sw_flow_key *flow_key,
0256             const struct ovs_key_ethernet *key,
0257             const struct ovs_key_ethernet *mask)
0258 {
0259     int err;
0260 
0261     err = skb_ensure_writable(skb, ETH_HLEN);
0262     if (unlikely(err))
0263         return err;
0264 
0265     skb_postpull_rcsum(skb, eth_hdr(skb), ETH_ALEN * 2);
0266 
0267     ether_addr_copy_masked(eth_hdr(skb)->h_source, key->eth_src,
0268                    mask->eth_src);
0269     ether_addr_copy_masked(eth_hdr(skb)->h_dest, key->eth_dst,
0270                    mask->eth_dst);
0271 
0272     skb_postpush_rcsum(skb, eth_hdr(skb), ETH_ALEN * 2);
0273 
0274     ether_addr_copy(flow_key->eth.src, eth_hdr(skb)->h_source);
0275     ether_addr_copy(flow_key->eth.dst, eth_hdr(skb)->h_dest);
0276     return 0;
0277 }
0278 
0279 /* pop_eth does not support VLAN packets as this action is never called
0280  * for them.
0281  */
0282 static int pop_eth(struct sk_buff *skb, struct sw_flow_key *key)
0283 {
0284     int err;
0285 
0286     err = skb_eth_pop(skb);
0287     if (err)
0288         return err;
0289 
0290     /* safe right before invalidate_flow_key */
0291     key->mac_proto = MAC_PROTO_NONE;
0292     invalidate_flow_key(key);
0293     return 0;
0294 }
0295 
0296 static int push_eth(struct sk_buff *skb, struct sw_flow_key *key,
0297             const struct ovs_action_push_eth *ethh)
0298 {
0299     int err;
0300 
0301     err = skb_eth_push(skb, ethh->addresses.eth_dst,
0302                ethh->addresses.eth_src);
0303     if (err)
0304         return err;
0305 
0306     /* safe right before invalidate_flow_key */
0307     key->mac_proto = MAC_PROTO_ETHERNET;
0308     invalidate_flow_key(key);
0309     return 0;
0310 }
0311 
0312 static int push_nsh(struct sk_buff *skb, struct sw_flow_key *key,
0313             const struct nshhdr *nh)
0314 {
0315     int err;
0316 
0317     err = nsh_push(skb, nh);
0318     if (err)
0319         return err;
0320 
0321     /* safe right before invalidate_flow_key */
0322     key->mac_proto = MAC_PROTO_NONE;
0323     invalidate_flow_key(key);
0324     return 0;
0325 }
0326 
0327 static int pop_nsh(struct sk_buff *skb, struct sw_flow_key *key)
0328 {
0329     int err;
0330 
0331     err = nsh_pop(skb);
0332     if (err)
0333         return err;
0334 
0335     /* safe right before invalidate_flow_key */
0336     if (skb->protocol == htons(ETH_P_TEB))
0337         key->mac_proto = MAC_PROTO_ETHERNET;
0338     else
0339         key->mac_proto = MAC_PROTO_NONE;
0340     invalidate_flow_key(key);
0341     return 0;
0342 }
0343 
0344 static void update_ip_l4_checksum(struct sk_buff *skb, struct iphdr *nh,
0345                   __be32 addr, __be32 new_addr)
0346 {
0347     int transport_len = skb->len - skb_transport_offset(skb);
0348 
0349     if (nh->frag_off & htons(IP_OFFSET))
0350         return;
0351 
0352     if (nh->protocol == IPPROTO_TCP) {
0353         if (likely(transport_len >= sizeof(struct tcphdr)))
0354             inet_proto_csum_replace4(&tcp_hdr(skb)->check, skb,
0355                          addr, new_addr, true);
0356     } else if (nh->protocol == IPPROTO_UDP) {
0357         if (likely(transport_len >= sizeof(struct udphdr))) {
0358             struct udphdr *uh = udp_hdr(skb);
0359 
0360             if (uh->check || skb->ip_summed == CHECKSUM_PARTIAL) {
0361                 inet_proto_csum_replace4(&uh->check, skb,
0362                              addr, new_addr, true);
0363                 if (!uh->check)
0364                     uh->check = CSUM_MANGLED_0;
0365             }
0366         }
0367     }
0368 }
0369 
0370 static void set_ip_addr(struct sk_buff *skb, struct iphdr *nh,
0371             __be32 *addr, __be32 new_addr)
0372 {
0373     update_ip_l4_checksum(skb, nh, *addr, new_addr);
0374     csum_replace4(&nh->check, *addr, new_addr);
0375     skb_clear_hash(skb);
0376     ovs_ct_clear(skb, NULL);
0377     *addr = new_addr;
0378 }
0379 
0380 static void update_ipv6_checksum(struct sk_buff *skb, u8 l4_proto,
0381                  __be32 addr[4], const __be32 new_addr[4])
0382 {
0383     int transport_len = skb->len - skb_transport_offset(skb);
0384 
0385     if (l4_proto == NEXTHDR_TCP) {
0386         if (likely(transport_len >= sizeof(struct tcphdr)))
0387             inet_proto_csum_replace16(&tcp_hdr(skb)->check, skb,
0388                           addr, new_addr, true);
0389     } else if (l4_proto == NEXTHDR_UDP) {
0390         if (likely(transport_len >= sizeof(struct udphdr))) {
0391             struct udphdr *uh = udp_hdr(skb);
0392 
0393             if (uh->check || skb->ip_summed == CHECKSUM_PARTIAL) {
0394                 inet_proto_csum_replace16(&uh->check, skb,
0395                               addr, new_addr, true);
0396                 if (!uh->check)
0397                     uh->check = CSUM_MANGLED_0;
0398             }
0399         }
0400     } else if (l4_proto == NEXTHDR_ICMP) {
0401         if (likely(transport_len >= sizeof(struct icmp6hdr)))
0402             inet_proto_csum_replace16(&icmp6_hdr(skb)->icmp6_cksum,
0403                           skb, addr, new_addr, true);
0404     }
0405 }
0406 
0407 static void mask_ipv6_addr(const __be32 old[4], const __be32 addr[4],
0408                const __be32 mask[4], __be32 masked[4])
0409 {
0410     masked[0] = OVS_MASKED(old[0], addr[0], mask[0]);
0411     masked[1] = OVS_MASKED(old[1], addr[1], mask[1]);
0412     masked[2] = OVS_MASKED(old[2], addr[2], mask[2]);
0413     masked[3] = OVS_MASKED(old[3], addr[3], mask[3]);
0414 }
0415 
0416 static void set_ipv6_addr(struct sk_buff *skb, u8 l4_proto,
0417               __be32 addr[4], const __be32 new_addr[4],
0418               bool recalculate_csum)
0419 {
0420     if (recalculate_csum)
0421         update_ipv6_checksum(skb, l4_proto, addr, new_addr);
0422 
0423     skb_clear_hash(skb);
0424     ovs_ct_clear(skb, NULL);
0425     memcpy(addr, new_addr, sizeof(__be32[4]));
0426 }
0427 
0428 static void set_ipv6_dsfield(struct sk_buff *skb, struct ipv6hdr *nh, u8 ipv6_tclass, u8 mask)
0429 {
0430     u8 old_ipv6_tclass = ipv6_get_dsfield(nh);
0431 
0432     ipv6_tclass = OVS_MASKED(old_ipv6_tclass, ipv6_tclass, mask);
0433 
0434     if (skb->ip_summed == CHECKSUM_COMPLETE)
0435         csum_replace(&skb->csum, (__force __wsum)(old_ipv6_tclass << 12),
0436                  (__force __wsum)(ipv6_tclass << 12));
0437 
0438     ipv6_change_dsfield(nh, ~mask, ipv6_tclass);
0439 }
0440 
0441 static void set_ipv6_fl(struct sk_buff *skb, struct ipv6hdr *nh, u32 fl, u32 mask)
0442 {
0443     u32 ofl;
0444 
0445     ofl = nh->flow_lbl[0] << 16 |  nh->flow_lbl[1] << 8 |  nh->flow_lbl[2];
0446     fl = OVS_MASKED(ofl, fl, mask);
0447 
0448     /* Bits 21-24 are always unmasked, so this retains their values. */
0449     nh->flow_lbl[0] = (u8)(fl >> 16);
0450     nh->flow_lbl[1] = (u8)(fl >> 8);
0451     nh->flow_lbl[2] = (u8)fl;
0452 
0453     if (skb->ip_summed == CHECKSUM_COMPLETE)
0454         csum_replace(&skb->csum, (__force __wsum)htonl(ofl), (__force __wsum)htonl(fl));
0455 }
0456 
0457 static void set_ipv6_ttl(struct sk_buff *skb, struct ipv6hdr *nh, u8 new_ttl, u8 mask)
0458 {
0459     new_ttl = OVS_MASKED(nh->hop_limit, new_ttl, mask);
0460 
0461     if (skb->ip_summed == CHECKSUM_COMPLETE)
0462         csum_replace(&skb->csum, (__force __wsum)(nh->hop_limit << 8),
0463                  (__force __wsum)(new_ttl << 8));
0464     nh->hop_limit = new_ttl;
0465 }
0466 
0467 static void set_ip_ttl(struct sk_buff *skb, struct iphdr *nh, u8 new_ttl,
0468                u8 mask)
0469 {
0470     new_ttl = OVS_MASKED(nh->ttl, new_ttl, mask);
0471 
0472     csum_replace2(&nh->check, htons(nh->ttl << 8), htons(new_ttl << 8));
0473     nh->ttl = new_ttl;
0474 }
0475 
0476 static int set_ipv4(struct sk_buff *skb, struct sw_flow_key *flow_key,
0477             const struct ovs_key_ipv4 *key,
0478             const struct ovs_key_ipv4 *mask)
0479 {
0480     struct iphdr *nh;
0481     __be32 new_addr;
0482     int err;
0483 
0484     err = skb_ensure_writable(skb, skb_network_offset(skb) +
0485                   sizeof(struct iphdr));
0486     if (unlikely(err))
0487         return err;
0488 
0489     nh = ip_hdr(skb);
0490 
0491     /* Setting an IP addresses is typically only a side effect of
0492      * matching on them in the current userspace implementation, so it
0493      * makes sense to check if the value actually changed.
0494      */
0495     if (mask->ipv4_src) {
0496         new_addr = OVS_MASKED(nh->saddr, key->ipv4_src, mask->ipv4_src);
0497 
0498         if (unlikely(new_addr != nh->saddr)) {
0499             set_ip_addr(skb, nh, &nh->saddr, new_addr);
0500             flow_key->ipv4.addr.src = new_addr;
0501         }
0502     }
0503     if (mask->ipv4_dst) {
0504         new_addr = OVS_MASKED(nh->daddr, key->ipv4_dst, mask->ipv4_dst);
0505 
0506         if (unlikely(new_addr != nh->daddr)) {
0507             set_ip_addr(skb, nh, &nh->daddr, new_addr);
0508             flow_key->ipv4.addr.dst = new_addr;
0509         }
0510     }
0511     if (mask->ipv4_tos) {
0512         ipv4_change_dsfield(nh, ~mask->ipv4_tos, key->ipv4_tos);
0513         flow_key->ip.tos = nh->tos;
0514     }
0515     if (mask->ipv4_ttl) {
0516         set_ip_ttl(skb, nh, key->ipv4_ttl, mask->ipv4_ttl);
0517         flow_key->ip.ttl = nh->ttl;
0518     }
0519 
0520     return 0;
0521 }
0522 
0523 static bool is_ipv6_mask_nonzero(const __be32 addr[4])
0524 {
0525     return !!(addr[0] | addr[1] | addr[2] | addr[3]);
0526 }
0527 
0528 static int set_ipv6(struct sk_buff *skb, struct sw_flow_key *flow_key,
0529             const struct ovs_key_ipv6 *key,
0530             const struct ovs_key_ipv6 *mask)
0531 {
0532     struct ipv6hdr *nh;
0533     int err;
0534 
0535     err = skb_ensure_writable(skb, skb_network_offset(skb) +
0536                   sizeof(struct ipv6hdr));
0537     if (unlikely(err))
0538         return err;
0539 
0540     nh = ipv6_hdr(skb);
0541 
0542     /* Setting an IP addresses is typically only a side effect of
0543      * matching on them in the current userspace implementation, so it
0544      * makes sense to check if the value actually changed.
0545      */
0546     if (is_ipv6_mask_nonzero(mask->ipv6_src)) {
0547         __be32 *saddr = (__be32 *)&nh->saddr;
0548         __be32 masked[4];
0549 
0550         mask_ipv6_addr(saddr, key->ipv6_src, mask->ipv6_src, masked);
0551 
0552         if (unlikely(memcmp(saddr, masked, sizeof(masked)))) {
0553             set_ipv6_addr(skb, flow_key->ip.proto, saddr, masked,
0554                       true);
0555             memcpy(&flow_key->ipv6.addr.src, masked,
0556                    sizeof(flow_key->ipv6.addr.src));
0557         }
0558     }
0559     if (is_ipv6_mask_nonzero(mask->ipv6_dst)) {
0560         unsigned int offset = 0;
0561         int flags = IP6_FH_F_SKIP_RH;
0562         bool recalc_csum = true;
0563         __be32 *daddr = (__be32 *)&nh->daddr;
0564         __be32 masked[4];
0565 
0566         mask_ipv6_addr(daddr, key->ipv6_dst, mask->ipv6_dst, masked);
0567 
0568         if (unlikely(memcmp(daddr, masked, sizeof(masked)))) {
0569             if (ipv6_ext_hdr(nh->nexthdr))
0570                 recalc_csum = (ipv6_find_hdr(skb, &offset,
0571                                  NEXTHDR_ROUTING,
0572                                  NULL, &flags)
0573                            != NEXTHDR_ROUTING);
0574 
0575             set_ipv6_addr(skb, flow_key->ip.proto, daddr, masked,
0576                       recalc_csum);
0577             memcpy(&flow_key->ipv6.addr.dst, masked,
0578                    sizeof(flow_key->ipv6.addr.dst));
0579         }
0580     }
0581     if (mask->ipv6_tclass) {
0582         set_ipv6_dsfield(skb, nh, key->ipv6_tclass, mask->ipv6_tclass);
0583         flow_key->ip.tos = ipv6_get_dsfield(nh);
0584     }
0585     if (mask->ipv6_label) {
0586         set_ipv6_fl(skb, nh, ntohl(key->ipv6_label),
0587                 ntohl(mask->ipv6_label));
0588         flow_key->ipv6.label =
0589             *(__be32 *)nh & htonl(IPV6_FLOWINFO_FLOWLABEL);
0590     }
0591     if (mask->ipv6_hlimit) {
0592         set_ipv6_ttl(skb, nh, key->ipv6_hlimit, mask->ipv6_hlimit);
0593         flow_key->ip.ttl = nh->hop_limit;
0594     }
0595     return 0;
0596 }
0597 
0598 static int set_nsh(struct sk_buff *skb, struct sw_flow_key *flow_key,
0599            const struct nlattr *a)
0600 {
0601     struct nshhdr *nh;
0602     size_t length;
0603     int err;
0604     u8 flags;
0605     u8 ttl;
0606     int i;
0607 
0608     struct ovs_key_nsh key;
0609     struct ovs_key_nsh mask;
0610 
0611     err = nsh_key_from_nlattr(a, &key, &mask);
0612     if (err)
0613         return err;
0614 
0615     /* Make sure the NSH base header is there */
0616     if (!pskb_may_pull(skb, skb_network_offset(skb) + NSH_BASE_HDR_LEN))
0617         return -ENOMEM;
0618 
0619     nh = nsh_hdr(skb);
0620     length = nsh_hdr_len(nh);
0621 
0622     /* Make sure the whole NSH header is there */
0623     err = skb_ensure_writable(skb, skb_network_offset(skb) +
0624                        length);
0625     if (unlikely(err))
0626         return err;
0627 
0628     nh = nsh_hdr(skb);
0629     skb_postpull_rcsum(skb, nh, length);
0630     flags = nsh_get_flags(nh);
0631     flags = OVS_MASKED(flags, key.base.flags, mask.base.flags);
0632     flow_key->nsh.base.flags = flags;
0633     ttl = nsh_get_ttl(nh);
0634     ttl = OVS_MASKED(ttl, key.base.ttl, mask.base.ttl);
0635     flow_key->nsh.base.ttl = ttl;
0636     nsh_set_flags_and_ttl(nh, flags, ttl);
0637     nh->path_hdr = OVS_MASKED(nh->path_hdr, key.base.path_hdr,
0638                   mask.base.path_hdr);
0639     flow_key->nsh.base.path_hdr = nh->path_hdr;
0640     switch (nh->mdtype) {
0641     case NSH_M_TYPE1:
0642         for (i = 0; i < NSH_MD1_CONTEXT_SIZE; i++) {
0643             nh->md1.context[i] =
0644                 OVS_MASKED(nh->md1.context[i], key.context[i],
0645                        mask.context[i]);
0646         }
0647         memcpy(flow_key->nsh.context, nh->md1.context,
0648                sizeof(nh->md1.context));
0649         break;
0650     case NSH_M_TYPE2:
0651         memset(flow_key->nsh.context, 0,
0652                sizeof(flow_key->nsh.context));
0653         break;
0654     default:
0655         return -EINVAL;
0656     }
0657     skb_postpush_rcsum(skb, nh, length);
0658     return 0;
0659 }
0660 
0661 /* Must follow skb_ensure_writable() since that can move the skb data. */
0662 static void set_tp_port(struct sk_buff *skb, __be16 *port,
0663             __be16 new_port, __sum16 *check)
0664 {
0665     ovs_ct_clear(skb, NULL);
0666     inet_proto_csum_replace2(check, skb, *port, new_port, false);
0667     *port = new_port;
0668 }
0669 
0670 static int set_udp(struct sk_buff *skb, struct sw_flow_key *flow_key,
0671            const struct ovs_key_udp *key,
0672            const struct ovs_key_udp *mask)
0673 {
0674     struct udphdr *uh;
0675     __be16 src, dst;
0676     int err;
0677 
0678     err = skb_ensure_writable(skb, skb_transport_offset(skb) +
0679                   sizeof(struct udphdr));
0680     if (unlikely(err))
0681         return err;
0682 
0683     uh = udp_hdr(skb);
0684     /* Either of the masks is non-zero, so do not bother checking them. */
0685     src = OVS_MASKED(uh->source, key->udp_src, mask->udp_src);
0686     dst = OVS_MASKED(uh->dest, key->udp_dst, mask->udp_dst);
0687 
0688     if (uh->check && skb->ip_summed != CHECKSUM_PARTIAL) {
0689         if (likely(src != uh->source)) {
0690             set_tp_port(skb, &uh->source, src, &uh->check);
0691             flow_key->tp.src = src;
0692         }
0693         if (likely(dst != uh->dest)) {
0694             set_tp_port(skb, &uh->dest, dst, &uh->check);
0695             flow_key->tp.dst = dst;
0696         }
0697 
0698         if (unlikely(!uh->check))
0699             uh->check = CSUM_MANGLED_0;
0700     } else {
0701         uh->source = src;
0702         uh->dest = dst;
0703         flow_key->tp.src = src;
0704         flow_key->tp.dst = dst;
0705         ovs_ct_clear(skb, NULL);
0706     }
0707 
0708     skb_clear_hash(skb);
0709 
0710     return 0;
0711 }
0712 
0713 static int set_tcp(struct sk_buff *skb, struct sw_flow_key *flow_key,
0714            const struct ovs_key_tcp *key,
0715            const struct ovs_key_tcp *mask)
0716 {
0717     struct tcphdr *th;
0718     __be16 src, dst;
0719     int err;
0720 
0721     err = skb_ensure_writable(skb, skb_transport_offset(skb) +
0722                   sizeof(struct tcphdr));
0723     if (unlikely(err))
0724         return err;
0725 
0726     th = tcp_hdr(skb);
0727     src = OVS_MASKED(th->source, key->tcp_src, mask->tcp_src);
0728     if (likely(src != th->source)) {
0729         set_tp_port(skb, &th->source, src, &th->check);
0730         flow_key->tp.src = src;
0731     }
0732     dst = OVS_MASKED(th->dest, key->tcp_dst, mask->tcp_dst);
0733     if (likely(dst != th->dest)) {
0734         set_tp_port(skb, &th->dest, dst, &th->check);
0735         flow_key->tp.dst = dst;
0736     }
0737     skb_clear_hash(skb);
0738 
0739     return 0;
0740 }
0741 
0742 static int set_sctp(struct sk_buff *skb, struct sw_flow_key *flow_key,
0743             const struct ovs_key_sctp *key,
0744             const struct ovs_key_sctp *mask)
0745 {
0746     unsigned int sctphoff = skb_transport_offset(skb);
0747     struct sctphdr *sh;
0748     __le32 old_correct_csum, new_csum, old_csum;
0749     int err;
0750 
0751     err = skb_ensure_writable(skb, sctphoff + sizeof(struct sctphdr));
0752     if (unlikely(err))
0753         return err;
0754 
0755     sh = sctp_hdr(skb);
0756     old_csum = sh->checksum;
0757     old_correct_csum = sctp_compute_cksum(skb, sctphoff);
0758 
0759     sh->source = OVS_MASKED(sh->source, key->sctp_src, mask->sctp_src);
0760     sh->dest = OVS_MASKED(sh->dest, key->sctp_dst, mask->sctp_dst);
0761 
0762     new_csum = sctp_compute_cksum(skb, sctphoff);
0763 
0764     /* Carry any checksum errors through. */
0765     sh->checksum = old_csum ^ old_correct_csum ^ new_csum;
0766 
0767     skb_clear_hash(skb);
0768     ovs_ct_clear(skb, NULL);
0769 
0770     flow_key->tp.src = sh->source;
0771     flow_key->tp.dst = sh->dest;
0772 
0773     return 0;
0774 }
0775 
0776 static int ovs_vport_output(struct net *net, struct sock *sk,
0777                 struct sk_buff *skb)
0778 {
0779     struct ovs_frag_data *data = this_cpu_ptr(&ovs_frag_data_storage);
0780     struct vport *vport = data->vport;
0781 
0782     if (skb_cow_head(skb, data->l2_len) < 0) {
0783         kfree_skb(skb);
0784         return -ENOMEM;
0785     }
0786 
0787     __skb_dst_copy(skb, data->dst);
0788     *OVS_CB(skb) = data->cb;
0789     skb->inner_protocol = data->inner_protocol;
0790     if (data->vlan_tci & VLAN_CFI_MASK)
0791         __vlan_hwaccel_put_tag(skb, data->vlan_proto, data->vlan_tci & ~VLAN_CFI_MASK);
0792     else
0793         __vlan_hwaccel_clear_tag(skb);
0794 
0795     /* Reconstruct the MAC header.  */
0796     skb_push(skb, data->l2_len);
0797     memcpy(skb->data, &data->l2_data, data->l2_len);
0798     skb_postpush_rcsum(skb, skb->data, data->l2_len);
0799     skb_reset_mac_header(skb);
0800 
0801     if (eth_p_mpls(skb->protocol)) {
0802         skb->inner_network_header = skb->network_header;
0803         skb_set_network_header(skb, data->network_offset);
0804         skb_reset_mac_len(skb);
0805     }
0806 
0807     ovs_vport_send(vport, skb, data->mac_proto);
0808     return 0;
0809 }
0810 
0811 static unsigned int
0812 ovs_dst_get_mtu(const struct dst_entry *dst)
0813 {
0814     return dst->dev->mtu;
0815 }
0816 
0817 static struct dst_ops ovs_dst_ops = {
0818     .family = AF_UNSPEC,
0819     .mtu = ovs_dst_get_mtu,
0820 };
0821 
0822 /* prepare_frag() is called once per (larger-than-MTU) frame; its inverse is
0823  * ovs_vport_output(), which is called once per fragmented packet.
0824  */
0825 static void prepare_frag(struct vport *vport, struct sk_buff *skb,
0826              u16 orig_network_offset, u8 mac_proto)
0827 {
0828     unsigned int hlen = skb_network_offset(skb);
0829     struct ovs_frag_data *data;
0830 
0831     data = this_cpu_ptr(&ovs_frag_data_storage);
0832     data->dst = skb->_skb_refdst;
0833     data->vport = vport;
0834     data->cb = *OVS_CB(skb);
0835     data->inner_protocol = skb->inner_protocol;
0836     data->network_offset = orig_network_offset;
0837     if (skb_vlan_tag_present(skb))
0838         data->vlan_tci = skb_vlan_tag_get(skb) | VLAN_CFI_MASK;
0839     else
0840         data->vlan_tci = 0;
0841     data->vlan_proto = skb->vlan_proto;
0842     data->mac_proto = mac_proto;
0843     data->l2_len = hlen;
0844     memcpy(&data->l2_data, skb->data, hlen);
0845 
0846     memset(IPCB(skb), 0, sizeof(struct inet_skb_parm));
0847     skb_pull(skb, hlen);
0848 }
0849 
0850 static void ovs_fragment(struct net *net, struct vport *vport,
0851              struct sk_buff *skb, u16 mru,
0852              struct sw_flow_key *key)
0853 {
0854     u16 orig_network_offset = 0;
0855 
0856     if (eth_p_mpls(skb->protocol)) {
0857         orig_network_offset = skb_network_offset(skb);
0858         skb->network_header = skb->inner_network_header;
0859     }
0860 
0861     if (skb_network_offset(skb) > MAX_L2_LEN) {
0862         OVS_NLERR(1, "L2 header too long to fragment");
0863         goto err;
0864     }
0865 
0866     if (key->eth.type == htons(ETH_P_IP)) {
0867         struct rtable ovs_rt = { 0 };
0868         unsigned long orig_dst;
0869 
0870         prepare_frag(vport, skb, orig_network_offset,
0871                  ovs_key_mac_proto(key));
0872         dst_init(&ovs_rt.dst, &ovs_dst_ops, NULL, 1,
0873              DST_OBSOLETE_NONE, DST_NOCOUNT);
0874         ovs_rt.dst.dev = vport->dev;
0875 
0876         orig_dst = skb->_skb_refdst;
0877         skb_dst_set_noref(skb, &ovs_rt.dst);
0878         IPCB(skb)->frag_max_size = mru;
0879 
0880         ip_do_fragment(net, skb->sk, skb, ovs_vport_output);
0881         refdst_drop(orig_dst);
0882     } else if (key->eth.type == htons(ETH_P_IPV6)) {
0883         unsigned long orig_dst;
0884         struct rt6_info ovs_rt;
0885 
0886         prepare_frag(vport, skb, orig_network_offset,
0887                  ovs_key_mac_proto(key));
0888         memset(&ovs_rt, 0, sizeof(ovs_rt));
0889         dst_init(&ovs_rt.dst, &ovs_dst_ops, NULL, 1,
0890              DST_OBSOLETE_NONE, DST_NOCOUNT);
0891         ovs_rt.dst.dev = vport->dev;
0892 
0893         orig_dst = skb->_skb_refdst;
0894         skb_dst_set_noref(skb, &ovs_rt.dst);
0895         IP6CB(skb)->frag_max_size = mru;
0896 
0897         ipv6_stub->ipv6_fragment(net, skb->sk, skb, ovs_vport_output);
0898         refdst_drop(orig_dst);
0899     } else {
0900         WARN_ONCE(1, "Failed fragment ->%s: eth=%04x, MRU=%d, MTU=%d.",
0901               ovs_vport_name(vport), ntohs(key->eth.type), mru,
0902               vport->dev->mtu);
0903         goto err;
0904     }
0905 
0906     return;
0907 err:
0908     kfree_skb(skb);
0909 }
0910 
0911 static void do_output(struct datapath *dp, struct sk_buff *skb, int out_port,
0912               struct sw_flow_key *key)
0913 {
0914     struct vport *vport = ovs_vport_rcu(dp, out_port);
0915 
0916     if (likely(vport)) {
0917         u16 mru = OVS_CB(skb)->mru;
0918         u32 cutlen = OVS_CB(skb)->cutlen;
0919 
0920         if (unlikely(cutlen > 0)) {
0921             if (skb->len - cutlen > ovs_mac_header_len(key))
0922                 pskb_trim(skb, skb->len - cutlen);
0923             else
0924                 pskb_trim(skb, ovs_mac_header_len(key));
0925         }
0926 
0927         if (likely(!mru ||
0928                    (skb->len <= mru + vport->dev->hard_header_len))) {
0929             ovs_vport_send(vport, skb, ovs_key_mac_proto(key));
0930         } else if (mru <= vport->dev->mtu) {
0931             struct net *net = read_pnet(&dp->net);
0932 
0933             ovs_fragment(net, vport, skb, mru, key);
0934         } else {
0935             kfree_skb(skb);
0936         }
0937     } else {
0938         kfree_skb(skb);
0939     }
0940 }
0941 
0942 static int output_userspace(struct datapath *dp, struct sk_buff *skb,
0943                 struct sw_flow_key *key, const struct nlattr *attr,
0944                 const struct nlattr *actions, int actions_len,
0945                 uint32_t cutlen)
0946 {
0947     struct dp_upcall_info upcall;
0948     const struct nlattr *a;
0949     int rem;
0950 
0951     memset(&upcall, 0, sizeof(upcall));
0952     upcall.cmd = OVS_PACKET_CMD_ACTION;
0953     upcall.mru = OVS_CB(skb)->mru;
0954 
0955     for (a = nla_data(attr), rem = nla_len(attr); rem > 0;
0956          a = nla_next(a, &rem)) {
0957         switch (nla_type(a)) {
0958         case OVS_USERSPACE_ATTR_USERDATA:
0959             upcall.userdata = a;
0960             break;
0961 
0962         case OVS_USERSPACE_ATTR_PID:
0963             if (dp->user_features &
0964                 OVS_DP_F_DISPATCH_UPCALL_PER_CPU)
0965                 upcall.portid =
0966                   ovs_dp_get_upcall_portid(dp,
0967                                smp_processor_id());
0968             else
0969                 upcall.portid = nla_get_u32(a);
0970             break;
0971 
0972         case OVS_USERSPACE_ATTR_EGRESS_TUN_PORT: {
0973             /* Get out tunnel info. */
0974             struct vport *vport;
0975 
0976             vport = ovs_vport_rcu(dp, nla_get_u32(a));
0977             if (vport) {
0978                 int err;
0979 
0980                 err = dev_fill_metadata_dst(vport->dev, skb);
0981                 if (!err)
0982                     upcall.egress_tun_info = skb_tunnel_info(skb);
0983             }
0984 
0985             break;
0986         }
0987 
0988         case OVS_USERSPACE_ATTR_ACTIONS: {
0989             /* Include actions. */
0990             upcall.actions = actions;
0991             upcall.actions_len = actions_len;
0992             break;
0993         }
0994 
0995         } /* End of switch. */
0996     }
0997 
0998     return ovs_dp_upcall(dp, skb, key, &upcall, cutlen);
0999 }
1000 
1001 static int dec_ttl_exception_handler(struct datapath *dp, struct sk_buff *skb,
1002                      struct sw_flow_key *key,
1003                      const struct nlattr *attr)
1004 {
1005     /* The first attribute is always 'OVS_DEC_TTL_ATTR_ACTION'. */
1006     struct nlattr *actions = nla_data(attr);
1007 
1008     if (nla_len(actions))
1009         return clone_execute(dp, skb, key, 0, nla_data(actions),
1010                      nla_len(actions), true, false);
1011 
1012     consume_skb(skb);
1013     return 0;
1014 }
1015 
1016 /* When 'last' is true, sample() should always consume the 'skb'.
1017  * Otherwise, sample() should keep 'skb' intact regardless what
1018  * actions are executed within sample().
1019  */
1020 static int sample(struct datapath *dp, struct sk_buff *skb,
1021           struct sw_flow_key *key, const struct nlattr *attr,
1022           bool last)
1023 {
1024     struct nlattr *actions;
1025     struct nlattr *sample_arg;
1026     int rem = nla_len(attr);
1027     const struct sample_arg *arg;
1028     bool clone_flow_key;
1029 
1030     /* The first action is always 'OVS_SAMPLE_ATTR_ARG'. */
1031     sample_arg = nla_data(attr);
1032     arg = nla_data(sample_arg);
1033     actions = nla_next(sample_arg, &rem);
1034 
1035     if ((arg->probability != U32_MAX) &&
1036         (!arg->probability || prandom_u32() > arg->probability)) {
1037         if (last)
1038             consume_skb(skb);
1039         return 0;
1040     }
1041 
1042     clone_flow_key = !arg->exec;
1043     return clone_execute(dp, skb, key, 0, actions, rem, last,
1044                  clone_flow_key);
1045 }
1046 
1047 /* When 'last' is true, clone() should always consume the 'skb'.
1048  * Otherwise, clone() should keep 'skb' intact regardless what
1049  * actions are executed within clone().
1050  */
1051 static int clone(struct datapath *dp, struct sk_buff *skb,
1052          struct sw_flow_key *key, const struct nlattr *attr,
1053          bool last)
1054 {
1055     struct nlattr *actions;
1056     struct nlattr *clone_arg;
1057     int rem = nla_len(attr);
1058     bool dont_clone_flow_key;
1059 
1060     /* The first action is always 'OVS_CLONE_ATTR_EXEC'. */
1061     clone_arg = nla_data(attr);
1062     dont_clone_flow_key = nla_get_u32(clone_arg);
1063     actions = nla_next(clone_arg, &rem);
1064 
1065     return clone_execute(dp, skb, key, 0, actions, rem, last,
1066                  !dont_clone_flow_key);
1067 }
1068 
1069 static void execute_hash(struct sk_buff *skb, struct sw_flow_key *key,
1070              const struct nlattr *attr)
1071 {
1072     struct ovs_action_hash *hash_act = nla_data(attr);
1073     u32 hash = 0;
1074 
1075     /* OVS_HASH_ALG_L4 is the only possible hash algorithm.  */
1076     hash = skb_get_hash(skb);
1077     hash = jhash_1word(hash, hash_act->hash_basis);
1078     if (!hash)
1079         hash = 0x1;
1080 
1081     key->ovs_flow_hash = hash;
1082 }
1083 
1084 static int execute_set_action(struct sk_buff *skb,
1085                   struct sw_flow_key *flow_key,
1086                   const struct nlattr *a)
1087 {
1088     /* Only tunnel set execution is supported without a mask. */
1089     if (nla_type(a) == OVS_KEY_ATTR_TUNNEL_INFO) {
1090         struct ovs_tunnel_info *tun = nla_data(a);
1091 
1092         skb_dst_drop(skb);
1093         dst_hold((struct dst_entry *)tun->tun_dst);
1094         skb_dst_set(skb, (struct dst_entry *)tun->tun_dst);
1095         return 0;
1096     }
1097 
1098     return -EINVAL;
1099 }
1100 
1101 /* Mask is at the midpoint of the data. */
1102 #define get_mask(a, type) ((const type)nla_data(a) + 1)
1103 
1104 static int execute_masked_set_action(struct sk_buff *skb,
1105                      struct sw_flow_key *flow_key,
1106                      const struct nlattr *a)
1107 {
1108     int err = 0;
1109 
1110     switch (nla_type(a)) {
1111     case OVS_KEY_ATTR_PRIORITY:
1112         OVS_SET_MASKED(skb->priority, nla_get_u32(a),
1113                    *get_mask(a, u32 *));
1114         flow_key->phy.priority = skb->priority;
1115         break;
1116 
1117     case OVS_KEY_ATTR_SKB_MARK:
1118         OVS_SET_MASKED(skb->mark, nla_get_u32(a), *get_mask(a, u32 *));
1119         flow_key->phy.skb_mark = skb->mark;
1120         break;
1121 
1122     case OVS_KEY_ATTR_TUNNEL_INFO:
1123         /* Masked data not supported for tunnel. */
1124         err = -EINVAL;
1125         break;
1126 
1127     case OVS_KEY_ATTR_ETHERNET:
1128         err = set_eth_addr(skb, flow_key, nla_data(a),
1129                    get_mask(a, struct ovs_key_ethernet *));
1130         break;
1131 
1132     case OVS_KEY_ATTR_NSH:
1133         err = set_nsh(skb, flow_key, a);
1134         break;
1135 
1136     case OVS_KEY_ATTR_IPV4:
1137         err = set_ipv4(skb, flow_key, nla_data(a),
1138                    get_mask(a, struct ovs_key_ipv4 *));
1139         break;
1140 
1141     case OVS_KEY_ATTR_IPV6:
1142         err = set_ipv6(skb, flow_key, nla_data(a),
1143                    get_mask(a, struct ovs_key_ipv6 *));
1144         break;
1145 
1146     case OVS_KEY_ATTR_TCP:
1147         err = set_tcp(skb, flow_key, nla_data(a),
1148                   get_mask(a, struct ovs_key_tcp *));
1149         break;
1150 
1151     case OVS_KEY_ATTR_UDP:
1152         err = set_udp(skb, flow_key, nla_data(a),
1153                   get_mask(a, struct ovs_key_udp *));
1154         break;
1155 
1156     case OVS_KEY_ATTR_SCTP:
1157         err = set_sctp(skb, flow_key, nla_data(a),
1158                    get_mask(a, struct ovs_key_sctp *));
1159         break;
1160 
1161     case OVS_KEY_ATTR_MPLS:
1162         err = set_mpls(skb, flow_key, nla_data(a), get_mask(a,
1163                                     __be32 *));
1164         break;
1165 
1166     case OVS_KEY_ATTR_CT_STATE:
1167     case OVS_KEY_ATTR_CT_ZONE:
1168     case OVS_KEY_ATTR_CT_MARK:
1169     case OVS_KEY_ATTR_CT_LABELS:
1170     case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4:
1171     case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6:
1172         err = -EINVAL;
1173         break;
1174     }
1175 
1176     return err;
1177 }
1178 
1179 static int execute_recirc(struct datapath *dp, struct sk_buff *skb,
1180               struct sw_flow_key *key,
1181               const struct nlattr *a, bool last)
1182 {
1183     u32 recirc_id;
1184 
1185     if (!is_flow_key_valid(key)) {
1186         int err;
1187 
1188         err = ovs_flow_key_update(skb, key);
1189         if (err)
1190             return err;
1191     }
1192     BUG_ON(!is_flow_key_valid(key));
1193 
1194     recirc_id = nla_get_u32(a);
1195     return clone_execute(dp, skb, key, recirc_id, NULL, 0, last, true);
1196 }
1197 
1198 static int execute_check_pkt_len(struct datapath *dp, struct sk_buff *skb,
1199                  struct sw_flow_key *key,
1200                  const struct nlattr *attr, bool last)
1201 {
1202     struct ovs_skb_cb *ovs_cb = OVS_CB(skb);
1203     const struct nlattr *actions, *cpl_arg;
1204     int len, max_len, rem = nla_len(attr);
1205     const struct check_pkt_len_arg *arg;
1206     bool clone_flow_key;
1207 
1208     /* The first netlink attribute in 'attr' is always
1209      * 'OVS_CHECK_PKT_LEN_ATTR_ARG'.
1210      */
1211     cpl_arg = nla_data(attr);
1212     arg = nla_data(cpl_arg);
1213 
1214     len = ovs_cb->mru ? ovs_cb->mru + skb->mac_len : skb->len;
1215     max_len = arg->pkt_len;
1216 
1217     if ((skb_is_gso(skb) && skb_gso_validate_mac_len(skb, max_len)) ||
1218         len <= max_len) {
1219         /* Second netlink attribute in 'attr' is always
1220          * 'OVS_CHECK_PKT_LEN_ATTR_ACTIONS_IF_LESS_EQUAL'.
1221          */
1222         actions = nla_next(cpl_arg, &rem);
1223         clone_flow_key = !arg->exec_for_lesser_equal;
1224     } else {
1225         /* Third netlink attribute in 'attr' is always
1226          * 'OVS_CHECK_PKT_LEN_ATTR_ACTIONS_IF_GREATER'.
1227          */
1228         actions = nla_next(cpl_arg, &rem);
1229         actions = nla_next(actions, &rem);
1230         clone_flow_key = !arg->exec_for_greater;
1231     }
1232 
1233     return clone_execute(dp, skb, key, 0, nla_data(actions),
1234                  nla_len(actions), last, clone_flow_key);
1235 }
1236 
1237 static int execute_dec_ttl(struct sk_buff *skb, struct sw_flow_key *key)
1238 {
1239     int err;
1240 
1241     if (skb->protocol == htons(ETH_P_IPV6)) {
1242         struct ipv6hdr *nh;
1243 
1244         err = skb_ensure_writable(skb, skb_network_offset(skb) +
1245                       sizeof(*nh));
1246         if (unlikely(err))
1247             return err;
1248 
1249         nh = ipv6_hdr(skb);
1250 
1251         if (nh->hop_limit <= 1)
1252             return -EHOSTUNREACH;
1253 
1254         key->ip.ttl = --nh->hop_limit;
1255     } else if (skb->protocol == htons(ETH_P_IP)) {
1256         struct iphdr *nh;
1257         u8 old_ttl;
1258 
1259         err = skb_ensure_writable(skb, skb_network_offset(skb) +
1260                       sizeof(*nh));
1261         if (unlikely(err))
1262             return err;
1263 
1264         nh = ip_hdr(skb);
1265         if (nh->ttl <= 1)
1266             return -EHOSTUNREACH;
1267 
1268         old_ttl = nh->ttl--;
1269         csum_replace2(&nh->check, htons(old_ttl << 8),
1270                   htons(nh->ttl << 8));
1271         key->ip.ttl = nh->ttl;
1272     }
1273     return 0;
1274 }
1275 
1276 /* Execute a list of actions against 'skb'. */
1277 static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
1278                   struct sw_flow_key *key,
1279                   const struct nlattr *attr, int len)
1280 {
1281     const struct nlattr *a;
1282     int rem;
1283 
1284     for (a = attr, rem = len; rem > 0;
1285          a = nla_next(a, &rem)) {
1286         int err = 0;
1287 
1288         if (trace_ovs_do_execute_action_enabled())
1289             trace_ovs_do_execute_action(dp, skb, key, a, rem);
1290 
1291         switch (nla_type(a)) {
1292         case OVS_ACTION_ATTR_OUTPUT: {
1293             int port = nla_get_u32(a);
1294             struct sk_buff *clone;
1295 
1296             /* Every output action needs a separate clone
1297              * of 'skb', In case the output action is the
1298              * last action, cloning can be avoided.
1299              */
1300             if (nla_is_last(a, rem)) {
1301                 do_output(dp, skb, port, key);
1302                 /* 'skb' has been used for output.
1303                  */
1304                 return 0;
1305             }
1306 
1307             clone = skb_clone(skb, GFP_ATOMIC);
1308             if (clone)
1309                 do_output(dp, clone, port, key);
1310             OVS_CB(skb)->cutlen = 0;
1311             break;
1312         }
1313 
1314         case OVS_ACTION_ATTR_TRUNC: {
1315             struct ovs_action_trunc *trunc = nla_data(a);
1316 
1317             if (skb->len > trunc->max_len)
1318                 OVS_CB(skb)->cutlen = skb->len - trunc->max_len;
1319             break;
1320         }
1321 
1322         case OVS_ACTION_ATTR_USERSPACE:
1323             output_userspace(dp, skb, key, a, attr,
1324                              len, OVS_CB(skb)->cutlen);
1325             OVS_CB(skb)->cutlen = 0;
1326             break;
1327 
1328         case OVS_ACTION_ATTR_HASH:
1329             execute_hash(skb, key, a);
1330             break;
1331 
1332         case OVS_ACTION_ATTR_PUSH_MPLS: {
1333             struct ovs_action_push_mpls *mpls = nla_data(a);
1334 
1335             err = push_mpls(skb, key, mpls->mpls_lse,
1336                     mpls->mpls_ethertype, skb->mac_len);
1337             break;
1338         }
1339         case OVS_ACTION_ATTR_ADD_MPLS: {
1340             struct ovs_action_add_mpls *mpls = nla_data(a);
1341             __u16 mac_len = 0;
1342 
1343             if (mpls->tun_flags & OVS_MPLS_L3_TUNNEL_FLAG_MASK)
1344                 mac_len = skb->mac_len;
1345 
1346             err = push_mpls(skb, key, mpls->mpls_lse,
1347                     mpls->mpls_ethertype, mac_len);
1348             break;
1349         }
1350         case OVS_ACTION_ATTR_POP_MPLS:
1351             err = pop_mpls(skb, key, nla_get_be16(a));
1352             break;
1353 
1354         case OVS_ACTION_ATTR_PUSH_VLAN:
1355             err = push_vlan(skb, key, nla_data(a));
1356             break;
1357 
1358         case OVS_ACTION_ATTR_POP_VLAN:
1359             err = pop_vlan(skb, key);
1360             break;
1361 
1362         case OVS_ACTION_ATTR_RECIRC: {
1363             bool last = nla_is_last(a, rem);
1364 
1365             err = execute_recirc(dp, skb, key, a, last);
1366             if (last) {
1367                 /* If this is the last action, the skb has
1368                  * been consumed or freed.
1369                  * Return immediately.
1370                  */
1371                 return err;
1372             }
1373             break;
1374         }
1375 
1376         case OVS_ACTION_ATTR_SET:
1377             err = execute_set_action(skb, key, nla_data(a));
1378             break;
1379 
1380         case OVS_ACTION_ATTR_SET_MASKED:
1381         case OVS_ACTION_ATTR_SET_TO_MASKED:
1382             err = execute_masked_set_action(skb, key, nla_data(a));
1383             break;
1384 
1385         case OVS_ACTION_ATTR_SAMPLE: {
1386             bool last = nla_is_last(a, rem);
1387 
1388             err = sample(dp, skb, key, a, last);
1389             if (last)
1390                 return err;
1391 
1392             break;
1393         }
1394 
1395         case OVS_ACTION_ATTR_CT:
1396             if (!is_flow_key_valid(key)) {
1397                 err = ovs_flow_key_update(skb, key);
1398                 if (err)
1399                     return err;
1400             }
1401 
1402             err = ovs_ct_execute(ovs_dp_get_net(dp), skb, key,
1403                          nla_data(a));
1404 
1405             /* Hide stolen IP fragments from user space. */
1406             if (err)
1407                 return err == -EINPROGRESS ? 0 : err;
1408             break;
1409 
1410         case OVS_ACTION_ATTR_CT_CLEAR:
1411             err = ovs_ct_clear(skb, key);
1412             break;
1413 
1414         case OVS_ACTION_ATTR_PUSH_ETH:
1415             err = push_eth(skb, key, nla_data(a));
1416             break;
1417 
1418         case OVS_ACTION_ATTR_POP_ETH:
1419             err = pop_eth(skb, key);
1420             break;
1421 
1422         case OVS_ACTION_ATTR_PUSH_NSH: {
1423             u8 buffer[NSH_HDR_MAX_LEN];
1424             struct nshhdr *nh = (struct nshhdr *)buffer;
1425 
1426             err = nsh_hdr_from_nlattr(nla_data(a), nh,
1427                           NSH_HDR_MAX_LEN);
1428             if (unlikely(err))
1429                 break;
1430             err = push_nsh(skb, key, nh);
1431             break;
1432         }
1433 
1434         case OVS_ACTION_ATTR_POP_NSH:
1435             err = pop_nsh(skb, key);
1436             break;
1437 
1438         case OVS_ACTION_ATTR_METER:
1439             if (ovs_meter_execute(dp, skb, key, nla_get_u32(a))) {
1440                 consume_skb(skb);
1441                 return 0;
1442             }
1443             break;
1444 
1445         case OVS_ACTION_ATTR_CLONE: {
1446             bool last = nla_is_last(a, rem);
1447 
1448             err = clone(dp, skb, key, a, last);
1449             if (last)
1450                 return err;
1451 
1452             break;
1453         }
1454 
1455         case OVS_ACTION_ATTR_CHECK_PKT_LEN: {
1456             bool last = nla_is_last(a, rem);
1457 
1458             err = execute_check_pkt_len(dp, skb, key, a, last);
1459             if (last)
1460                 return err;
1461 
1462             break;
1463         }
1464 
1465         case OVS_ACTION_ATTR_DEC_TTL:
1466             err = execute_dec_ttl(skb, key);
1467             if (err == -EHOSTUNREACH)
1468                 return dec_ttl_exception_handler(dp, skb,
1469                                  key, a);
1470             break;
1471         }
1472 
1473         if (unlikely(err)) {
1474             kfree_skb(skb);
1475             return err;
1476         }
1477     }
1478 
1479     consume_skb(skb);
1480     return 0;
1481 }
1482 
1483 /* Execute the actions on the clone of the packet. The effect of the
1484  * execution does not affect the original 'skb' nor the original 'key'.
1485  *
1486  * The execution may be deferred in case the actions can not be executed
1487  * immediately.
1488  */
1489 static int clone_execute(struct datapath *dp, struct sk_buff *skb,
1490              struct sw_flow_key *key, u32 recirc_id,
1491              const struct nlattr *actions, int len,
1492              bool last, bool clone_flow_key)
1493 {
1494     struct deferred_action *da;
1495     struct sw_flow_key *clone;
1496 
1497     skb = last ? skb : skb_clone(skb, GFP_ATOMIC);
1498     if (!skb) {
1499         /* Out of memory, skip this action.
1500          */
1501         return 0;
1502     }
1503 
1504     /* When clone_flow_key is false, the 'key' will not be change
1505      * by the actions, then the 'key' can be used directly.
1506      * Otherwise, try to clone key from the next recursion level of
1507      * 'flow_keys'. If clone is successful, execute the actions
1508      * without deferring.
1509      */
1510     clone = clone_flow_key ? clone_key(key) : key;
1511     if (clone) {
1512         int err = 0;
1513 
1514         if (actions) { /* Sample action */
1515             if (clone_flow_key)
1516                 __this_cpu_inc(exec_actions_level);
1517 
1518             err = do_execute_actions(dp, skb, clone,
1519                          actions, len);
1520 
1521             if (clone_flow_key)
1522                 __this_cpu_dec(exec_actions_level);
1523         } else { /* Recirc action */
1524             clone->recirc_id = recirc_id;
1525             ovs_dp_process_packet(skb, clone);
1526         }
1527         return err;
1528     }
1529 
1530     /* Out of 'flow_keys' space. Defer actions */
1531     da = add_deferred_actions(skb, key, actions, len);
1532     if (da) {
1533         if (!actions) { /* Recirc action */
1534             key = &da->pkt_key;
1535             key->recirc_id = recirc_id;
1536         }
1537     } else {
1538         /* Out of per CPU action FIFO space. Drop the 'skb' and
1539          * log an error.
1540          */
1541         kfree_skb(skb);
1542 
1543         if (net_ratelimit()) {
1544             if (actions) { /* Sample action */
1545                 pr_warn("%s: deferred action limit reached, drop sample action\n",
1546                     ovs_dp_name(dp));
1547             } else {  /* Recirc action */
1548                 pr_warn("%s: deferred action limit reached, drop recirc action (recirc_id=%#x)\n",
1549                     ovs_dp_name(dp), recirc_id);
1550             }
1551         }
1552     }
1553     return 0;
1554 }
1555 
1556 static void process_deferred_actions(struct datapath *dp)
1557 {
1558     struct action_fifo *fifo = this_cpu_ptr(action_fifos);
1559 
1560     /* Do not touch the FIFO in case there is no deferred actions. */
1561     if (action_fifo_is_empty(fifo))
1562         return;
1563 
1564     /* Finishing executing all deferred actions. */
1565     do {
1566         struct deferred_action *da = action_fifo_get(fifo);
1567         struct sk_buff *skb = da->skb;
1568         struct sw_flow_key *key = &da->pkt_key;
1569         const struct nlattr *actions = da->actions;
1570         int actions_len = da->actions_len;
1571 
1572         if (actions)
1573             do_execute_actions(dp, skb, key, actions, actions_len);
1574         else
1575             ovs_dp_process_packet(skb, key);
1576     } while (!action_fifo_is_empty(fifo));
1577 
1578     /* Reset FIFO for the next packet.  */
1579     action_fifo_init(fifo);
1580 }
1581 
1582 /* Execute a list of actions against 'skb'. */
1583 int ovs_execute_actions(struct datapath *dp, struct sk_buff *skb,
1584             const struct sw_flow_actions *acts,
1585             struct sw_flow_key *key)
1586 {
1587     int err, level;
1588 
1589     level = __this_cpu_inc_return(exec_actions_level);
1590     if (unlikely(level > OVS_RECURSION_LIMIT)) {
1591         net_crit_ratelimited("ovs: recursion limit reached on datapath %s, probable configuration error\n",
1592                      ovs_dp_name(dp));
1593         kfree_skb(skb);
1594         err = -ENETDOWN;
1595         goto out;
1596     }
1597 
1598     OVS_CB(skb)->acts_origlen = acts->orig_len;
1599     err = do_execute_actions(dp, skb, key,
1600                  acts->actions, acts->actions_len);
1601 
1602     if (level == 1)
1603         process_deferred_actions(dp);
1604 
1605 out:
1606     __this_cpu_dec(exec_actions_level);
1607     return err;
1608 }
1609 
1610 int action_fifos_init(void)
1611 {
1612     action_fifos = alloc_percpu(struct action_fifo);
1613     if (!action_fifos)
1614         return -ENOMEM;
1615 
1616     flow_keys = alloc_percpu(struct action_flow_keys);
1617     if (!flow_keys) {
1618         free_percpu(action_fifos);
1619         return -ENOMEM;
1620     }
1621 
1622     return 0;
1623 }
1624 
1625 void action_fifos_exit(void)
1626 {
1627     free_percpu(action_fifos);
1628     free_percpu(flow_keys);
1629 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!