User-Space MPLS actions and matches

[sliver-openvswitch.git] / lib / meta-flow.c

diff --git a/lib/meta-flow.c b/lib/meta-flow.c
index ebbd605..6f7a3aa 100644 (file)
--- a/lib/meta-flow.c
+++ b/lib/meta-flow.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011, 2012 Nicira, Inc.
+ * Copyright (c) 2011, 2012, 2013 Nicira, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,6 @@
 
 #include "meta-flow.h"
 
-#include <assert.h>
 #include <errno.h>
 #include <limits.h>
 #include <netinet/icmp6.h>
@@ -257,6 +256,38 @@ static const struct mf_field mf_fields[MFF_N_IDS] = {
         OXM_OF_VLAN_PCP, "OXM_OF_VLAN_PCP",
     },
 
+    /* ## ---- ## */
+    /* ## L2.5 ## */
+    /* ## ---- ## */
+    {
+        MFF_MPLS_LABEL, "mpls_label", NULL,
+        4, 20,
+        MFM_NONE,
+        MFS_DECIMAL,
+        MFP_MPLS,
+        true,
+        OXM_OF_MPLS_LABEL, "OXM_OF_MPLS_LABEL",
+        OXM_OF_MPLS_LABEL, "OXM_OF_MPLS_LABEL",
+    }, {
+        MFF_MPLS_TC, "mpls_tc", NULL,
+        1, 3,
+        MFM_NONE,
+        MFS_DECIMAL,
+        MFP_MPLS,
+        true,
+        OXM_OF_MPLS_TC, "OXM_OF_MPLS_TC",
+        OXM_OF_MPLS_TC, "OXM_OF_MPLS_TC",
+    }, {
+        MFF_MPLS_BOS, "mpls_bos", NULL,
+        1, 1,
+        MFM_NONE,
+        MFS_DECIMAL,
+        MFP_MPLS,
+        false,
+        OXM_OF_MPLS_BOS, "OXM_OF_MPLS_BOS",
+        OXM_OF_MPLS_BOS, "OXM_OF_MPLS_BOS",
+    },
+
     /* ## -- ## */
     /* ## L3 ## */
     /* ## -- ## */
@@ -543,7 +574,7 @@ const struct mf_field *mf_from_nxm_header__(uint32_t header);
 const struct mf_field *
 mf_from_id(enum mf_field_id id)
 {
-    assert((unsigned int) id < MFF_N_IDS);
+    ovs_assert((unsigned int) id < MFF_N_IDS);
     return &mf_fields[id];
 }
 
@@ -583,7 +614,7 @@ static void
 nxm_init_add_field(const struct mf_field *mf, uint32_t header)
 {
     if (header) {
-        assert(!mf_from_nxm_header__(header));
+        ovs_assert(!mf_from_nxm_header__(header));
         add_nxm_field(header, mf);
         if (mf->maskable != MFM_NONE) {
             add_nxm_field(NXM_MAKE_WILD_HEADER(header), mf);
@@ -679,6 +710,13 @@ mf_is_all_wild(const struct mf_field *mf, const struct flow_wildcards *wc)
     case MFF_VLAN_PCP:
         return !(wc->masks.vlan_tci & htons(VLAN_PCP_MASK));
 
+    case MFF_MPLS_LABEL:
+        return !(wc->masks.mpls_lse & htonl(MPLS_LABEL_MASK));
+    case MFF_MPLS_TC:
+        return !(wc->masks.mpls_lse & htonl(MPLS_TC_MASK));
+    case MFF_MPLS_BOS:
+        return !(wc->masks.mpls_lse & htonl(MPLS_BOS_MASK));
+
     case MFF_IPV4_SRC:
         return !wc->masks.nw_src;
     case MFF_IPV4_DST:
@@ -761,13 +799,6 @@ mf_is_mask_valid(const struct mf_field *mf, const union mf_value *mask)
     NOT_REACHED();
 }
 
-static bool
-is_ip_any(const struct flow *flow)
-{
-    return (flow->dl_type == htons(ETH_TYPE_IP) ||
-            flow->dl_type == htons(ETH_TYPE_IPV6));
-}
-
 static bool
 is_icmpv4(const struct flow *flow)
 {
@@ -799,6 +830,8 @@ mf_are_prereqs_ok(const struct mf_field *mf, const struct flow *flow)
         return flow->dl_type == htons(ETH_TYPE_IPV6);
     case MFP_VLAN_VID:
         return (flow->vlan_tci & htons(VLAN_CFI)) != 0;
+    case MFP_MPLS:
+        return eth_type_mpls(flow->dl_type);
     case MFP_IP_ANY:
         return is_ip_any(flow);
 
@@ -903,6 +936,15 @@ mf_is_value_valid(const struct mf_field *mf, const union mf_value *value)
     case MFF_IPV6_LABEL:
         return !(value->be32 & ~htonl(IPV6_LABEL_MASK));
 
+    case MFF_MPLS_LABEL:
+        return !(value->be32 & ~htonl(MPLS_LABEL_MASK >> MPLS_LABEL_SHIFT));
+
+    case MFF_MPLS_TC:
+        return !(value->u8 & ~(MPLS_TC_MASK >> MPLS_TC_SHIFT));
+
+    case MFF_MPLS_BOS:
+        return !(value->u8 & ~(MPLS_BOS_MASK >> MPLS_BOS_SHIFT));
+
     case MFF_N_IDS:
     default:
         NOT_REACHED();
@@ -944,11 +986,11 @@ mf_get_value(const struct mf_field *mf, const struct flow *flow,
         break;
 
     case MFF_SKB_PRIORITY:
-        value->be32 = flow->skb_priority;
+        value->be32 = htonl(flow->skb_priority);
         break;
 
     case MFF_SKB_MARK:
-        value->be32 = flow->skb_mark;
+        value->be32 = htonl(flow->skb_mark);
         break;
 
     CASE_MFF_REGS:
@@ -983,6 +1025,18 @@ mf_get_value(const struct mf_field *mf, const struct flow *flow,
         value->u8 = vlan_tci_to_pcp(flow->vlan_tci);
         break;
 
+    case MFF_MPLS_LABEL:
+        value->be32 = htonl(mpls_lse_to_label(flow->mpls_lse));
+        break;
+
+    case MFF_MPLS_TC:
+        value->u8 = mpls_lse_to_tc(flow->mpls_lse);
+        break;
+
+    case MFF_MPLS_BOS:
+        value->u8 = mpls_lse_to_bos(flow->mpls_lse);
+        break;
+
     case MFF_IPV4_SRC:
         value->be32 = flow->nw_src;
         break;
@@ -1150,6 +1204,18 @@ mf_set_value(const struct mf_field *mf,
         match_set_dl_vlan_pcp(match, value->u8);
         break;
 
+    case MFF_MPLS_LABEL:
+        match_set_mpls_label(match, value->be32);
+        break;
+
+    case MFF_MPLS_TC:
+        match_set_mpls_tc(match, value->u8);
+        break;
+
+    case MFF_MPLS_BOS:
+        match_set_mpls_bos(match, value->u8);
+        break;
+
     case MFF_IPV4_SRC:
         match_set_nw_src(match, value->be32);
         break;
@@ -1317,6 +1383,18 @@ mf_set_flow_value(const struct mf_field *mf,
         flow_set_vlan_pcp(flow, value->u8);
         break;
 
+    case MFF_MPLS_LABEL:
+        flow_set_mpls_label(flow, value->be32);
+        break;
+
+    case MFF_MPLS_TC:
+        flow_set_mpls_tc(flow, value->u8);
+        break;
+
+    case MFF_MPLS_BOS:
+        flow_set_mpls_bos(flow, value->u8);
+        break;
+
     case MFF_IPV4_SRC:
         flow->nw_src = value->be32;
         break;
@@ -1453,6 +1531,7 @@ mf_set_wild(const struct mf_field *mf, struct match *match)
 
     case MFF_METADATA:
         match_set_metadata_masked(match, htonll(0), htonll(0));
+        break;
 
     case MFF_IN_PORT:
         match->flow.in_port = 0;
@@ -1502,6 +1581,18 @@ mf_set_wild(const struct mf_field *mf, struct match *match)
         match_set_any_pcp(match);
         break;
 
+    case MFF_MPLS_LABEL:
+        match_set_any_mpls_label(match);
+        break;
+
+    case MFF_MPLS_TC:
+        match_set_any_mpls_tc(match);
+        break;
+
+    case MFF_MPLS_BOS:
+        match_set_any_mpls_bos(match);
+        break;
+
     case MFF_IPV4_SRC:
     case MFF_ARP_SPA:
         match_set_nw_src_masked(match, htonl(0), htonl(0));
@@ -1629,6 +1720,9 @@ mf_set(const struct mf_field *mf,
     case MFF_DL_VLAN:
     case MFF_DL_VLAN_PCP:
     case MFF_VLAN_PCP:
+    case MFF_MPLS_LABEL:
+    case MFF_MPLS_TC:
+    case MFF_MPLS_BOS:
     case MFF_IP_PROTO:
     case MFF_IP_TTL:
     case MFF_IP_DSCP:
@@ -1886,6 +1980,18 @@ mf_random_value(const struct mf_field *mf, union mf_value *value)
         value->u8 &= 0x07;
         break;
 
+    case MFF_MPLS_LABEL:
+        value->be32 &= htonl(MPLS_LABEL_MASK >> MPLS_LABEL_SHIFT);
+        break;
+
+    case MFF_MPLS_TC:
+        value->u8 &= MPLS_TC_MASK >> MPLS_TC_SHIFT;
+        break;
+
+    case MFF_MPLS_BOS:
+        value->u8 &= MPLS_BOS_MASK >> MPLS_BOS_SHIFT;
+        break;
+
     case MFF_N_IDS:
     default:
         NOT_REACHED();
@@ -1936,7 +2042,7 @@ mf_from_ethernet_string(const struct mf_field *mf, const char *s,
                         uint8_t mac[ETH_ADDR_LEN],
                         uint8_t mask[ETH_ADDR_LEN])
 {
-    assert(mf->n_bytes == ETH_ADDR_LEN);
+    ovs_assert(mf->n_bytes == ETH_ADDR_LEN);
 
     switch (sscanf(s, ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT,
                    ETH_ADDR_SCAN_ARGS(mac), ETH_ADDR_SCAN_ARGS(mask))){
@@ -1958,7 +2064,7 @@ mf_from_ipv4_string(const struct mf_field *mf, const char *s,
 {
     int prefix;
 
-    assert(mf->n_bytes == sizeof *ip);
+    ovs_assert(mf->n_bytes == sizeof *ip);
 
     if (sscanf(s, IP_SCAN_FMT"/"IP_SCAN_FMT,
                IP_SCAN_ARGS(ip), IP_SCAN_ARGS(mask)) == IP_SCAN_COUNT * 2) {
@@ -1990,7 +2096,7 @@ mf_from_ipv6_string(const struct mf_field *mf, const char *s,
     const char *name, *netmask;
     int retval;
 
-    assert(mf->n_bytes == sizeof *value);
+    ovs_assert(mf->n_bytes == sizeof *value);
 
     name = strtok_r(str, "/", &save_ptr);
     retval = name ? lookup_ipv6(name, value) : EINVAL;
@@ -2028,7 +2134,7 @@ mf_from_ofp_port_string(const struct mf_field *mf, const char *s,
 {
     uint16_t port;
 
-    assert(mf->n_bytes == sizeof(ovs_be16));
+    ovs_assert(mf->n_bytes == sizeof(ovs_be16));
     if (*s == '-') {
         return xasprintf("%s: negative values not supported for %s",
                          s, mf->name);
@@ -2138,9 +2244,10 @@ out:
 }
 
 static char *
-mf_from_tun_flags_string(const char *s, ovs_be16 *valuep)
+mf_from_tun_flags_string(const char *s, ovs_be16 *valuep, ovs_be16 *maskp)
 {
     if (!parse_flow_tun_flags(s, flow_tun_flag_to_string, valuep)) {
+        *maskp = htons(UINT16_MAX);
         return NULL;
     }
 
@@ -2154,7 +2261,7 @@ char *
 mf_parse(const struct mf_field *mf, const char *s,
          union mf_value *value, union mf_value *mask)
 {
-    if (!strcasecmp(s, "any") || !strcmp(s, "*")) {
+    if (!strcmp(s, "*")) {
         memset(value, 0, mf->n_bytes);
         memset(mask, 0, mf->n_bytes);
         return NULL;
@@ -2182,7 +2289,8 @@ mf_parse(const struct mf_field *mf, const char *s,
         return mf_from_frag_string(s, &value->u8, &mask->u8);
 
     case MFS_TNL_FLAGS:
-        return mf_from_tun_flags_string(s, &value->be16);
+        ovs_assert(mf->n_bytes == sizeof(ovs_be16));
+        return mf_from_tun_flags_string(s, &value->be16, &mask->be16);
     }
     NOT_REACHED();
 }
@@ -2213,7 +2321,7 @@ mf_format_integer_string(const struct mf_field *mf, const uint8_t *valuep,
     unsigned long long int integer;
     int i;
 
-    assert(mf->n_bytes <= 8);
+    ovs_assert(mf->n_bytes <= 8);
 
     integer = 0;
     for (i = 0; i < mf->n_bytes; i++) {
@@ -2241,15 +2349,12 @@ mf_format_integer_string(const struct mf_field *mf, const uint8_t *valuep,
 }
 
 static void
-mf_format_frag_string(const uint8_t *valuep, const uint8_t *maskp,
-                      struct ds *s)
+mf_format_frag_string(uint8_t value, uint8_t mask, struct ds *s)
 {
     const struct frag_handling *h;
-    uint8_t value = *valuep;
-    uint8_t mask = *maskp;
 
-    value &= mask;
     mask &= FLOW_NW_FRAG_MASK;
+    value &= mask;
 
     for (h = all_frags; h < &all_frags[ARRAY_SIZE(all_frags)]; h++) {
         if (value == h->value && mask == h->mask) {
@@ -2308,7 +2413,7 @@ mf_format(const struct mf_field *mf,
         break;
 
     case MFS_FRAG:
-        mf_format_frag_string(&value->u8, &mask->u8, s);
+        mf_format_frag_string(value->u8, mask ? mask->u8 : UINT8_MAX, s);
         break;
 
     case MFS_TNL_FLAGS: