X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fclassifier.c;h=b05b491e89adb043b9876ff3b35df2f3b348b6b9;hb=75fca0a445ccecbf0b53a44024800860475acf2e;hp=ec94385596e22f77769b1b3e32454320d12a0c4a;hpb=87542e21fa88f0e566fdff023410a33f11d164ba;p=openvswitch

diff --git a/lib/classifier.c b/lib/classifier.c
index ec943855..b05b491e 100644
--- a/lib/classifier.c
+++ b/lib/classifier.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2010 Nicira Networks.
+ * Copyright (c) 2009, 2010, 2011 Nicira Networks.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@
 #include "dynamic-string.h"
 #include "flow.h"
 #include "hash.h"
+#include "odp-util.h"
 #include "ofp-util.h"
 #include "packets.h"
 
@@ -127,10 +128,17 @@ cls_rule_set_reg_masked(struct cls_rule *rule, unsigned int reg_idx,
 }
 
 void
-cls_rule_set_tun_id(struct cls_rule *rule, ovs_be32 tun_id)
+cls_rule_set_tun_id(struct cls_rule *rule, ovs_be64 tun_id)
 {
-    rule->wc.wildcards &= ~FWW_TUN_ID;
-    rule->flow.tun_id = tun_id;
+    cls_rule_set_tun_id_masked(rule, tun_id, htonll(UINT64_MAX));
+}
+
+void
+cls_rule_set_tun_id_masked(struct cls_rule *rule,
+                           ovs_be64 tun_id, ovs_be64 mask)
+{
+    rule->wc.tun_id_mask = mask;
+    rule->flow.tun_id = tun_id & mask;
 }
 
 void
@@ -321,28 +329,184 @@ cls_rule_equal(const struct cls_rule *a, const struct cls_rule *b)
             && flow_equal(&a->flow, &b->flow));
 }
 
+static void
+format_ip_netmask(struct ds *s, const char *name, ovs_be32 ip,
+                  ovs_be32 netmask)
+{
+    if (netmask) {
+        ds_put_format(s, "%s="IP_FMT, name, IP_ARGS(&ip));
+        if (netmask != htonl(UINT32_MAX)) {
+            if (ip_is_cidr(netmask)) {
+                int wcbits = ofputil_netmask_to_wcbits(netmask);
+                ds_put_format(s, "/%d", 32 - wcbits);
+            } else {
+                ds_put_format(s, "/"IP_FMT, IP_ARGS(&netmask));
+            }
+        }
+        ds_put_char(s, ',');
+    }
+}
+
+void
+cls_rule_format(const struct cls_rule *rule, struct ds *s)
+{
+    const struct flow_wildcards *wc = &rule->wc;
+    size_t start_len = s->length;
+    flow_wildcards_t w = wc->wildcards;
+    const struct flow *f = &rule->flow;
+    bool skip_type = false;
+    bool skip_proto = false;
+
+    int i;
+
+    if (rule->priority != OFP_DEFAULT_PRIORITY) {
+        ds_put_format(s, "priority=%d,", rule->priority);
+    }
+
+    if (!(w & FWW_DL_TYPE)) {
+        skip_type = true;
+        if (f->dl_type == htons(ETH_TYPE_IP)) {
+            if (!(w & FWW_NW_PROTO)) {
+                skip_proto = true;
+                if (f->nw_proto == IP_TYPE_ICMP) {
+                    ds_put_cstr(s, "icmp,");
+                } else if (f->nw_proto == IP_TYPE_TCP) {
+                    ds_put_cstr(s, "tcp,");
+                } else if (f->nw_proto == IP_TYPE_UDP) {
+                    ds_put_cstr(s, "udp,");
+                } else {
+                    ds_put_cstr(s, "ip,");
+                    skip_proto = false;
+                }
+            } else {
+                ds_put_cstr(s, "ip,");
+            }
+        } else if (f->dl_type == htons(ETH_TYPE_ARP)) {
+            ds_put_cstr(s, "arp,");
+        } else {
+            skip_type = false;
+        }
+    }
+    for (i = 0; i < FLOW_N_REGS; i++) {
+        switch (wc->reg_masks[i]) {
+        case 0:
+            break;
+        case UINT32_MAX:
+            ds_put_format(s, "reg%d=0x%"PRIx32",", i, f->regs[i]);
+            break;
+        default:
+            ds_put_format(s, "reg%d=0x%"PRIx32"/0x%"PRIx32",",
+                          i, f->regs[i], wc->reg_masks[i]);
+            break;
+        }
+    }
+    switch (wc->tun_id_mask) {
+    case 0:
+        break;
+    case CONSTANT_HTONLL(UINT64_MAX):
+        ds_put_format(s, "tun_id=%#"PRIx64",", ntohll(f->tun_id));
+        break;
+    default:
+        ds_put_format(s, "tun_id=%#"PRIx64"/%#"PRIx64",",
+                      ntohll(f->tun_id), ntohll(wc->tun_id_mask));
+        break;
+    }
+    if (!(w & FWW_IN_PORT)) {
+        ds_put_format(s, "in_port=%"PRIu16",",
+                      odp_port_to_ofp_port(f->in_port));
+    }
+    if (wc->vlan_tci_mask) {
+        ovs_be16 vid_mask = wc->vlan_tci_mask & htons(VLAN_VID_MASK);
+        ovs_be16 pcp_mask = wc->vlan_tci_mask & htons(VLAN_PCP_MASK);
+        ovs_be16 cfi = wc->vlan_tci_mask & htons(VLAN_CFI);
+
+        if (cfi && f->vlan_tci & htons(VLAN_CFI)
+            && (!vid_mask || vid_mask == htons(VLAN_VID_MASK))
+            && (!pcp_mask || pcp_mask == htons(VLAN_PCP_MASK))
+            && (vid_mask || pcp_mask)) {
+            if (vid_mask) {
+                ds_put_format(s, "dl_vlan=%"PRIu16",",
+                              vlan_tci_to_vid(f->vlan_tci));
+            }
+            if (pcp_mask) {
+                ds_put_format(s, "dl_vlan_pcp=%d,",
+                              vlan_tci_to_pcp(f->vlan_tci));
+            }
+        } else {
+            ds_put_format(s, "vlan_tci=0x%04"PRIx16"/0x%04"PRIx16",",
+                          ntohs(f->vlan_tci), ntohs(wc->vlan_tci_mask));
+        }
+    }
+    if (!(w & FWW_DL_SRC)) {
+        ds_put_format(s, "dl_src="ETH_ADDR_FMT",", ETH_ADDR_ARGS(f->dl_src));
+    }
+    switch (w & (FWW_DL_DST | FWW_ETH_MCAST)) {
+    case 0:
+        ds_put_format(s, "dl_dst="ETH_ADDR_FMT",", ETH_ADDR_ARGS(f->dl_dst));
+        break;
+    case FWW_DL_DST:
+        ds_put_format(s, "dl_dst="ETH_ADDR_FMT"/01:00:00:00:00:00,",
+                      ETH_ADDR_ARGS(f->dl_dst));
+        break;
+    case FWW_ETH_MCAST:
+        ds_put_format(s, "dl_dst="ETH_ADDR_FMT"/fe:ff:ff:ff:ff:ff,",
+                      ETH_ADDR_ARGS(f->dl_dst));
+        break;
+    case FWW_DL_DST | FWW_ETH_MCAST:
+        break;
+    }
+    if (!skip_type && !(w & FWW_DL_TYPE)) {
+        ds_put_format(s, "dl_type=0x%04"PRIx16",", ntohs(f->dl_type));
+    }
+    format_ip_netmask(s, "nw_src", f->nw_src, wc->nw_src_mask);
+    format_ip_netmask(s, "nw_dst", f->nw_dst, wc->nw_dst_mask);
+    if (!skip_proto && !(w & FWW_NW_PROTO)) {
+        if (f->dl_type == htons(ETH_TYPE_ARP)) {
+            ds_put_format(s, "opcode=%"PRIu8",", f->nw_proto);
+        } else {
+            ds_put_format(s, "nw_proto=%"PRIu8",", f->nw_proto);
+        }
+    }
+    if (!(w & FWW_NW_TOS)) {
+        ds_put_format(s, "nw_tos=%"PRIu8",", f->nw_tos);
+    }
+    if (f->nw_proto == IP_TYPE_ICMP) {
+        if (!(w & FWW_TP_SRC)) {
+            ds_put_format(s, "icmp_type=%"PRIu16",", ntohs(f->tp_src));
+        }
+        if (!(w & FWW_TP_DST)) {
+            ds_put_format(s, "icmp_code=%"PRIu16",", ntohs(f->tp_dst));
+        }
+    } else {
+        if (!(w & FWW_TP_SRC)) {
+            ds_put_format(s, "tp_src=%"PRIu16",", ntohs(f->tp_src));
+        }
+        if (!(w & FWW_TP_DST)) {
+            ds_put_format(s, "tp_dst=%"PRIu16",", ntohs(f->tp_dst));
+        }
+    }
+
+    if (s->length > start_len && ds_last(s) == ',') {
+        s->length--;
+    }
+}
+
 /* Converts 'rule' to a string and returns the string.  The caller must free
  * the string (with free()). */
 char *
 cls_rule_to_string(const struct cls_rule *rule)
 {
     struct ds s = DS_EMPTY_INITIALIZER;
-    ds_put_format(&s, "wildcards=%x priority=%u ",
-                  rule->wc.wildcards, rule->priority);
-    flow_format(&s, &rule->flow);
-    return ds_cstr(&s);
+    cls_rule_format(rule, &s);
+    return ds_steal_cstr(&s);
 }
 
-/* Prints cls_rule 'rule', for debugging.
- *
- * (The output could be improved and expanded, but this was good enough to
- * debug the classifier.) */
 void
 cls_rule_print(const struct cls_rule *rule)
 {
-    printf("wildcards=%x priority=%u ", rule->wc.wildcards, rule->priority);
-    flow_print(stdout, &rule->flow);
-    putc('\n', stdout);
+    char *s = cls_rule_to_string(rule);
+    puts(s);
+    free(s);
 }
 
 /* Initializes 'cls' as a classifier that initially contains no classification
@@ -783,7 +947,7 @@ flow_equal_except(const struct flow *a, const struct flow *b,
     const flow_wildcards_t wc = wildcards->wildcards;
     int i;
 
-    BUILD_ASSERT_DECL(FLOW_SIG_SIZE == 36 + FLOW_N_REGS * 4);
+    BUILD_ASSERT_DECL(FLOW_SIG_SIZE == 40 + FLOW_N_REGS * 4);
 
     for (i = 0; i < FLOW_N_REGS; i++) {
         if ((a->regs[i] ^ b->regs[i]) & wildcards->reg_masks[i]) {
@@ -791,7 +955,7 @@ flow_equal_except(const struct flow *a, const struct flow *b,
         }
     }
 
-    return ((wc & FWW_TUN_ID || a->tun_id == b->tun_id)
+    return (!((a->tun_id ^ b->tun_id) & wildcards->tun_id_mask)
             && !((a->nw_src ^ b->nw_src) & wildcards->nw_src_mask)
             && !((a->nw_dst ^ b->nw_dst) & wildcards->nw_dst_mask)
             && (wc & FWW_IN_PORT || a->in_port == b->in_port)
@@ -819,14 +983,12 @@ zero_wildcards(struct flow *flow, const struct flow_wildcards *wildcards)
     const flow_wildcards_t wc = wildcards->wildcards;
     int i;
 
-    BUILD_ASSERT_DECL(FLOW_SIG_SIZE == 36 + 4 * FLOW_N_REGS);
+    BUILD_ASSERT_DECL(FLOW_SIG_SIZE == 40 + 4 * FLOW_N_REGS);
 
     for (i = 0; i < FLOW_N_REGS; i++) {
         flow->regs[i] &= wildcards->reg_masks[i];
     }
-    if (wc & FWW_TUN_ID) {
-        flow->tun_id = 0;
-    }
+    flow->tun_id &= wildcards->tun_id_mask;
     flow->nw_src &= wildcards->nw_src_mask;
     flow->nw_dst &= wildcards->nw_dst_mask;
     if (wc & FWW_IN_PORT) {