cregit-Linux how code gets into the kernel

Release 4.8 net/openvswitch/actions.c

Directory: net/openvswitch
/*
 * Copyright (c) 2007-2014 Nicira, Inc.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/skbuff.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/openvswitch.h>
#include <linux/netfilter_ipv6.h>
#include <linux/sctp.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/in6.h>
#include <linux/if_arp.h>
#include <linux/if_vlan.h>

#include <net/dst.h>
#include <net/ip.h>
#include <net/ipv6.h>
#include <net/ip6_fib.h>
#include <net/checksum.h>
#include <net/dsfield.h>
#include <net/mpls.h>
#include <net/sctp/checksum.h>

#include "datapath.h"
#include "flow.h"
#include "conntrack.h"
#include "vport.h"

static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
			      struct sw_flow_key *key,
			      const struct nlattr *attr, int len);


struct deferred_action {
	
struct sk_buff *skb;
	
const struct nlattr *actions;

	/* Store pkt_key clone when creating deferred action. */
	
struct sw_flow_key pkt_key;
};


#define MAX_L2_LEN	(VLAN_ETH_HLEN + 3 * MPLS_HLEN)

struct ovs_frag_data {
	
unsigned long dst;
	
struct vport *vport;
	
struct ovs_skb_cb cb;
	
__be16 inner_protocol;
	
__u16 vlan_tci;
	
__be16 vlan_proto;
	
unsigned int l2_len;
	
u8 l2_data[MAX_L2_LEN];
};

static DEFINE_PER_CPU(struct ovs_frag_data, ovs_frag_data_storage);


#define DEFERRED_ACTION_FIFO_SIZE 10

struct action_fifo {
	
int head;
	
int tail;
	/* Deferred action fifo queue storage. */
	
struct deferred_action fifo[DEFERRED_ACTION_FIFO_SIZE];
};


static struct action_fifo __percpu *action_fifos;
static DEFINE_PER_CPU(int, exec_actions_level);


static void action_fifo_init(struct action_fifo *fifo) { fifo->head = 0; fifo->tail = 0; }

Contributors

PersonTokensPropCommitsCommitProp
andy zhouandy zhou23100.00%1100.00%
Total23100.00%1100.00%


static bool action_fifo_is_empty(const struct action_fifo *fifo) { return (fifo->head == fifo->tail); }

Contributors

PersonTokensPropCommitsCommitProp
andy zhouandy zhou2295.65%150.00%
thomas grafthomas graf14.35%150.00%
Total23100.00%2100.00%


static struct deferred_action *action_fifo_get(struct action_fifo *fifo) { if (action_fifo_is_empty(fifo)) return NULL; return &fifo->fifo[fifo->tail++]; }

Contributors

PersonTokensPropCommitsCommitProp
andy zhouandy zhou35100.00%1100.00%
Total35100.00%1100.00%


static struct deferred_action *action_fifo_put(struct action_fifo *fifo) { if (fifo->head >= DEFERRED_ACTION_FIFO_SIZE - 1) return NULL; return &fifo->fifo[fifo->head++]; }

Contributors

PersonTokensPropCommitsCommitProp
andy zhouandy zhou38100.00%1100.00%
Total38100.00%1100.00%

/* Return true if fifo is not full */
static struct deferred_action *add_deferred_actions(struct sk_buff *skb, const struct sw_flow_key *key, const struct nlattr *attr) { struct action_fifo *fifo; struct deferred_action *da; fifo = this_cpu_ptr(action_fifos); da = action_fifo_put(fifo); if (da) { da->skb = skb; da->actions = attr; da->pkt_key = *key; } return da; }

Contributors

PersonTokensPropCommitsCommitProp
andy zhouandy zhou7698.70%150.00%
thomas grafthomas graf11.30%150.00%
Total77100.00%2100.00%


static void invalidate_flow_key(struct sw_flow_key *key) { key->eth.type = htons(0); }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar22100.00%1100.00%
Total22100.00%1100.00%


static bool is_flow_key_valid(const struct sw_flow_key *key) { return !!key->eth.type; }

Contributors

PersonTokensPropCommitsCommitProp
pravin b shelarpravin b shelar21100.00%1100.00%
Total21100.00%1100.00%


static void update_ethertype(struct sk_buff *skb, struct ethhdr *hdr, __be16 ethertype) { if (skb->ip_summed == CHECKSUM_COMPLETE) { __be16 diff[] = { ~(hdr->h_proto), ethertype }; skb->csum = ~csum_partial((char *)diff, sizeof(diff), ~skb->csum); } hdr->h_proto = ethertype; }

Contributors

PersonTokensPropCommitsCommitProp
simon hormansimon horman74100.00%1100.00%
Total74100.00%1100.00%


static int push_mpls(struct sk_buff *skb, struct sw_flow_key *key, const struct ovs_action_push_mpls *mpls) { __be32 *new_mpls_lse; /* Networking stack do not allow simultaneous Tunnel and MPLS GSO. */ if (skb->encapsulation) return -ENOTSUPP; if (skb_cow_head(skb, MPLS_HLEN) < 0) return -ENOMEM; skb_push(skb, MPLS_HLEN); memmove(skb_mac_header(skb) - MPLS_HLEN, skb_mac_header(skb), skb->mac_len); skb_reset_mac_header(skb); new_mpls_lse = (__be32 *)skb_mpls_header(skb); *new_mpls_lse = mpls->mpls_lse; skb_postpush_rcsum(skb, new_mpls_lse, MPLS_HLEN); update_ethertype(skb, eth_hdr(skb), mpls->mpls_ethertype); if (!skb->inner_protocol) skb_set_inner_protocol(skb, skb->protocol); skb->protocol = mpls->mpls_ethertype; invalidate_flow_key(key); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
simon hormansimon horman13888.46%240.00%
pravin b shelarpravin b shelar1710.90%240.00%
daniel borkmanndaniel borkmann10.64%120.00%
Total156100.00%5100.00%


static int pop_mpls(struct sk_buff *skb, struct sw_flow_key *key, const __be16 ethertype) { struct ethhdr *hdr; int err; err = skb_ensure_writable(skb, skb->mac_len + MPLS_HLEN); if (unlikely(err)) return err; skb_postpull_rcsum(skb, skb_mpls_header(skb), MPLS_HLEN); memmove(skb_mac_header(skb) + MPLS_HLEN, skb_mac_header(skb), skb->mac_len); __skb_pull(skb, MPLS_HLEN); skb_reset_mac_header(skb); /* skb_mpls_header() is used to locate the ethertype * field correctly in the presence of VLAN tags. */ hdr = (struct ethhdr *)(skb_mpls_header(skb) - ETH_HLEN); update_ethertype(skb, hdr, ethertype); if (eth_p_mpls(skb->protocol)) skb->protocol = ethertype; invalidate_flow_key(key); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
simon hormansimon horman13191.61%240.00%
pravin b shelarpravin b shelar106.99%120.00%
jiri pirkojiri pirko21.40%240.00%
Total143100.00%5100.00%


static int set_mpls(struct sk_buff *skb, struct sw_flow_key *flow_key, const __be32 *mpls_lse, const __be32 *mask) { __be32 *stack; __be32 lse; int err; err = skb_ensure_writable(skb, skb->mac_len + MPLS_HLEN); if (unlikely(err)) return err; stack = (__be32 *)skb_mpls_header(skb); lse = OVS_MASKED(*stack, *mpls_lse, *mask); if (skb->ip_summed == CHECKSUM_COMPLETE) { __be32 diff[] = { ~(*stack), lse }; skb->csum = ~csum_partial((char *)diff, sizeof(diff), ~skb->csum); } *stack = lse; flow_key->mpls.top_lse = lse; return 0; }

Contributors

PersonTokensPropCommitsCommitProp
simon hormansimon horman11074.32%120.00%
jarno rajahalmejarno rajahalme2617.57%120.00%
pravin b shelarpravin b shelar106.76%120.00%
joe stringerjoe stringer10.68%120.00%
jiri pirkojiri pirko10.68%120.00%
Total148100.00%5100.00%


static int pop_vlan(struct sk_buff *skb, struct sw_flow_key *key) { int err; err = skb_vlan_pop(skb); if (skb_vlan_tag_present(skb)) invalidate_flow_key(key); else key->eth.tci = 0; return err; }

Contributors

PersonTokensPropCommitsCommitProp
jesse grossjesse gross3060.00%125.00%
pravin b shelarpravin b shelar1326.00%125.00%
jiri pirkojiri pirko714.00%250.00%
Total50100.00%4100.00%


static int push_vlan(struct sk_buff *skb, struct sw_flow_key *key, const struct ovs_action_push_vlan *vlan) { if (skb_vlan_tag_present(skb)) invalidate_flow_key(key); else key->eth.tci = vlan->vlan_tci; return skb_vlan_push(skb, vlan->vlan_tpid, ntohs(vlan->vlan_tci) & ~VLAN_TAG_PRESENT); }

Contributors

PersonTokensPropCommitsCommitProp
jesse grossjesse gross3756.92%120.00%
pravin b shelarpravin b shelar2132.31%120.00%
patrick mchardypatrick mchardy46.15%120.00%
jiri pirkojiri pirko34.62%240.00%
Total65100.00%5100.00%

/* 'src' is already properly masked. */
static void ether_addr_copy_masked(u8 *dst_, const u8 *src_, const u8 *mask_) { u16 *dst = (u16 *)dst_; const u16 *src = (const u16 *)src_; const u16 *mask = (const u16 *)mask_; OVS_SET_MASKED(dst[0], src[0], mask[0]); OVS_SET_MASKED(dst[1], src[1], mask[1]); OVS_SET_MASKED(dst[2], src[2], mask[2]); }

Contributors

PersonTokensPropCommitsCommitProp
jarno rajahalmejarno rajahalme10597.22%150.00%
joe stringerjoe stringer32.78%150.00%
Total108100.00%2100.00%


static int set_eth_addr(struct sk_buff *skb, struct sw_flow_key *flow_key, const struct ovs_key_ethernet *key, const struct ovs_key_ethernet *mask) { int err; err = skb_ensure_writable(skb, ETH_HLEN); if (unlikely(err)) return err; skb_postpull_rcsum(skb, eth_hdr(skb), ETH_ALEN * 2); ether_addr_copy_masked(eth_hdr(skb)->h_source, key->eth_src, mask->eth_src); ether_addr_copy_masked(eth_hdr(skb)->h_dest, key->eth_dst, mask->eth_dst); skb_postpush_rcsum(skb, eth_hdr(skb), ETH_ALEN * 2); ether_addr_copy(flow_key->eth.src, eth_hdr(skb)->h_source); ether_addr_copy(flow_key->eth.dst, eth_hdr(skb)->h_dest); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
jesse grossjesse gross6442.95%116.67%
pravin b shelarpravin b shelar5234.90%233.33%
jarno rajahalmejarno rajahalme3120.81%116.67%
daniel borkmanndaniel borkmann10.67%116.67%
jiri pirkojiri pirko10.67%116.67%
Total149100.00%6100.00%


static void update_ip_l4_checksum(struct sk_buff *skb, struct iphdr *nh, __be32 addr, __be32 new_addr) { int transport_len = skb->len - skb_transport_offset(skb); if (nh->frag_off & htons(IP_OFFSET)) return; if (nh->protocol == IPPROTO_TCP) { if (likely(transport_len >= sizeof(struct tcphdr))) inet_proto_csum_replace4(&tcp_hdr(skb)->check, skb, addr, new_addr, true); } else if (nh->protocol == IPPROTO_UDP) { if (likely(transport_len >= sizeof(struct udphdr))) { struct udphdr *uh = udp_hdr(skb); if (uh->check || skb->ip_summed == CHECKSUM_PARTIAL) { inet_proto_csum_replace4(&uh->check, skb, addr, new_addr, true); if (!uh->check) uh->check = CSUM_MANGLED_0; } } } }

Contributors

PersonTokensPropCommitsCommitProp
jesse grossjesse gross15190.42%250.00%
glenn griffinglenn griffin148.38%125.00%
tom herberttom herbert21.20%125.00%
Total167100.00%4100.00%


static void set_ip_addr(struct sk_buff *skb, struct iphdr *nh, __be32 *addr, __be32 new_addr) { update_ip_l4_checksum(skb, nh, *addr, new_addr); csum_replace4(&nh->check, *addr, new_addr); skb_clear_hash(skb); *addr = new_addr; }

Contributors

PersonTokensPropCommitsCommitProp
glenn griffinglenn griffin3458.62%133.33%
jesse grossjesse gross2136.21%133.33%
tom herberttom herbert35.17%133.33%
Total58100.00%3100.00%


static void update_ipv6_checksum(struct sk_buff *skb, u8 l4_proto, __be32 addr[4], const __be32 new_addr[4]) { int transport_len = skb->len - skb_transport_offset(skb); if (l4_proto == NEXTHDR_TCP) { if (likely(transport_len >= sizeof(struct tcphdr))) inet_proto_csum_replace16(&tcp_hdr(skb)->check, skb, addr, new_addr, true); } else if (l4_proto == NEXTHDR_UDP) { if (likely(transport_len >= sizeof(struct udphdr))) { struct udphdr *uh = udp_hdr(skb); if (uh->check || skb->ip_summed == CHECKSUM_PARTIAL) { inet_proto_csum_replace16(&uh->check, skb, addr, new_addr, true); if (!uh->check) uh->check = CSUM_MANGLED_0; } } } else if (l4_proto == NEXTHDR_ICMP) { if (likely(transport_len >= sizeof(struct icmp6hdr))) inet_proto_csum_replace16(&icmp6_hdr(skb)->icmp6_cksum, skb, addr, new_addr, true); } }

Contributors

PersonTokensPropCommitsCommitProp
ansis attekaansis atteka15277.16%133.33%
jesse grossjesse gross4221.32%133.33%
tom herberttom herbert31.52%133.33%
Total197100.00%3100.00%


static void mask_ipv6_addr(const __be32 old[4], const __be32 addr[4], const __be32 mask[4], __be32 masked[4]) { masked[0] = OVS_MASKED(old[0], addr[0], mask[0]); masked[1] = OVS_MASKED(old[1], addr[1], mask[1]); masked[2] = OVS_MASKED(old[2], addr[2], mask[2]); masked[3] = OVS_MASKED(old[3], addr[3], mask[3]); }

Contributors

PersonTokensPropCommitsCommitProp
jarno rajahalmejarno rajahalme8568.00%125.00%
ansis attekaansis atteka3427.20%125.00%
joe stringerjoe stringer43.20%125.00%
tom herberttom herbert21.60%125.00%
Total125100.00%4100.00%


static void set_ipv6_addr(struct sk_buff *skb, u8 l4_proto, __be32 addr[4], const __be32 new_addr[4], bool recalculate_csum) { if (recalculate_csum) update_ipv6_checksum(skb, l4_proto, addr, new_addr); skb_clear_hash(skb); memcpy(addr, new_addr, sizeof(__be32[4])); }

Contributors

PersonTokensPropCommitsCommitProp
jarno rajahalmejarno rajahalme5889.23%150.00%
ansis attekaansis atteka710.77%150.00%
Total65100.00%2100.00%


static void set_ipv6_fl(struct ipv6hdr *nh, u32 fl, u32 mask) { /* Bits 21-24 are always unmasked, so this retains their values. */ OVS_SET_MASKED(nh->flow_lbl[0], (u8)(fl >> 16), (u8)(mask >> 16)); OVS_SET_MASKED(nh->flow_lbl[1], (u8)(fl >> 8), (u8)(mask >> 8)); OVS_SET_MASKED(nh->flow_lbl[2], (u8)fl, (u8)mask); }

Contributors

PersonTokensPropCommitsCommitProp
jarno rajahalmejarno rajahalme4952.13%133.33%
ansis attekaansis atteka4244.68%133.33%
joe stringerjoe stringer33.19%133.33%
Total94100.00%3100.00%


static void set_ip_ttl(struct sk_buff *skb, struct iphdr *nh, u8 new_ttl, u8 mask) { new_ttl = OVS_MASKED(nh->ttl, new_ttl, mask); csum_replace2(&nh->check, htons(nh->ttl << 8), htons(new_ttl << 8)); nh->ttl = new_ttl; }

Contributors

PersonTokensPropCommitsCommitProp
jesse grossjesse gross4975.38%133.33%
jarno rajahalmejarno rajahalme1523.08%133.33%
joe stringerjoe stringer11.54%133.33%
Total65100.00%3100.00%


static int set_ipv4(struct sk_buff *skb, struct sw_flow_key *flow_key, const struct ovs_key_ipv4 *key, const struct ovs_key_ipv4 *mask) { struct iphdr *nh; __be32 new_addr; int err; err = skb_ensure_writable(skb, skb_network_offset(skb) + sizeof(struct iphdr)); if (unlikely(err)) return err; nh = ip_hdr(skb); /* Setting an IP addresses is typically only a side effect of * matching on them in the current userspace implementation, so it * makes sense to check if the value actually changed. */ if (mask->ipv4_src) { new_addr = OVS_MASKED(nh->saddr, key->ipv4_src, mask->ipv4_src); if (unlikely(new_addr != nh->saddr)) { set_ip_addr(skb, nh, &nh->saddr, new_addr); flow_key->ipv4.addr.src = new_addr; } } if (mask->ipv4_dst) { new_addr = OVS_MASKED(nh->daddr, key->ipv4_dst, mask->ipv4_dst); if (unlikely(new_addr != nh->daddr)) { set_ip_addr(skb, nh, &nh->daddr, new_addr); flow_key->ipv4.addr.dst = new_addr; } } if (mask->ipv4_tos) { ipv4_change_dsfield(nh, ~mask->ipv4_tos, key->ipv4_tos); flow_key->ip.tos = nh->tos; } if (mask->ipv4_ttl) { set_ip_ttl(skb, nh, key->ipv4_ttl, mask->ipv4_ttl); flow_key->ip.ttl = nh->ttl; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
jesse grossjesse gross13450.19%120.00%
jarno rajahalmejarno rajahalme8531.84%120.00%
pravin b shelarpravin b shelar4516.85%120.00%
joe stringerjoe stringer20.75%120.00%
jiri pirkojiri pirko10.37%120.00%
Total267100.00%5100.00%


static bool is_ipv6_mask_nonzero(const __be32 addr[4]) { return !!(addr[0] | addr[1] | addr[2] | addr[3]); }

Contributors

PersonTokensPropCommitsCommitProp
jarno rajahalmejarno rajahalme38100.00%1100.00%
Total38100.00%1100.00%


static int set_ipv6(struct sk_buff *skb, struct sw_flow_key *flow_key, const struct ovs_key_ipv6 *key, const struct ovs_key_ipv6 *mask) { struct ipv6hdr *nh; int err; err = skb_ensure_writable(skb, skb_network_offset(skb) + sizeof(struct ipv6hdr)); if (unlikely(err)) return err; nh = ipv6_hdr(skb); /* Setting an IP addresses is typically only a side effect of * matching on them in the current userspace implementation, so it * makes sense to check if the value actually changed. */ if (is_ipv6_mask_nonzero(mask->ipv6_src)) { __be32 *saddr = (__be32 *)&nh->saddr; __be32 masked[4]; mask_ipv6_addr(saddr, key->ipv6_src, mask->ipv6_src, masked); if (unlikely(memcmp(saddr, masked, sizeof(masked)))) { set_ipv6_addr(skb, flow_key->ip.proto, saddr, masked, true); memcpy(&flow_key->ipv6.addr.src, masked, sizeof(flow_key->ipv6.addr.src)); } } if (is_ipv6_mask_nonzero(mask->ipv6_dst)) { unsigned int offset = 0; int flags = IP6_FH_F_SKIP_RH; bool recalc_csum = true; __be32 *daddr = (__be32 *)&nh->daddr; __be32 masked[4]; mask_ipv6_addr(daddr, key->ipv6_dst, mask->ipv6_dst, masked); if (unlikely(memcmp(daddr, masked, sizeof(masked)))) { if (ipv6_ext_hdr(nh->nexthdr)) recalc_csum = (ipv6_find_hdr(skb, &offset, NEXTHDR_ROUTING, NULL, &flags) != NEXTHDR_ROUTING); set_ipv6_addr(skb, flow_key->ip.proto, daddr, masked, recalc_csum); memcpy(&flow_key->ipv6.addr.dst, masked, sizeof(flow_key->ipv6.addr.dst)); } } if (mask->ipv6_tclass) { ipv6_change_dsfield(nh, ~mask->ipv6_tclass, key->ipv6_tclass); flow_key->ip.tos = ipv6_get_dsfield(nh); } if (mask->ipv6_label) { set_ipv6_fl(nh, ntohl(key->ipv6_label), ntohl(mask->ipv6_label)); flow_key->ipv6.label = *(__be32 *)nh & htonl(IPV6_FLOWINFO_FLOWLABEL); } if (mask->ipv6_hlimit) { OVS_SET_MASKED(nh->hop_limit, key->ipv6_hlimit, mask->ipv6_hlimit); flow_key->ip.ttl = nh->hop_limit; } return 0; }

Contributors

PersonTokensPropCommitsCommitProp
ansis attekaansis atteka18541.67%116.67%
jarno rajahalmejarno rajahalme17439.19%116.67%
pravin b shelarpravin b shelar7516.89%116.67%
simon hormansimon horman81.80%116.67%
joe stringerjoe stringer10.23%116.67%
jiri pirkojiri pirko10.23%116.67%
Total444100.00%6100.00%

/* Must follow skb_ensure_writable() since that can move the skb data. */
static void set_tp_port(struct sk_buff *skb, __be16 *port, __be16 new_port, __sum16 *check) { inet_proto_csum_replace2(check, skb, *port, new_port, false); *port = new_port; }

Contributors

PersonTokensPropCommitsCommitProp
jesse grossjesse gross3585.37%250.00%
jarno rajahalmejarno rajahalme512.20%125.00%
tom herberttom herbert12.44%125.00%
Total41100.00%4100.00%


static int set_udp(struct sk_buff *skb, struct sw_flow_key *flow_key, const struct ovs_key_udp *key,