From patchwork Thu Jul 30 15:20:34 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Balasubramanian Manoharan X-Patchwork-Id: 51699 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-wi0-f197.google.com (mail-wi0-f197.google.com [209.85.212.197]) by patches.linaro.org (Postfix) with ESMTPS id 1D9FF22DB5 for ; Thu, 30 Jul 2015 15:21:17 +0000 (UTC) Received: by wixh2 with SMTP id h2sf19299067wix.0 for ; Thu, 30 Jul 2015 08:21:16 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:delivered-to:delivered-to:from:to:date :message-id:subject:precedence:list-id:list-unsubscribe:list-archive :list-post:list-help:list-subscribe:mime-version:content-type :content-transfer-encoding:errors-to:sender:x-original-sender :x-original-authentication-results:mailing-list; bh=B5OLYF+jKJpi83p+oT5K3fBPAlUsAgKmZm07COHiTbo=; b=bvyIDE1ItpWJKhYeGJUmD+3c5dvyqdd1YYEwSIJDSTVEBHDnfocEdnXXVOXkMXZHMl f/boWnxe6RdD7+msf86v3ZoG8yEqJ75FsJWYMoYE+oyCoAE+5v/kNzv091WT4ivb8dbW RlaykDRxGD7xPQrlc5Em2EL+8VGN8g5RHulWHHEzaRPbuvEWEPi5ohBMBvDA4trze5fK isftsMizLd7u3bhp0WxlYvlNHXJxHzwNyJeMFQ2xZxOFEBf/wobg3Iat5bWez6dMEANc yi3gn633FDW3d8eAMALNGUL02an6JTZfmzcwhNSA0GmQF0J8VSNIjvCODQwG71f7Ctrz 9SKA== X-Gm-Message-State: ALoCoQn1LmbhqF8kdgSlt/LozhSV5C8LnPbqBF+JPG/0UiKhGFZGS1mAiKRegIsf1WvVFPSuOzH9 X-Received: by 10.152.88.111 with SMTP id bf15mr17872818lab.9.1438269676310; Thu, 30 Jul 2015 08:21:16 -0700 (PDT) X-BeenThere: patchwork-forward@linaro.org Received: by 10.152.28.5 with SMTP id x5ls22082lag.58.gmail; Thu, 30 Jul 2015 08:21:15 -0700 (PDT) X-Received: by 10.152.4.163 with SMTP id l3mr45746692lal.35.1438269675893; Thu, 30 Jul 2015 08:21:15 -0700 (PDT) Received: from mail-la0-f43.google.com (mail-la0-f43.google.com. [209.85.215.43]) by mx.google.com with ESMTPS id lc7si1066705lac.95.2015.07.30.08.21.15 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 30 Jul 2015 08:21:15 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.215.43 as permitted sender) client-ip=209.85.215.43; Received: by lafd3 with SMTP id d3so27259825laf.1 for ; Thu, 30 Jul 2015 08:21:15 -0700 (PDT) X-Received: by 10.112.158.4 with SMTP id wq4mr5966286lbb.106.1438269675748; Thu, 30 Jul 2015 08:21:15 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.112.7.198 with SMTP id l6csp683845lba; Thu, 30 Jul 2015 08:21:14 -0700 (PDT) X-Received: by 10.55.15.198 with SMTP id 67mr72404455qkp.7.1438269674034; Thu, 30 Jul 2015 08:21:14 -0700 (PDT) Received: from lists.linaro.org (lists.linaro.org. [54.225.227.206]) by mx.google.com with ESMTP id d4si1603059qka.106.2015.07.30.08.21.13; Thu, 30 Jul 2015 08:21:14 -0700 (PDT) Received-SPF: pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) client-ip=54.225.227.206; Received: by lists.linaro.org (Postfix, from userid 109) id 3D8C661F6B; Thu, 30 Jul 2015 15:21:13 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on ip-10-142-244-252.ec2.internal X-Spam-Level: X-Spam-Status: No, score=-2.6 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, URIBL_BLOCKED autolearn=disabled version=3.4.0 Received: from ip-10-142-244-252.ec2.internal (localhost [127.0.0.1]) by lists.linaro.org (Postfix) with ESMTP id E954F61F1F; Thu, 30 Jul 2015 15:20:57 +0000 (UTC) X-Original-To: lng-odp@lists.linaro.org Delivered-To: lng-odp@lists.linaro.org Received: by lists.linaro.org (Postfix, from userid 109) id 5F3C961F19; Thu, 30 Jul 2015 15:20:54 +0000 (UTC) Received: from mail-pd0-f178.google.com (mail-pd0-f178.google.com [209.85.192.178]) by lists.linaro.org (Postfix) with ESMTPS id CF85E61F19 for ; Thu, 30 Jul 2015 15:20:51 +0000 (UTC) Received: by pdbnt7 with SMTP id nt7so26200260pdb.0 for ; Thu, 30 Jul 2015 08:20:51 -0700 (PDT) X-Received: by 10.70.126.133 with SMTP id my5mr107960410pdb.14.1438269650945; Thu, 30 Jul 2015 08:20:50 -0700 (PDT) Received: from localhost.localdomain ([122.166.219.57]) by smtp.gmail.com with ESMTPSA id s7sm2719260pdn.85.2015.07.30.08.20.47 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 30 Jul 2015 08:20:50 -0700 (PDT) From: Balasubramanian Manoharan To: lng-odp@lists.linaro.org Date: Thu, 30 Jul 2015 20:50:34 +0530 Message-Id: <1438269634-5735-1-git-send-email-bala.manoharan@linaro.org> X-Mailer: git-send-email 1.9.1 X-Topics: Classification Subject: [lng-odp] [API-NEXT] validation: classification: added additional suite to test individual PMRs X-BeenThere: lng-odp@lists.linaro.org X-Mailman-Version: 2.1.16 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: , List-Help: , List-Subscribe: , MIME-Version: 1.0 Errors-To: lng-odp-bounces@lists.linaro.org Sender: "lng-odp" X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: bala.manoharan@linaro.org X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.215.43 as permitted sender) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org Mailing-list: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org X-Google-Group-Id: 836684582541 Additional test suite is added to classification validation suite to test individual PMRs. This suite will test the defined PMRs by configuring pktio separately for every test case. Signed-off-by: Balasubramanian Manoharan --- helper/include/odp/helper/tcp.h | 4 + test/validation/classification/Makefile.am | 2 + test/validation/classification/classification.c | 5 + .../classification/odp_classification_common.c | 200 +++++++ .../classification/odp_classification_test_pmr.c | 629 +++++++++++++++++++++ .../classification/odp_classification_tests.c | 116 +--- .../classification/odp_classification_testsuites.h | 7 + 7 files changed, 854 insertions(+), 109 deletions(-) create mode 100644 test/validation/classification/odp_classification_common.c create mode 100644 test/validation/classification/odp_classification_test_pmr.c diff --git a/helper/include/odp/helper/tcp.h b/helper/include/odp/helper/tcp.h index defe422..b52784d 100644 --- a/helper/include/odp/helper/tcp.h +++ b/helper/include/odp/helper/tcp.h @@ -26,6 +26,10 @@ extern "C" { * @{ */ +/** TCP header length (Minimum Header length without options)*/ +/** If options field is added to TCP header then the correct header value +should be updated by the application */ +#define ODPH_TCPHDR_LEN 20 /** TCP header */ typedef struct ODP_PACKED { diff --git a/test/validation/classification/Makefile.am b/test/validation/classification/Makefile.am index ba468fa..050d5e6 100644 --- a/test/validation/classification/Makefile.am +++ b/test/validation/classification/Makefile.am @@ -3,6 +3,8 @@ include ../Makefile.inc noinst_LTLIBRARIES = libclassification.la libclassification_la_SOURCES = odp_classification_basic.c \ odp_classification_tests.c \ + odp_classification_test_pmr.c \ + odp_classification_common.c \ classification.c bin_PROGRAMS = classification_main$(EXEEXT) diff --git a/test/validation/classification/classification.c b/test/validation/classification/classification.c index 2582aaa..aec0655 100644 --- a/test/validation/classification/classification.c +++ b/test/validation/classification/classification.c @@ -18,6 +18,11 @@ static CU_SuiteInfo classification_suites[] = { .pInitFunc = classification_suite_init, .pCleanupFunc = classification_suite_term, }, + { .pName = "classification pmr tests", + .pTests = classification_test_pmr, + .pInitFunc = classification_test_pmr_init, + .pCleanupFunc = classification_test_pmr_term, + }, CU_SUITE_INFO_NULL, }; diff --git a/test/validation/classification/odp_classification_common.c b/test/validation/classification/odp_classification_common.c new file mode 100644 index 0000000..db994c6 --- /dev/null +++ b/test/validation/classification/odp_classification_common.c @@ -0,0 +1,200 @@ +/* Copyright (c) 2015, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "odp_classification_testsuites.h" +#include +#include +#include +#include +#include + +#define SHM_PKT_NUM_BUFS 32 +#define SHM_PKT_BUF_SIZE 1024 + +#define CLS_DEFAULT_SADDR "10.0.0.1/32" +#define CLS_DEFAULT_DADDR "10.0.0.100/32" +#define CLS_DEFAULT_SPORT 1024 +#define CLS_DEFAULT_DPORT 2048 + +#define CLS_TEST_SPORT 4096 +#define CLS_TEST_DPORT 8192 +#define CLS_TEST_DADDR "10.0.0.5/32" + +/* Test Packet values */ +#define DATA_MAGIC 0x01020304 +#define TEST_SEQ_INVALID ((uint32_t)~0) + +/** sequence number of IP packets */ +odp_atomic_u32_t seq; + +typedef struct cls_test_packet { + uint32be_t magic; + uint32be_t seq; +} cls_test_packet_t; + +static int cls_pkt_set_seq(odp_packet_t pkt, bool flag_udp) +{ + static uint32_t seq; + cls_test_packet_t data; + uint32_t offset; + int status; + + data.magic = DATA_MAGIC; + data.seq = ++seq; + + offset = odp_packet_l4_offset(pkt); + CU_ASSERT_FATAL(offset != 0); + + if (flag_udp) + status = odp_packet_copydata_in(pkt, offset + ODPH_UDPHDR_LEN, + sizeof(data), &data); + else + status = odp_packet_copydata_in(pkt, offset + ODPH_TCPHDR_LEN, + sizeof(data), &data); + + return status; +} + +static inline +int parse_ipv4_string(const char *ipaddress, uint32_t *addr, uint32_t *mask) +{ + int b[4]; + int qualifier = 32; + int converted; + + if (strchr(ipaddress, '/')) { + converted = sscanf(ipaddress, "%d.%d.%d.%d/%d", + &b[3], &b[2], &b[1], &b[0], + &qualifier); + if (5 != converted) + return -1; + } else { + converted = sscanf(ipaddress, "%d.%d.%d.%d", + &b[3], &b[2], &b[1], &b[0]); + if (4 != converted) + return -1; + } + + if ((b[0] > 255) || (b[1] > 255) || (b[2] > 255) || (b[3] > 255)) + return -1; + if (!qualifier || (qualifier > 32)) + return -1; + + *addr = b[0] | b[1] << 8 | b[2] << 16 | b[3] << 24; + if (mask) + *mask = ~(0xFFFFFFFF & ((1ULL << (32 - qualifier)) - 1)); + + return 0; +} + +odp_packet_t create_packet_tcp(odp_pool_t pool, bool vlan, bool flag_udp) +{ + uint32_t seqno; + odph_ethhdr_t *ethhdr; + odph_udphdr_t *udp; + odph_tcphdr_t *tcp; + odph_ipv4hdr_t *ip; + uint8_t payload_len; + char src_mac[ODPH_ETHADDR_LEN] = {0}; + char dst_mac[ODPH_ETHADDR_LEN] = {0}; + uint32_t addr = 0; + uint32_t mask; + int offset; + odp_packet_t pkt; + int packet_len = 0; + + payload_len = sizeof(cls_test_packet_t); + packet_len += ODPH_ETHHDR_LEN; + packet_len += ODPH_IPV4HDR_LEN; + if (flag_udp) + packet_len += ODPH_UDPHDR_LEN; + else + packet_len += ODPH_TCPHDR_LEN; + packet_len += payload_len; + + if (vlan) + packet_len += ODPH_VLANHDR_LEN; + + pkt = odp_packet_alloc(pool, packet_len); + CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); + + /* Ethernet Header */ + offset = 0; + odp_packet_l2_offset_set(pkt, offset); + ethhdr = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL); + memcpy(ethhdr->src.addr, src_mac, ODPH_ETHADDR_LEN); + memcpy(ethhdr->dst.addr, dst_mac, ODPH_ETHADDR_LEN); + offset += sizeof(odph_ethhdr_t); + if (vlan) { + /* Default vlan header */ + uint8_t *parseptr; + odph_vlanhdr_t *vlan; + + vlan = (odph_vlanhdr_t *)(ðhdr->type); + parseptr = (uint8_t *)vlan; + vlan->tci = odp_cpu_to_be_16(0); + vlan->tpid = odp_cpu_to_be_16(ODPH_ETHTYPE_VLAN); + offset += sizeof(odph_vlanhdr_t); + parseptr += sizeof(odph_vlanhdr_t); + uint16be_t *type = (uint16be_t *)(void *)parseptr; + *type = odp_cpu_to_be_16(ODPH_ETHTYPE_IPV4); + } else { + ethhdr->type = odp_cpu_to_be_16(ODPH_ETHTYPE_IPV4); + } + + odp_packet_l3_offset_set(pkt, offset); + + /* ipv4 */ + ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt, NULL); + + parse_ipv4_string(CLS_DEFAULT_SADDR, &addr, &mask); + ip->dst_addr = odp_cpu_to_be_32(addr); + + parse_ipv4_string(CLS_DEFAULT_DADDR, &addr, &mask); + ip->src_addr = odp_cpu_to_be_32(addr); + ip->ver_ihl = ODPH_IPV4 << 4 | ODPH_IPV4HDR_IHL_MIN; + if (flag_udp) + ip->tot_len = odp_cpu_to_be_16(ODPH_UDPHDR_LEN + payload_len + + ODPH_IPV4HDR_LEN); + else + ip->tot_len = odp_cpu_to_be_16(ODPH_TCPHDR_LEN + payload_len + + ODPH_IPV4HDR_LEN); + + ip->ttl = 128; + if (flag_udp) + ip->proto = ODPH_IPPROTO_UDP; + else + ip->proto = ODPH_IPPROTO_TCP; + + seqno = odp_atomic_fetch_inc_u32(&seq); + ip->id = odp_cpu_to_be_16(seqno); + ip->chksum = 0; + ip->chksum = odp_cpu_to_be_16(odph_ipv4_csum_update(pkt)); + offset += ODPH_IPV4HDR_LEN; + + /* udp */ + if (flag_udp) { + odp_packet_l4_offset_set(pkt, offset); + udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL); + udp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT); + udp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT); + udp->length = odp_cpu_to_be_16(payload_len + ODPH_UDPHDR_LEN); + udp->chksum = 0; + } else { + odp_packet_l4_offset_set(pkt, offset); + tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL); + tcp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT); + tcp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT); + tcp->hl = ODPH_TCPHDR_LEN / 4; + /* TODO: checksum field has to be updated */ + tcp->cksm = 0; + } + + /* set pkt sequence number */ + cls_pkt_set_seq(pkt, flag_udp); + + return pkt; +} diff --git a/test/validation/classification/odp_classification_test_pmr.c b/test/validation/classification/odp_classification_test_pmr.c new file mode 100644 index 0000000..c18beaf --- /dev/null +++ b/test/validation/classification/odp_classification_test_pmr.c @@ -0,0 +1,629 @@ +/* Copyright (c) 2015, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "odp_classification_testsuites.h" +#include +#include +#include +#include +#include + +#define SHM_PKT_NUM_BUFS 32 +#define SHM_PKT_BUF_SIZE 1024 + +#define CLS_DEFAULT_SADDR "10.0.0.1/32" +#define CLS_DEFAULT_DADDR "10.0.0.100/32" +#define CLS_DEFAULT_SPORT 1024 +#define CLS_DEFAULT_DPORT 2048 + +#define CLS_TEST_SPORT 4096 +#define CLS_TEST_DPORT 8192 +#define CLS_TEST_DADDR "10.0.0.5/32" + +/* Test Packet values */ +#define DATA_MAGIC 0x01020304 +#define TEST_SEQ_INVALID ((uint32_t)~0) + +static odp_pool_t pool_default; +static odp_pktio_t pktio_loop; + +/** sequence number of IP packets */ +odp_atomic_u32_t seq; + +typedef struct cls_test_packet { + uint32be_t magic; + uint32be_t seq; +} cls_test_packet_t; + +static inline +int parse_ipv4_string(const char *ipaddress, uint32_t *addr, uint32_t *mask) +{ + int b[4]; + int qualifier = 32; + int converted; + + if (strchr(ipaddress, '/')) { + converted = sscanf(ipaddress, "%d.%d.%d.%d/%d", + &b[3], &b[2], &b[1], &b[0], + &qualifier); + if (5 != converted) + return -1; + } else { + converted = sscanf(ipaddress, "%d.%d.%d.%d", + &b[3], &b[2], &b[1], &b[0]); + if (4 != converted) + return -1; + } + + if ((b[0] > 255) || (b[1] > 255) || (b[2] > 255) || (b[3] > 255)) + return -1; + if (!qualifier || (qualifier > 32)) + return -1; + + *addr = b[0] | b[1] << 8 | b[2] << 16 | b[3] << 24; + if (mask) + *mask = ~(0xFFFFFFFF & ((1ULL << (32 - qualifier)) - 1)); + + return 0; +} + +static inline +void enqueue_pktio_interface(odp_packet_t pkt, odp_pktio_t pktio) +{ + odp_event_t ev; + odp_queue_t defqueue = odp_pktio_outq_getdef(pktio); + + ev = odp_packet_to_event(pkt); + CU_ASSERT(odp_queue_enq(defqueue, ev) == 0); +} + +static inline +void enqueue_loop_interface(odp_packet_t pkt) +{ + odp_event_t ev; + odp_queue_t defqueue = odp_pktio_outq_getdef(pktio_loop); + + ev = odp_packet_to_event(pkt); + CU_ASSERT(odp_queue_enq(defqueue, ev) == 0); +} + +static inline +odp_packet_t receive_packet(odp_queue_t *queue, uint64_t ns) +{ + odp_event_t ev; + + ev = odp_schedule(queue, ns); + return odp_packet_from_event(ev); +} + +static inline +odp_queue_t queue_create(char *queuename, bool sched) +{ + odp_queue_t queue; + + if (sched) { + odp_queue_param_t qparam; + + qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST; + qparam.sched.sync = ODP_SCHED_SYNC_NONE; + qparam.sched.group = ODP_SCHED_GROUP_ALL; + + queue = odp_queue_create(queuename, + ODP_QUEUE_TYPE_SCHED, + &qparam); + } else { + queue = odp_queue_create(queuename, + ODP_QUEUE_TYPE_POLL, + NULL); + } + + return queue; +} + +static uint32_t cls_pkt_get_seq(odp_packet_t pkt) +{ + uint32_t offset; + cls_test_packet_t data; + + offset = odp_packet_l4_offset(pkt); + if (offset) { + odp_packet_copydata_out(pkt, offset + ODPH_UDPHDR_LEN, + sizeof(data), &data); + + if (data.magic == DATA_MAGIC) + return data.seq; + } + + return TEST_SEQ_INVALID; +} + +static int destroy_inq(odp_pktio_t pktio) +{ + odp_queue_t inq; + odp_event_t ev; + + inq = odp_pktio_inq_getdef(pktio); + + if (inq == ODP_QUEUE_INVALID) { + CU_FAIL("attempting to destroy invalid inq"); + return -1; + } + + if (0 > odp_pktio_inq_remdef(pktio)) + return -1; + + while (1) { + ev = odp_schedule(NULL, ODP_SCHED_NO_WAIT); + + if (ev != ODP_EVENT_INVALID) + odp_buffer_free(odp_buffer_from_event(ev)); + else + break; + } + + return odp_queue_destroy(inq); +} + +int classification_test_pmr_init(void) +{ + odp_pool_t pool; + odp_pool_param_t param; + + memset(¶m, 0, sizeof(param)); + param.pkt.seg_len = SHM_PKT_BUF_SIZE; + param.pkt.len = SHM_PKT_BUF_SIZE; + param.pkt.num = SHM_PKT_NUM_BUFS; + param.type = ODP_POOL_PACKET; + + pool = odp_pool_create("classification_pool", ¶m); + if (ODP_POOL_INVALID == pool) { + fprintf(stderr, "Packet pool creation failed.\n"); + return -1; + } + + pool_default = odp_pool_lookup("classification_pool"); + if (pool_default == ODP_POOL_INVALID) + return -1; + + odp_atomic_init_u32(&seq, 0); + return 0; +} + +odp_pktio_t create_pktio(odp_queue_type_t q_type) +{ + odp_pktio_t pktio; + odp_pktio_param_t pktio_param; + odp_pool_t pool; + int ret; + + pool = odp_pool_lookup("classification_pool"); + if (pool == ODP_POOL_INVALID) + return ODP_PKTIO_INVALID; + + if (q_type == ODP_QUEUE_TYPE_POLL) + pktio_param.in_mode = ODP_PKTIN_MODE_POLL; + else + pktio_param.in_mode = ODP_PKTIN_MODE_SCHED; + + pktio = odp_pktio_open("loop", pool, &pktio_param); + if (pktio == ODP_PKTIO_INVALID) { + ret = odp_pool_destroy(pool); + if (ret) + fprintf(stderr, "unable to destroy pool.\n"); + return ODP_PKTIO_INVALID; + } + + return pktio; +} + +odp_queue_t create_default_inq(odp_pktio_t pktio, odp_queue_type_t qtype) +{ + odp_queue_param_t qparam; + odp_queue_t inq_def; + char inq_name[ODP_QUEUE_NAME_LEN]; + + qparam.sched.prio = ODP_SCHED_PRIO_DEFAULT; + qparam.sched.sync = ODP_SCHED_SYNC_ATOMIC; + qparam.sched.group = ODP_SCHED_GROUP_ALL; + + snprintf(inq_name, sizeof(inq_name), "inq-pktio-%" PRIu64, + odp_pktio_to_u64(pktio)); + inq_def = odp_queue_lookup(inq_name); + if (inq_def == ODP_QUEUE_INVALID) + inq_def = odp_queue_create( + inq_name, + ODP_QUEUE_TYPE_PKTIN, + qtype == ODP_QUEUE_TYPE_POLL ? NULL : &qparam); + + CU_ASSERT(inq_def != ODP_QUEUE_INVALID); + + if (0 > odp_pktio_inq_setdef(pktio, inq_def)) + return ODP_QUEUE_INVALID; + + return inq_def; +} + +int classification_test_pmr_term(void) +{ + int retcode = 0; + + if (0 != odp_pool_destroy(pool_default)) { + fprintf(stderr, "pool_default destroy failed.\n"); + retcode = -1; + } + + return retcode; +} + +static void classification_pmr_term_tcp_dport(void) +{ + odp_packet_t pkt; + odph_tcphdr_t *tcp; + uint32_t seq; + uint16_t val; + uint16_t mask; + int retval; + odp_pktio_t pktio; + odp_queue_t queue; + odp_queue_t retqueue; + odp_queue_t defqueue; + odp_pmr_t pmr; + odp_cos_t cos; + char cosname[ODP_QUEUE_NAME_LEN]; + char queuename[ODP_QUEUE_NAME_LEN]; + + val = CLS_TEST_DPORT; + mask = 0xffff; + + pktio = create_pktio(ODP_QUEUE_TYPE_SCHED); + defqueue = create_default_inq(pktio, ODP_QUEUE_TYPE_SCHED); + + pmr = odp_pmr_create(ODP_PMR_TCP_DPORT, &val, + &mask, sizeof(val)); + CU_ASSERT(pmr != ODP_PMR_INVAL); + + sprintf(cosname, "tcp_dport"); + cos = odp_cos_create(cosname); + CU_ASSERT_FATAL(cos != ODP_COS_INVALID); + + sprintf(queuename, "%s", "tcp_dport"); + + queue = queue_create(queuename, true); + CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID); + + retval = odp_cos_set_queue(cos, queue); + CU_ASSERT(retval == 0); + + retval = odp_pktio_pmr_cos(pmr, pktio, cos); + CU_ASSERT(retval == 0); + + pkt = create_packet_tcp(pool_default, false, false); + seq = cls_pkt_get_seq(pkt); + + tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL); + tcp->dst_port = odp_cpu_to_be_16(CLS_TEST_DPORT); + + enqueue_pktio_interface(pkt, pktio); + + pkt = receive_packet(&retqueue, ODP_TIME_SEC); + CU_ASSERT(seq == cls_pkt_get_seq(pkt)); + CU_ASSERT(retqueue == queue); + odp_packet_free(pkt); + + /* Other packets are delivered to default queue */ + pkt = create_packet_tcp(pool_default, false, false); + seq = cls_pkt_get_seq(pkt); + + tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL); + tcp->dst_port = odp_cpu_to_be_16(CLS_TEST_DPORT + 1); + + enqueue_pktio_interface(pkt, pktio); + + pkt = receive_packet(&retqueue, ODP_TIME_SEC); + CU_ASSERT(seq == cls_pkt_get_seq(pkt)); + CU_ASSERT(retqueue == defqueue); + + odp_packet_free(pkt); + destroy_inq(pktio); + odp_queue_destroy(queue); + odp_pktio_close(pktio); +} + +static void classification_pmr_term_tcp_sport(void) +{ + odp_packet_t pkt; + odph_tcphdr_t *tcp; + uint32_t seq; + uint16_t val; + uint16_t mask; + int retval; + odp_pktio_t pktio; + odp_queue_t queue; + odp_queue_t retqueue; + odp_queue_t defqueue; + odp_pmr_t pmr; + odp_cos_t cos; + char cosname[ODP_QUEUE_NAME_LEN]; + char queuename[ODP_QUEUE_NAME_LEN]; + + val = CLS_TEST_SPORT; + mask = 0xffff; + + pktio = create_pktio(ODP_QUEUE_TYPE_SCHED); + defqueue = create_default_inq(pktio, ODP_QUEUE_TYPE_SCHED); + + pmr = odp_pmr_create(ODP_PMR_TCP_SPORT, &val, + &mask, sizeof(val)); + CU_ASSERT(pmr != ODP_PMR_INVAL); + + sprintf(cosname, "tcp_sport"); + cos = odp_cos_create(cosname); + CU_ASSERT_FATAL(cos != ODP_COS_INVALID); + + sprintf(queuename, "%s", "tcp_sport"); + + queue = queue_create(queuename, true); + CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID); + + retval = odp_cos_set_queue(cos, queue); + CU_ASSERT(retval == 0); + + retval = odp_pktio_pmr_cos(pmr, pktio, cos); + CU_ASSERT(retval == 0); + + pkt = create_packet_tcp(pool_default, false, false); + seq = cls_pkt_get_seq(pkt); + + tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL); + tcp->src_port = odp_cpu_to_be_16(CLS_TEST_SPORT); + + enqueue_pktio_interface(pkt, pktio); + + pkt = receive_packet(&retqueue, ODP_TIME_SEC); + CU_ASSERT(seq == cls_pkt_get_seq(pkt)); + CU_ASSERT(retqueue == queue); + odp_packet_free(pkt); + + pkt = create_packet_tcp(pool_default, false, false); + seq = cls_pkt_get_seq(pkt); + + tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL); + tcp->src_port = odp_cpu_to_be_16(CLS_TEST_SPORT + 1); + + enqueue_pktio_interface(pkt, pktio); + + pkt = receive_packet(&retqueue, ODP_TIME_SEC); + CU_ASSERT(seq == cls_pkt_get_seq(pkt)); + CU_ASSERT(retqueue == defqueue); + + odp_packet_free(pkt); + destroy_inq(pktio); + odp_queue_destroy(queue); + odp_pktio_close(pktio); +} + +static void classification_pmr_term_udp_dport(void) +{ + odp_packet_t pkt; + odph_udphdr_t *udp; + uint32_t seq; + uint16_t val; + uint16_t mask; + int retval; + odp_pktio_t pktio; + odp_queue_t queue; + odp_queue_t retqueue; + odp_queue_t defqueue; + odp_pmr_t pmr; + odp_cos_t cos; + char cosname[ODP_QUEUE_NAME_LEN]; + char queuename[ODP_QUEUE_NAME_LEN]; + + val = CLS_TEST_DPORT; + mask = 0xffff; + + pktio = create_pktio(ODP_QUEUE_TYPE_SCHED); + defqueue = create_default_inq(pktio, ODP_QUEUE_TYPE_SCHED); + + pmr = odp_pmr_create(ODP_PMR_UDP_DPORT, &val, + &mask, sizeof(val)); + CU_ASSERT(pmr != ODP_PMR_INVAL); + + sprintf(cosname, "tcp_sport"); + cos = odp_cos_create(cosname); + CU_ASSERT_FATAL(cos != ODP_COS_INVALID); + + sprintf(queuename, "%s", "tcp_sport"); + + queue = queue_create(queuename, true); + CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID); + + retval = odp_cos_set_queue(cos, queue); + CU_ASSERT(retval == 0); + + retval = odp_pktio_pmr_cos(pmr, pktio, cos); + CU_ASSERT(retval == 0); + + pkt = create_packet_tcp(pool_default, false, true); + seq = cls_pkt_get_seq(pkt); + + udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL); + udp->dst_port = odp_cpu_to_be_16(CLS_TEST_DPORT); + + enqueue_pktio_interface(pkt, pktio); + + pkt = receive_packet(&retqueue, ODP_TIME_SEC); + CU_ASSERT(seq == cls_pkt_get_seq(pkt)); + CU_ASSERT(retqueue == queue); + odp_packet_free(pkt); + + /* Other packets received in default queue */ + pkt = create_packet_tcp(pool_default, false, true); + seq = cls_pkt_get_seq(pkt); + + udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL); + udp->dst_port = odp_cpu_to_be_16(CLS_TEST_DPORT + 1); + + enqueue_pktio_interface(pkt, pktio); + + pkt = receive_packet(&retqueue, ODP_TIME_SEC); + CU_ASSERT(seq == cls_pkt_get_seq(pkt)); + CU_ASSERT(retqueue == defqueue); + + odp_packet_free(pkt); + destroy_inq(pktio); + odp_queue_destroy(queue); + odp_pktio_close(pktio); +} + +static void classification_pmr_term_udp_sport(void) +{ + odp_packet_t pkt; + odph_udphdr_t *udp; + uint32_t seq; + uint16_t val; + uint16_t mask; + int retval; + odp_pktio_t pktio; + odp_queue_t queue; + odp_queue_t retqueue; + odp_queue_t defqueue; + odp_pmr_t pmr; + odp_cos_t cos; + char cosname[ODP_QUEUE_NAME_LEN]; + char queuename[ODP_QUEUE_NAME_LEN]; + + val = CLS_TEST_SPORT; + mask = 0xffff; + + pktio = create_pktio(ODP_QUEUE_TYPE_SCHED); + defqueue = create_default_inq(pktio, ODP_QUEUE_TYPE_SCHED); + + pmr = odp_pmr_create(ODP_PMR_UDP_SPORT, &val, + &mask, sizeof(val)); + CU_ASSERT(pmr != ODP_PMR_INVAL); + + sprintf(cosname, "udp_sport"); + cos = odp_cos_create(cosname); + CU_ASSERT_FATAL(cos != ODP_COS_INVALID); + + sprintf(queuename, "%s", "udp_sport"); + + queue = queue_create(queuename, true); + CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID); + + retval = odp_cos_set_queue(cos, queue); + CU_ASSERT(retval == 0); + + retval = odp_pktio_pmr_cos(pmr, pktio, cos); + CU_ASSERT(retval == 0); + + pkt = create_packet_tcp(pool_default, false, true); + seq = cls_pkt_get_seq(pkt); + + udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL); + udp->src_port = odp_cpu_to_be_16(CLS_TEST_SPORT); + + enqueue_pktio_interface(pkt, pktio); + + pkt = receive_packet(&retqueue, ODP_TIME_SEC); + CU_ASSERT(seq == cls_pkt_get_seq(pkt)); + CU_ASSERT(retqueue == queue); + odp_packet_free(pkt); + + pkt = create_packet_tcp(pool_default, false, true); + seq = cls_pkt_get_seq(pkt); + + udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL); + udp->src_port = odp_cpu_to_be_16(CLS_TEST_SPORT + 1); + + enqueue_pktio_interface(pkt, pktio); + + pkt = receive_packet(&retqueue, ODP_TIME_SEC); + CU_ASSERT(seq == cls_pkt_get_seq(pkt)); + CU_ASSERT(retqueue == defqueue); + odp_packet_free(pkt); + + destroy_inq(pktio); + odp_queue_destroy(queue); + odp_pktio_close(pktio); +} + +static void classification_pmr_term_ipproto(void) +{ + odp_packet_t pkt; + uint32_t seq; + uint8_t val; + uint8_t mask; + int retval; + odp_pktio_t pktio; + odp_queue_t queue; + odp_queue_t retqueue; + odp_queue_t defqueue; + odp_pmr_t pmr; + odp_cos_t cos; + char cosname[ODP_QUEUE_NAME_LEN]; + char queuename[ODP_QUEUE_NAME_LEN]; + + val = ODPH_IPPROTO_UDP; + mask = 0xff; + + pktio = create_pktio(ODP_QUEUE_TYPE_SCHED); + defqueue = create_default_inq(pktio, ODP_QUEUE_TYPE_SCHED); + + pmr = odp_pmr_create(ODP_PMR_IPPROTO, &val, + &mask, sizeof(val)); + CU_ASSERT(pmr != ODP_PMR_INVAL); + + sprintf(cosname, "ipproto"); + cos = odp_cos_create(cosname); + CU_ASSERT_FATAL(cos != ODP_COS_INVALID); + + sprintf(queuename, "%s", "ipproto"); + + queue = queue_create(queuename, true); + CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID); + + retval = odp_cos_set_queue(cos, queue); + CU_ASSERT(retval == 0); + + retval = odp_pktio_pmr_cos(pmr, pktio, cos); + CU_ASSERT(retval == 0); + + pkt = create_packet_tcp(pool_default, false, true); + seq = cls_pkt_get_seq(pkt); + + enqueue_pktio_interface(pkt, pktio); + + pkt = receive_packet(&retqueue, ODP_TIME_SEC); + CU_ASSERT(seq == cls_pkt_get_seq(pkt)); + CU_ASSERT(retqueue == queue); + odp_packet_free(pkt); + + /* Other packets delivered to default queue */ + pkt = create_packet_tcp(pool_default, false, false); + seq = cls_pkt_get_seq(pkt); + + enqueue_pktio_interface(pkt, pktio); + + pkt = receive_packet(&retqueue, ODP_TIME_SEC); + CU_ASSERT(seq == cls_pkt_get_seq(pkt)); + CU_ASSERT(retqueue == defqueue); + + odp_packet_free(pkt); + destroy_inq(pktio); + odp_queue_destroy(queue); + odp_pktio_close(pktio); +} + +CU_TestInfo classification_test_pmr[] = { + _CU_TEST_INFO(classification_pmr_term_tcp_dport), + _CU_TEST_INFO(classification_pmr_term_tcp_sport), + _CU_TEST_INFO(classification_pmr_term_udp_dport), + _CU_TEST_INFO(classification_pmr_term_udp_sport), + _CU_TEST_INFO(classification_pmr_term_ipproto), + CU_TEST_INFO_NULL, +}; diff --git a/test/validation/classification/odp_classification_tests.c b/test/validation/classification/odp_classification_tests.c index ecf9db0..9de6637 100644 --- a/test/validation/classification/odp_classification_tests.c +++ b/test/validation/classification/odp_classification_tests.c @@ -122,25 +122,6 @@ odp_packet_t receive_packet(odp_queue_t *queue, uint64_t ns) return odp_packet_from_event(ev); } -static int cls_pkt_set_seq(odp_packet_t pkt) -{ - static uint32_t seq; - cls_test_packet_t data; - uint32_t offset; - int status; - - data.magic = DATA_MAGIC; - data.seq = ++seq; - - offset = odp_packet_l4_offset(pkt); - CU_ASSERT_FATAL(offset != 0); - - status = odp_packet_copydata_in(pkt, offset + ODPH_UDPHDR_LEN, - sizeof(data), &data); - - return status; -} - static uint32_t cls_pkt_get_seq(odp_packet_t pkt) { uint32_t offset; @@ -184,89 +165,6 @@ static int destroy_inq(odp_pktio_t pktio) return odp_queue_destroy(inq); } -odp_packet_t create_packet(bool vlan) -{ - uint32_t seqno; - odph_ethhdr_t *ethhdr; - odph_udphdr_t *udp; - odph_ipv4hdr_t *ip; - uint8_t payload_len; - char src_mac[ODPH_ETHADDR_LEN] = {0}; - char dst_mac[ODPH_ETHADDR_LEN] = {0}; - uint32_t addr = 0; - uint32_t mask; - int offset; - odp_packet_t pkt; - int packet_len = 0; - - payload_len = sizeof(cls_test_packet_t); - packet_len += ODPH_ETHHDR_LEN; - packet_len += ODPH_IPV4HDR_LEN; - packet_len += ODPH_UDPHDR_LEN; - packet_len += payload_len; - - if (vlan) - packet_len += ODPH_VLANHDR_LEN; - - pkt = odp_packet_alloc(pool_default, packet_len); - CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); - - /* Ethernet Header */ - offset = 0; - odp_packet_l2_offset_set(pkt, offset); - ethhdr = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL); - memcpy(ethhdr->src.addr, src_mac, ODPH_ETHADDR_LEN); - memcpy(ethhdr->dst.addr, dst_mac, ODPH_ETHADDR_LEN); - offset += sizeof(odph_ethhdr_t); - if (vlan) { - /* Default vlan header */ - uint8_t *parseptr; - odph_vlanhdr_t *vlan = (odph_vlanhdr_t *)(ðhdr->type); - parseptr = (uint8_t *)vlan; - vlan->tci = odp_cpu_to_be_16(0); - vlan->tpid = odp_cpu_to_be_16(ODPH_ETHTYPE_VLAN); - offset += sizeof(odph_vlanhdr_t); - parseptr += sizeof(odph_vlanhdr_t); - uint16be_t *type = (uint16be_t *)(void *)parseptr; - *type = odp_cpu_to_be_16(ODPH_ETHTYPE_IPV4); - } else { - ethhdr->type = odp_cpu_to_be_16(ODPH_ETHTYPE_IPV4); - } - - odp_packet_l3_offset_set(pkt, offset); - - /* ipv4 */ - ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt, NULL); - - parse_ipv4_string(CLS_DEFAULT_SADDR, &addr, &mask); - ip->dst_addr = odp_cpu_to_be_32(addr); - - parse_ipv4_string(CLS_DEFAULT_DADDR, &addr, &mask); - ip->src_addr = odp_cpu_to_be_32(addr); - ip->ver_ihl = ODPH_IPV4 << 4 | ODPH_IPV4HDR_IHL_MIN; - ip->tot_len = odp_cpu_to_be_16(ODPH_UDPHDR_LEN + payload_len + - ODPH_IPV4HDR_LEN); - ip->ttl = 128; - ip->proto = ODPH_IPPROTO_UDP; - seqno = odp_atomic_fetch_inc_u32(&seq); - ip->id = odp_cpu_to_be_16(seqno); - ip->chksum = 0; - ip->chksum = odp_cpu_to_be_16(odph_ipv4_csum_update(pkt)); - offset += ODPH_IPV4HDR_LEN; - - /* udp */ - odp_packet_l4_offset_set(pkt, offset); - udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL); - udp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT); - udp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT); - udp->length = odp_cpu_to_be_16(payload_len + ODPH_UDPHDR_LEN); - udp->chksum = 0; - - /* set pkt sequence number */ - cls_pkt_set_seq(pkt); - - return pkt; -} int classification_suite_init(void) { @@ -442,7 +340,7 @@ void test_cls_pmr_chain(void) uint32_t mask; uint32_t seq; - pkt = create_packet(false); + pkt = create_packet_tcp(pool_default, false, true); seq = cls_pkt_get_seq(pkt); ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt, NULL); parse_ipv4_string(CLS_PMR_CHAIN_SADDR, &addr, &mask); @@ -460,7 +358,7 @@ void test_cls_pmr_chain(void) CU_ASSERT(seq == cls_pkt_get_seq(pkt)); odp_packet_free(pkt); - pkt = create_packet(false); + pkt = create_packet_tcp(pool_default, false, true); seq = cls_pkt_get_seq(pkt); ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt, NULL); parse_ipv4_string(CLS_PMR_CHAIN_SADDR, &addr, &mask); @@ -508,7 +406,7 @@ void test_pktio_default_cos(void) odp_queue_t queue; uint32_t seq; /* create a default packet */ - pkt = create_packet(false); + pkt = create_packet_tcp(pool_default, false, true); seq = cls_pkt_get_seq(pkt); enqueue_loop_interface(pkt); @@ -554,7 +452,7 @@ void test_pktio_error_cos(void) odp_packet_t pkt; /*Create an error packet */ - pkt = create_packet(false); + pkt = create_packet_tcp(pool_default, false, true); odph_ipv4hdr_t *ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt, NULL); /* Incorrect IpV4 version */ @@ -648,7 +546,7 @@ void test_cos_with_l2_priority(void) uint8_t i; for (i = 0; i < CLS_L2_QOS_MAX; i++) { - pkt = create_packet(true); + pkt = create_packet_tcp(pool_default, true, true); seq = cls_pkt_get_seq(pkt); ethhdr = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL); vlan = (odph_vlanhdr_t *)(ðhdr->type); @@ -706,7 +604,7 @@ void test_pmr_cos(void) odp_queue_t queue; uint32_t seq; - pkt = create_packet(false); + pkt = create_packet_tcp(pool_default, false, true); seq = cls_pkt_get_seq(pkt); udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL); udp->src_port = odp_cpu_to_be_16(CLS_PMR_SPORT); @@ -780,7 +678,7 @@ void test_pktio_pmr_match_set_cos(void) odp_queue_t queue; uint32_t seq; - pkt = create_packet(false); + pkt = create_packet_tcp(pool_default, false, true); seq = cls_pkt_get_seq(pkt); ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt, NULL); parse_ipv4_string(CLS_PMR_SET_SADDR, &addr, &mask); diff --git a/test/validation/classification/odp_classification_testsuites.h b/test/validation/classification/odp_classification_testsuites.h index f603f30..be30ff0 100644 --- a/test/validation/classification/odp_classification_testsuites.h +++ b/test/validation/classification/odp_classification_testsuites.h @@ -16,11 +16,18 @@ extern CU_TestInfo classification_suite[]; extern CU_TestInfo classification_suite_basic[]; +extern CU_TestInfo classification_test_pmr[]; int classification_suite_init(void); int classification_suite_term(void); +int classification_test_pmr_term(void); +int classification_test_pmr_init(void); + +odp_packet_t create_packet_tcp(odp_pool_t pool, bool vlan, bool udp); odp_packet_t create_packet(bool vlan); +odp_pktio_t create_pktio(odp_queue_type_t q_type); +odp_queue_t create_default_inq(odp_pktio_t pktio, odp_queue_type_t qtype); void configure_pktio_default_cos(void); void test_pktio_default_cos(void); void configure_pktio_error_cos(void);