X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tests%2Ftest-classifier.c;h=6c81cd60f090b0c23b411c942c0af51d2901e1db;hb=54294187a62dd13ff1531a1a5abcd5761203cd56;hp=309c4dd601695d5615a683a496cf96da826e5869;hpb=064af42167bf4fc9aaea2702d80ce08074b889c0;p=openvswitch diff --git a/tests/test-classifier.c b/tests/test-classifier.c index 309c4dd6..6c81cd60 100644 --- a/tests/test-classifier.c +++ b/tests/test-classifier.c @@ -1,17 +1,17 @@ /* - * Copyright (c) 2009 Nicira Networks. + * Copyright (c) 2009, 2010 Nicira Networks. * - * Permission to use, copy, modify, and/or distribute this software for any - * purpose with or without fee is hereby granted, provided that the above - * copyright notice and this permission notice appear in all copies. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. */ /* "White box" tests for classifier. @@ -223,31 +223,34 @@ tcls_delete_matches(struct tcls *cls, } #ifdef WORDS_BIGENDIAN -#define HTONL(VALUE) ((uint32_t) (VALUE)) -#define HTONS(VALUE) ((uint32_t) (VALUE)) +#define T_HTONL(VALUE) ((uint32_t) (VALUE)) +#define T_HTONS(VALUE) ((uint32_t) (VALUE)) #else -#define HTONL(VALUE) (((((uint32_t) (VALUE)) & 0x000000ff) << 24) | \ +#define T_HTONL(VALUE) (((((uint32_t) (VALUE)) & 0x000000ff) << 24) | \ ((((uint32_t) (VALUE)) & 0x0000ff00) << 8) | \ ((((uint32_t) (VALUE)) & 0x00ff0000) >> 8) | \ ((((uint32_t) (VALUE)) & 0xff000000) >> 24)) -#define HTONS(VALUE) (((((uint16_t) (VALUE)) & 0xff00) >> 8) | \ +#define T_HTONS(VALUE) (((((uint16_t) (VALUE)) & 0xff00) >> 8) | \ ((((uint16_t) (VALUE)) & 0x00ff) << 8)) #endif -static uint32_t nw_src_values[] = { HTONL(0xc0a80001), - HTONL(0xc0a04455) }; -static uint32_t nw_dst_values[] = { HTONL(0xc0a80002), - HTONL(0xc0a04455) }; -static uint16_t in_port_values[] = { HTONS(1), HTONS(OFPP_LOCAL) }; -static uint16_t dl_vlan_values[] = { HTONS(101), HTONS(0) }; -static uint16_t dl_type_values[] = { HTONS(ETH_TYPE_IP), HTONS(ETH_TYPE_ARP) }; -static uint16_t tp_src_values[] = { HTONS(49362), HTONS(80) }; -static uint16_t tp_dst_values[] = { HTONS(6667), HTONS(22) }; +static uint32_t nw_src_values[] = { T_HTONL(0xc0a80001), + T_HTONL(0xc0a04455) }; +static uint32_t nw_dst_values[] = { T_HTONL(0xc0a80002), + T_HTONL(0xc0a04455) }; +static uint16_t in_port_values[] = { T_HTONS(1), T_HTONS(OFPP_LOCAL) }; +static uint16_t dl_vlan_values[] = { T_HTONS(101), T_HTONS(0) }; +static uint8_t dl_vlan_pcp_values[] = { 7, 0 }; +static uint16_t dl_type_values[] + = { T_HTONS(ETH_TYPE_IP), T_HTONS(ETH_TYPE_ARP) }; +static uint16_t tp_src_values[] = { T_HTONS(49362), T_HTONS(80) }; +static uint16_t tp_dst_values[] = { T_HTONS(6667), T_HTONS(22) }; static uint8_t dl_src_values[][6] = { { 0x00, 0x02, 0xe3, 0x0f, 0x80, 0xa4 }, { 0x5e, 0x33, 0x7f, 0x5f, 0x1e, 0x99 } }; static uint8_t dl_dst_values[][6] = { { 0x4a, 0x27, 0x71, 0xae, 0x64, 0xc1 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } }; static uint8_t nw_proto_values[] = { IP_TYPE_TCP, IP_TYPE_ICMP }; +static uint8_t nw_tos_values[] = { 49, 0 }; static void *values[CLS_N_FIELDS][2]; @@ -260,6 +263,9 @@ init_values(void) values[CLS_F_IDX_DL_VLAN][0] = &dl_vlan_values[0]; values[CLS_F_IDX_DL_VLAN][1] = &dl_vlan_values[1]; + values[CLS_F_IDX_DL_VLAN_PCP][0] = &dl_vlan_pcp_values[0]; + values[CLS_F_IDX_DL_VLAN_PCP][1] = &dl_vlan_pcp_values[1]; + values[CLS_F_IDX_DL_SRC][0] = dl_src_values[0]; values[CLS_F_IDX_DL_SRC][1] = dl_src_values[1]; @@ -278,6 +284,9 @@ init_values(void) values[CLS_F_IDX_NW_PROTO][0] = &nw_proto_values[0]; values[CLS_F_IDX_NW_PROTO][1] = &nw_proto_values[1]; + values[CLS_F_IDX_NW_TOS][0] = &nw_tos_values[0]; + values[CLS_F_IDX_NW_TOS][1] = &nw_tos_values[1]; + values[CLS_F_IDX_TP_SRC][0] = &tp_src_values[0]; values[CLS_F_IDX_TP_SRC][1] = &tp_src_values[1]; @@ -289,23 +298,27 @@ init_values(void) #define N_NW_DST_VALUES ARRAY_SIZE(nw_dst_values) #define N_IN_PORT_VALUES ARRAY_SIZE(in_port_values) #define N_DL_VLAN_VALUES ARRAY_SIZE(dl_vlan_values) +#define N_DL_VLAN_PCP_VALUES ARRAY_SIZE(dl_vlan_pcp_values) #define N_DL_TYPE_VALUES ARRAY_SIZE(dl_type_values) #define N_TP_SRC_VALUES ARRAY_SIZE(tp_src_values) #define N_TP_DST_VALUES ARRAY_SIZE(tp_dst_values) #define N_DL_SRC_VALUES ARRAY_SIZE(dl_src_values) #define N_DL_DST_VALUES ARRAY_SIZE(dl_dst_values) #define N_NW_PROTO_VALUES ARRAY_SIZE(nw_proto_values) +#define N_NW_TOS_VALUES ARRAY_SIZE(nw_tos_values) #define N_FLOW_VALUES (N_NW_SRC_VALUES * \ N_NW_DST_VALUES * \ N_IN_PORT_VALUES * \ N_DL_VLAN_VALUES * \ + N_DL_VLAN_PCP_VALUES * \ N_DL_TYPE_VALUES * \ N_TP_SRC_VALUES * \ N_TP_DST_VALUES * \ N_DL_SRC_VALUES * \ N_DL_DST_VALUES * \ - N_NW_PROTO_VALUES) + N_NW_PROTO_VALUES * \ + N_NW_TOS_VALUES) static unsigned int get_value(unsigned int *x, unsigned n_values) @@ -349,6 +362,8 @@ compare_classifiers(struct classifier *cls, struct tcls *tcls) flow.nw_dst = nw_dst_values[get_value(&x, N_NW_DST_VALUES)]; flow.in_port = in_port_values[get_value(&x, N_IN_PORT_VALUES)]; flow.dl_vlan = dl_vlan_values[get_value(&x, N_DL_VLAN_VALUES)]; + flow.dl_vlan_pcp = dl_vlan_pcp_values[get_value(&x, + N_DL_VLAN_PCP_VALUES)]; flow.dl_type = dl_type_values[get_value(&x, N_DL_TYPE_VALUES)]; flow.tp_src = tp_src_values[get_value(&x, N_TP_SRC_VALUES)]; flow.tp_dst = tp_dst_values[get_value(&x, N_TP_DST_VALUES)]; @@ -357,7 +372,8 @@ compare_classifiers(struct classifier *cls, struct tcls *tcls) memcpy(flow.dl_dst, dl_dst_values[get_value(&x, N_DL_DST_VALUES)], ETH_ADDR_LEN); flow.nw_proto = nw_proto_values[get_value(&x, N_NW_PROTO_VALUES)]; - flow.reserved = 0; + flow.nw_tos = nw_tos_values[get_value(&x, N_NW_TOS_VALUES)]; + memset(flow.reserved, 0, sizeof flow.reserved); for (include = 1; include <= 3; include++) { cr0 = lookup_with_include_bits(cls, &flow, include); @@ -445,7 +461,7 @@ make_rule(int wc_fields, unsigned int priority, int value_pat) } } - rule = xcalloc(1, sizeof *rule); + rule = xzalloc(sizeof *rule); cls_rule_from_flow(&rule->cls_rule, &flow, wildcards, !wildcards ? UINT_MAX : priority); return rule; @@ -531,8 +547,8 @@ test_rule_replacement(void) for (wc_fields = 0; wc_fields < (1u << CLS_N_FIELDS); wc_fields++) { struct classifier cls; - struct test_rule *rule1, *tcls_rule1; - struct test_rule *rule2, *tcls_rule2; + struct test_rule *rule1; + struct test_rule *rule2; struct tcls tcls; rule1 = make_rule(wc_fields, OFP_DEFAULT_PRIORITY, UINT_MAX); @@ -542,14 +558,14 @@ test_rule_replacement(void) classifier_init(&cls); tcls_init(&tcls); - tcls_rule1 = tcls_insert(&tcls, rule1); + tcls_insert(&tcls, rule1); assert(!classifier_insert(&cls, &rule1->cls_rule)); check_tables(&cls, 1, 1, 1); compare_classifiers(&cls, &tcls); tcls_destroy(&tcls); tcls_init(&tcls); - tcls_rule2 = tcls_insert(&tcls, rule2); + tcls_insert(&tcls, rule2); assert(test_rule_from_cls_rule( classifier_insert(&cls, &rule2->cls_rule)) == rule1); free(rule1);