From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id F0847A0613 for ; Tue, 24 Sep 2019 19:14:38 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 8337B28FD; Tue, 24 Sep 2019 19:14:37 +0200 (CEST) Received: from mga14.intel.com (mga14.intel.com [192.55.52.115]) by dpdk.org (Postfix) with ESMTP id 7EDED1DBD for ; Tue, 24 Sep 2019 19:14:35 +0200 (CEST) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga004.fm.intel.com ([10.253.24.48]) by fmsmga103.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 24 Sep 2019 10:14:34 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.64,544,1559545200"; d="scan'208";a="213759915" Received: from irsmsx107.ger.corp.intel.com ([163.33.3.99]) by fmsmga004.fm.intel.com with ESMTP; 24 Sep 2019 10:14:33 -0700 Received: from irsmsx105.ger.corp.intel.com ([169.254.7.164]) by IRSMSX107.ger.corp.intel.com ([169.254.10.7]) with mapi id 14.03.0439.000; Tue, 24 Sep 2019 18:14:32 +0100 From: "Ananyev, Konstantin" To: Harman Kalra CC: "dev@dpdk.org" Thread-Topic: [PATCH] test/bpf: add new test cases Thread-Index: AQHVcuuWfPAukSSWCkez/k1/g6T2dKc7D7zA Date: Tue, 24 Sep 2019 17:14:31 +0000 Message-ID: <2601191342CEEE43887BDE71AB9772580191969C75@irsmsx105.ger.corp.intel.com> References: <1569338383-11118-1-git-send-email-hkalra@marvell.com> In-Reply-To: <1569338383-11118-1-git-send-email-hkalra@marvell.com> Accept-Language: en-IE, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: x-titus-metadata-40: eyJDYXRlZ29yeUxhYmVscyI6IiIsIk1ldGFkYXRhIjp7Im5zIjoiaHR0cDpcL1wvd3d3LnRpdHVzLmNvbVwvbnNcL0ludGVsMyIsImlkIjoiNDkxMDEwYzYtYzE5Yi00Y2VlLTljYWEtZjM5ZTc4N2Y2MTUxIiwicHJvcHMiOlt7Im4iOiJDVFBDbGFzc2lmaWNhdGlvbiIsInZhbHMiOlt7InZhbHVlIjoiQ1RQX05UIn1dfV19LCJTdWJqZWN0TGFiZWxzIjpbXSwiVE1DVmVyc2lvbiI6IjE3LjEwLjE4MDQuNDkiLCJUcnVzdGVkTGFiZWxIYXNoIjoiRFFvVXNWRW9iNFlZb3lqelpLWmdxV25YV0d4WEJycndXRHR3UFNCUzlcL0JWZGhrXC81RFU3NWVjT0RReDgwa0tMIn0= x-ctpclassification: CTP_NT dlp-product: dlpe-windows dlp-version: 11.2.0.6 dlp-reaction: no-action x-originating-ip: [163.33.239.182] Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Subject: Re: [dpdk-dev] [PATCH] test/bpf: add new test cases X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Hi, >=20 > This patch implements following new test cases: > - test_call4: test case to verify if stack corruption occurs > across with multiple function calls. > - test_jump2: test case with a default packet in memory, parse > the packet and check if dest ip is part of a subnet. > - test_call5: test case with string data in the stack and > calling string comaprision. >=20 > Signed-off-by: Harman Kalra > --- > app/test/test_bpf.c | 644 ++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 644 insertions(+) >=20 > diff --git a/app/test/test_bpf.c b/app/test/test_bpf.c > index e8841800a..c6b9819fc 100644 > --- a/app/test/test_bpf.c > +++ b/app/test/test_bpf.c > @@ -14,6 +14,8 @@ > #include > #include > #include > +#include > +#include >=20 > #include "test.h" >=20 > @@ -35,6 +37,12 @@ struct dummy_vect8 { > struct dummy_offset out[8]; > }; >=20 > +struct dummy_net { > + struct rte_ether_hdr eth_hdr; > + struct rte_vlan_hdr vlan_hdr; > + struct rte_ipv4_hdr ip_hdr; > +}; > + > #define TEST_FILL_1 0xDEADBEEF >=20 > #define TEST_MUL_1 21 > @@ -54,6 +62,20 @@ struct dummy_vect8 { > #define TEST_IMM_4 ((uint64_t)UINT32_MAX) > #define TEST_IMM_5 ((uint64_t)UINT32_MAX + 1) >=20 > +#define TEST_MEMFROB 0x2a2a2a2a > + > +#define STRING_GEEK 0x6B656567 > +#define STRING_WEEK 0x6B656577 > + > +#define TEST_NETMASK 0xffffff00 > +#define TEST_SUBNET 0xaca80200 > + > +uint8_t src_mac[] =3D { 0x00, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF }; > +uint8_t dst_mac[] =3D { 0x00, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA }; > + > +uint32_t ip_src_addr =3D (172U << 24) | (168U << 16) | (2 << 8) | 1; > +uint32_t ip_dst_addr =3D (172U << 24) | (168U << 16) | (2 << 8) | 2; > + > struct bpf_test { > const char *name; > size_t arg_sz; > @@ -866,6 +888,181 @@ test_jump1_check(uint64_t rc, const void *arg) > return cmp_res(__func__, rv, rc, &rv, &rc, sizeof(rv)); > } >=20 > +/* Jump test case - check ip4_dest in particular subnet */ > +static const struct ebpf_insn test_jump2_prog[] =3D { > + > + [0] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_2, > + .imm =3D 0xe, > + }, > + [1] =3D { > + .code =3D (BPF_LDX | BPF_MEM | BPF_H), > + .dst_reg =3D EBPF_REG_3, > + .src_reg =3D EBPF_REG_1, > + .off =3D 12, > + }, > + [2] =3D { > + .code =3D (BPF_JMP | EBPF_JNE | BPF_K), > + .dst_reg =3D EBPF_REG_3, > + .off =3D 2, > + .imm =3D 0x81, > + }, > + [3] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_2, > + .imm =3D 0x12, > + }, > + [4] =3D { > + .code =3D (BPF_LDX | BPF_MEM | BPF_H), > + .dst_reg =3D EBPF_REG_3, > + .src_reg =3D EBPF_REG_1, > + .off =3D 16, > + }, > + [5] =3D { > + .code =3D (EBPF_ALU64 | BPF_AND | BPF_K), > + .dst_reg =3D EBPF_REG_3, > + .imm =3D 0xffff, > + }, > + [6] =3D { > + .code =3D (BPF_JMP | EBPF_JNE | BPF_K), > + .dst_reg =3D EBPF_REG_3, > + .off =3D 9, > + .imm =3D 0x8, > + }, > + [7] =3D { > + .code =3D (EBPF_ALU64 | BPF_ADD | BPF_X), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_2, > + }, > + [8] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_0, > + .imm =3D 0, > + }, > + [9] =3D { > + .code =3D (BPF_LDX | BPF_MEM | BPF_W), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_1, > + .off =3D 16, > + }, > + [10] =3D { > + .code =3D (BPF_ALU | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_3, > + .imm =3D TEST_NETMASK, > + }, > + [11] =3D { > + .code =3D (BPF_ALU | EBPF_END | EBPF_TO_BE), > + .dst_reg =3D EBPF_REG_3, > + .imm =3D sizeof(uint32_t) * CHAR_BIT, > + }, > + [12] =3D { > + .code =3D (BPF_ALU | BPF_AND | BPF_X), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_3, > + }, > + [13] =3D { > + .code =3D (BPF_ALU | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_3, > + .imm =3D TEST_SUBNET, > + }, > + [14] =3D { > + .code =3D (BPF_ALU | EBPF_END | EBPF_TO_BE), > + .dst_reg =3D EBPF_REG_3, > + .imm =3D sizeof(uint32_t) * CHAR_BIT, > + }, > + [15] =3D { > + .code =3D (BPF_JMP | BPF_JEQ | BPF_X), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_3, > + .off =3D 1, > + }, > + [16] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_0, > + .imm =3D -1, > + }, > + [17] =3D { > + .code =3D (BPF_JMP | EBPF_EXIT), > + }, > +}; > + > +/* Preparing a vlan packet */ > +static void > +test_jump2_prepare(void *arg) > +{ > + struct dummy_net *dn; > + > + dn =3D arg; > + memset(dn, 0, sizeof(*dn)); > + > + /* > + * Initialize ether header. > + */ > + rte_ether_addr_copy((struct rte_ether_addr *)dst_mac, > + &dn->eth_hdr.d_addr); > + rte_ether_addr_copy((struct rte_ether_addr *)src_mac, > + &dn->eth_hdr.s_addr); > + dn->eth_hdr.ether_type =3D rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN); > + > + /* > + * Initialize vlan header. > + */ > + dn->vlan_hdr.eth_proto =3D rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4); > + dn->vlan_hdr.vlan_tci =3D 32; > + > + /* > + * Initialize IP header. > + */ > + dn->ip_hdr.version_ihl =3D 0x45; /*IP_VERSION | IP_HDRLEN*/ > + dn->ip_hdr.time_to_live =3D 64; /* IP_DEFTTL */ > + dn->ip_hdr.next_proto_id =3D IPPROTO_TCP; > + dn->ip_hdr.packet_id =3D rte_cpu_to_be_16(0x463c); > + dn->ip_hdr.total_length =3D rte_cpu_to_be_16(60); > + dn->ip_hdr.src_addr =3D rte_cpu_to_be_32(ip_src_addr); > + dn->ip_hdr.dst_addr =3D rte_cpu_to_be_32(ip_dst_addr); > +} > + > +static int > +test_jump2_check(uint64_t rc, const void *arg) > +{ > + const struct rte_ether_hdr *eth_hdr =3D arg; > + const struct rte_ipv4_hdr *ipv4_hdr; > + const void *next =3D eth_hdr; > + uint16_t eth_type; > + uint64_t v =3D -1; > + > + if (eth_hdr->ether_type =3D=3D htons(0x8100)) { > + const struct rte_vlan_hdr *vlan_hdr =3D > + (const void *)(eth_hdr + 1); > + eth_type =3D vlan_hdr->eth_proto; > + next =3D vlan_hdr + 1; > + } else { > + eth_type =3D eth_hdr->ether_type; > + next =3D eth_hdr + 1; > + } > + > + if (eth_type =3D=3D htons(0x0800)) { > + ipv4_hdr =3D next; > + if ((ipv4_hdr->dst_addr & rte_cpu_to_be_32(TEST_NETMASK)) =3D=3D > + rte_cpu_to_be_32(TEST_SUBNET)) { > + v =3D 0; > + } > + } > + > + if (v !=3D rc) { > + printf("%s@%d: invalid return value " > + "expected=3D0x%" PRIx64 ", actual=3D0x%" PRIx64 "\n", > + __func__, __LINE__, v, rc); > + return -1; > + } > + > + if (v) > + printf("Either IP not part of subnet or wrong ethertype\n"); Looks good to me in general, and obviously more tests are always welcome :) Just one nit - I think it here and in other tests that you added it is bett= er to use cm_res() for results validation. First - makes code more uniform, second cmp_res() does memcp() for whole st= ructs, which helps to catch possible problems with silent data corruption, etc. Konstantin > + > + return 0; > +} > + > /* alu (add, sub, and, or, xor, neg) test-cases */ > static const struct ebpf_insn test_alu1_prog[] =3D { >=20 > @@ -1889,6 +2086,403 @@ static const struct rte_bpf_xsym test_call3_xsym[= ] =3D { > }, > }; >=20 > +/* Test for stack corruption in multiple function calls */ > +static const struct ebpf_insn test_call4_prog[] =3D { > + { > + .code =3D (BPF_ST | BPF_MEM | BPF_B), > + .dst_reg =3D EBPF_REG_10, > + .off =3D -4, > + .imm =3D 1, > + }, > + { > + .code =3D (BPF_ST | BPF_MEM | BPF_B), > + .dst_reg =3D EBPF_REG_10, > + .off =3D -3, > + .imm =3D 2, > + }, > + { > + .code =3D (BPF_ST | BPF_MEM | BPF_B), > + .dst_reg =3D EBPF_REG_10, > + .off =3D -2, > + .imm =3D 3, > + }, > + { > + .code =3D (BPF_ST | BPF_MEM | BPF_B), > + .dst_reg =3D EBPF_REG_10, > + .off =3D -1, > + .imm =3D 4, > + }, > + { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_X), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_10, > + }, > + { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_2, > + .imm =3D 4, > + }, > + { > + .code =3D (EBPF_ALU64 | BPF_SUB | BPF_X), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_2, > + }, > + { > + .code =3D (BPF_JMP | EBPF_CALL), > + .imm =3D 0, > + }, > + { > + .code =3D (BPF_LDX | BPF_MEM | BPF_B), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_10, > + .off =3D -4, > + }, > + { > + .code =3D (BPF_LDX | BPF_MEM | BPF_B), > + .dst_reg =3D EBPF_REG_2, > + .src_reg =3D EBPF_REG_10, > + .off =3D -3, > + }, > + { > + .code =3D (BPF_LDX | BPF_MEM | BPF_B), > + .dst_reg =3D EBPF_REG_3, > + .src_reg =3D EBPF_REG_10, > + .off =3D -2, > + }, > + { > + .code =3D (BPF_LDX | BPF_MEM | BPF_B), > + .dst_reg =3D EBPF_REG_4, > + .src_reg =3D EBPF_REG_10, > + .off =3D -1, > + }, > + { > + .code =3D (BPF_JMP | EBPF_CALL), > + .imm =3D 1, > + }, > + { > + .code =3D (EBPF_ALU64 | BPF_XOR | BPF_K), > + .dst_reg =3D EBPF_REG_0, > + .imm =3D TEST_MEMFROB, > + }, > + { > + .code =3D (BPF_JMP | EBPF_EXIT), > + }, > +}; > + > +/* Gathering the bytes together */ > +static uint32_t > +dummy_func4_1(uint8_t a, uint8_t b, uint8_t c, uint8_t d) > +{ > + return (a << 24) | (b << 16) | (c << 8) | (d << 0); > +} > + > +/* Implementation of memfrob */ > +static uint32_t > +dummy_func4_0(uint32_t *s, uint8_t n) > +{ > + char *p =3D (char *) s; > + while (n-- > 0) > + *p++ ^=3D 42; > + return *s; > +} > + > + > +static int > +test_call4_check(uint64_t rc, const void *arg) > +{ > + uint8_t a[4] =3D {1, 2, 3, 4}; > + uint32_t s, v =3D 0; > + > + RTE_SET_USED(arg); > + > + s =3D dummy_func4_0((uint32_t *)a, 4); > + > + s =3D dummy_func4_1(a[0], a[1], a[2], a[3]); > + > + v =3D s ^ TEST_MEMFROB; > + > + if (v !=3D rc) { > + printf("%s@%d: invalid return value " > + "expected=3D0x%" PRIx32 ", actual=3D0x%" PRIx64 "\n", > + __func__, __LINE__, v, rc); > + return -1; > + } > + return 0; > +} > + > +static const struct rte_bpf_xsym test_call4_xsym[] =3D { > + [0] =3D { > + .name =3D RTE_STR(dummy_func4_0), > + .type =3D RTE_BPF_XTYPE_FUNC, > + .func =3D { > + .val =3D (void *)dummy_func4_0, > + .nb_args =3D 2, > + .args =3D { > + [0] =3D { > + .type =3D RTE_BPF_ARG_PTR, > + .size =3D 4 * sizeof(uint8_t), > + }, > + [1] =3D { > + .type =3D RTE_BPF_ARG_RAW, > + .size =3D sizeof(uint8_t), > + }, > + }, > + .ret =3D { > + .type =3D RTE_BPF_ARG_RAW, > + .size =3D sizeof(uint32_t), > + }, > + }, > + }, > + [1] =3D { > + .name =3D RTE_STR(dummy_func4_1), > + .type =3D RTE_BPF_XTYPE_FUNC, > + .func =3D { > + .val =3D (void *)dummy_func4_1, > + .nb_args =3D 4, > + .args =3D { > + [0] =3D { > + .type =3D RTE_BPF_ARG_RAW, > + .size =3D sizeof(uint8_t), > + }, > + [1] =3D { > + .type =3D RTE_BPF_ARG_RAW, > + .size =3D sizeof(uint8_t), > + }, > + [2] =3D { > + .type =3D RTE_BPF_ARG_RAW, > + .size =3D sizeof(uint8_t), > + }, > + [3] =3D { > + .type =3D RTE_BPF_ARG_RAW, > + .size =3D sizeof(uint8_t), > + }, > + }, > + .ret =3D { > + .type =3D RTE_BPF_ARG_RAW, > + .size =3D sizeof(uint32_t), > + }, > + }, > + }, > +}; > + > +/* string compare test case */ > +static const struct ebpf_insn test_call5_prog[] =3D { > + > + [0] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_1, > + .imm =3D STRING_GEEK, > + }, > + [1] =3D { > + .code =3D (BPF_STX | BPF_MEM | BPF_W), > + .dst_reg =3D EBPF_REG_10, > + .src_reg =3D EBPF_REG_1, > + .off =3D -8, > + }, > + [2] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_6, > + .imm =3D 0, > + }, > + [3] =3D { > + .code =3D (BPF_STX | BPF_MEM | BPF_B), > + .dst_reg =3D EBPF_REG_10, > + .src_reg =3D EBPF_REG_6, > + .off =3D -4, > + }, > + [4] =3D { > + .code =3D (BPF_STX | BPF_MEM | BPF_W), > + .dst_reg =3D EBPF_REG_10, > + .src_reg =3D EBPF_REG_6, > + .off =3D -12, > + }, > + [5] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_1, > + .imm =3D STRING_WEEK, > + }, > + [6] =3D { > + .code =3D (BPF_STX | BPF_MEM | BPF_W), > + .dst_reg =3D EBPF_REG_10, > + .src_reg =3D EBPF_REG_1, > + .off =3D -16, > + }, > + [7] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_X), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_10, > + }, > + [8] =3D { > + .code =3D (EBPF_ALU64 | BPF_ADD | BPF_K), > + .dst_reg =3D EBPF_REG_1, > + .imm =3D -8, > + }, > + [9] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_X), > + .dst_reg =3D EBPF_REG_2, > + .src_reg =3D EBPF_REG_1, > + }, > + [10] =3D { > + .code =3D (BPF_JMP | EBPF_CALL), > + .imm =3D 0, > + }, > + [11] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_X), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_0, > + }, > + [12] =3D { > + .code =3D (BPF_ALU | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_0, > + .imm =3D -1, > + }, > + [13] =3D { > + .code =3D (EBPF_ALU64 | BPF_LSH | BPF_K), > + .dst_reg =3D EBPF_REG_1, > + .imm =3D 0x20, > + }, > + [14] =3D { > + .code =3D (EBPF_ALU64 | BPF_RSH | BPF_K), > + .dst_reg =3D EBPF_REG_1, > + .imm =3D 0x20, > + }, > + [15] =3D { > + .code =3D (BPF_JMP | EBPF_JNE | BPF_K), > + .dst_reg =3D EBPF_REG_1, > + .off =3D 11, > + .imm =3D 0, > + }, > + [16] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_X), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_10, > + }, > + [17] =3D { > + .code =3D (EBPF_ALU64 | BPF_ADD | BPF_K), > + .dst_reg =3D EBPF_REG_1, > + .imm =3D -8, > + }, > + [18] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_X), > + .dst_reg =3D EBPF_REG_2, > + .src_reg =3D EBPF_REG_10, > + }, > + [19] =3D { > + .code =3D (EBPF_ALU64 | BPF_ADD | BPF_K), > + .dst_reg =3D EBPF_REG_2, > + .imm =3D -16, > + }, > + [20] =3D { > + .code =3D (BPF_JMP | EBPF_CALL), > + .imm =3D 0, > + }, > + [21] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_X), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_0, > + }, > + [22] =3D { > + .code =3D (EBPF_ALU64 | BPF_LSH | BPF_K), > + .dst_reg =3D EBPF_REG_1, > + .imm =3D 0x20, > + }, > + [23] =3D { > + .code =3D (EBPF_ALU64 | BPF_RSH | BPF_K), > + .dst_reg =3D EBPF_REG_1, > + .imm =3D 0x20, > + }, > + [24] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_X), > + .dst_reg =3D EBPF_REG_0, > + .src_reg =3D EBPF_REG_1, > + }, > + [25] =3D { > + .code =3D (BPF_JMP | BPF_JEQ | BPF_X), > + .dst_reg =3D EBPF_REG_1, > + .src_reg =3D EBPF_REG_6, > + .off =3D 1, > + }, > + [26] =3D { > + .code =3D (EBPF_ALU64 | EBPF_MOV | BPF_K), > + .dst_reg =3D EBPF_REG_0, > + .imm =3D 0, > + }, > + [27] =3D { > + .code =3D (BPF_JMP | EBPF_EXIT), > + }, > +}; > + > +/* String comparision impelementation, return 0 if equal else difference= */ > +static uint32_t > +dummy_func5(const char *s1, const char *s2) > +{ > + while (*s1 && (*s1 =3D=3D *s2)) { > + s1++; > + s2++; > + } > + return *(const unsigned char *)s1 - *(const unsigned char *)s2; > +} > + > +static int > +test_call5_check(uint64_t rc, const void *arg) > +{ > + char a[] =3D "geek"; > + char b[] =3D "week"; > + uint32_t v; > + > + RTE_SET_USED(arg); > + > + v =3D dummy_func5(a, a); > + if (v !=3D 0) { > + v =3D -1; > + goto fail; > + } > + > + v =3D dummy_func5(a, b); > + if (v =3D=3D 0) > + goto fail; > + > + v =3D 0; > + > +fail: > + if (v !=3D rc) { > + printf("%s@%d: invalid return value " > + "expected=3D0x%" PRIx32 ", actual=3D0x%" PRIx64 "\n", > + __func__, __LINE__, v, rc); > + return -1; > + } > + > + if (v) > + printf("String comparision test failed\n"); > + > + return 0; > +} > + > +static const struct rte_bpf_xsym test_call5_xsym[] =3D { > + [0] =3D { > + .name =3D RTE_STR(dummy_func5), > + .type =3D RTE_BPF_XTYPE_FUNC, > + .func =3D { > + .val =3D (void *)dummy_func5, > + .nb_args =3D 2, > + .args =3D { > + [0] =3D { > + .type =3D RTE_BPF_ARG_PTR, > + .size =3D sizeof(char), > + }, > + [1] =3D { > + .type =3D RTE_BPF_ARG_PTR, > + .size =3D sizeof(char), > + }, > + }, > + .ret =3D { > + .type =3D RTE_BPF_ARG_RAW, > + .size =3D sizeof(uint32_t), > + }, > + }, > + }, > +}; > + > static const struct bpf_test tests[] =3D { > { > .name =3D "test_store1", > @@ -1988,6 +2582,20 @@ static const struct bpf_test tests[] =3D { > .prepare =3D test_jump1_prepare, > .check_result =3D test_jump1_check, > }, > + { > + .name =3D "test_jump2", > + .arg_sz =3D sizeof(struct dummy_net), > + .prm =3D { > + .ins =3D test_jump2_prog, > + .nb_ins =3D RTE_DIM(test_jump2_prog), > + .prog_arg =3D { > + .type =3D RTE_BPF_ARG_PTR, > + .size =3D sizeof(struct dummy_net), > + }, > + }, > + .prepare =3D test_jump2_prepare, > + .check_result =3D test_jump2_check, > + }, > { > .name =3D "test_alu1", > .arg_sz =3D sizeof(struct dummy_vect8), > @@ -2098,6 +2706,42 @@ static const struct bpf_test tests[] =3D { > /* for now don't support function calls on 32 bit platform */ > .allow_fail =3D (sizeof(uint64_t) !=3D sizeof(uintptr_t)), > }, > + { > + .name =3D "test_call4", > + .arg_sz =3D sizeof(struct dummy_offset), > + .prm =3D { > + .ins =3D test_call4_prog, > + .nb_ins =3D RTE_DIM(test_call4_prog), > + .prog_arg =3D { > + .type =3D RTE_BPF_ARG_PTR, > + .size =3D 2 * sizeof(struct dummy_offset), > + }, > + .xsym =3D test_call4_xsym, > + .nb_xsym =3D RTE_DIM(test_call4_xsym), > + }, > + .prepare =3D test_store1_prepare, > + .check_result =3D test_call4_check, > + /* for now don't support function calls on 32 bit platform */ > + .allow_fail =3D (sizeof(uint64_t) !=3D sizeof(uintptr_t)), > + }, > + { > + .name =3D "test_call5", > + .arg_sz =3D sizeof(struct dummy_offset), > + .prm =3D { > + .ins =3D test_call5_prog, > + .nb_ins =3D RTE_DIM(test_call5_prog), > + .prog_arg =3D { > + .type =3D RTE_BPF_ARG_PTR, > + .size =3D sizeof(struct dummy_offset), > + }, > + .xsym =3D test_call5_xsym, > + .nb_xsym =3D RTE_DIM(test_call5_xsym), > + }, > + .prepare =3D test_store1_prepare, > + .check_result =3D test_call5_check, > + /* for now don't support function calls on 32 bit platform */ > + .allow_fail =3D (sizeof(uint64_t) !=3D sizeof(uintptr_t)), > + }, > }; >=20 > static int > -- > 2.18.0