DPDK patches and discussions
 help / color / mirror / Atom feed
From: "Ananyev, Konstantin" <konstantin.ananyev@intel.com>
To: Karmarkar Suyash <skarmarkar@sonusnet.com>,
	"dev@dpdk.org" <dev@dpdk.org>
Cc: "Dey, Souvik" <sodey@sonusnet.com>,
	"Patil, PraveenKumar" <ppatil@sonusnet.com>
Subject: Re: [dpdk-dev] Bug in IPACL library of DPDK-1.6.0
Date: Tue, 14 Oct 2014 15:17:35 +0000
Message-ID: <2601191342CEEE43887BDE71AB9772582139386C@IRSMSX105.ger.corp.intel.com> (raw)
In-Reply-To: <F68D47BAAB943145B18773EDECE588EE0DC00FFF@inba-mail02.sonusnet.com>



> -----Original Message-----
> From: Karmarkar Suyash [mailto:skarmarkar@sonusnet.com]
> Sent: Tuesday, October 14, 2014 4:07 PM
> To: Ananyev, Konstantin; dev@dpdk.org
> Cc: Dey, Souvik; Patil, PraveenKumar
> Subject: RE: Bug in IPACL library of DPDK-1.6.0
> 
> Hi Konstantin,
> 
> We did even tried with DPDK-1.7.0 version still we faced the same issue.

Then I suppose, I need more information to reproduce it...
See below the code I used, based on your description. 
Does it replicate your problem?

enum
{
   NEXT_HDR_FIELD_IPV6, //8
        IPSRC_FIELD0_IPV6,
        IPSRC_FIELD1_IPV6,
        IPSRC_FIELD2_IPV6,
        IPSRC_FIELD3_IPV6,
        IPDST_FIELD0_IPV6,
        IPDST_FIELD1_IPV6,
        IPDST_FIELD2_IPV6,
        IPDST_FIELD3_IPV6,
        PORTS_FIELD_IPV6,  // src port (16) + dest port (16) => 32
   LIF_GRP_INFO_FIELD_IPV6, //lif group (16) +  lif Id (16)  => 32
   ADDR_CTX_FIELD_IPV6, //addr context (32)
   NUM_FIELDS_IPV6
};



static const struct rte_acl_field_def ipv6_defs[NUM_FIELDS_IPV6] = {
   {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint8_t),
      .field_index = NEXT_HDR_FIELD_IPV6,
      .input_index = NEXT_HDR_FIELD_IPV6,
      .offset = offsetof(struct ipv6_hdr, proto),
   },

///source ip
   {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint32_t),
      .field_index = IPSRC_FIELD0_IPV6,
      .input_index = IPSRC_FIELD0_IPV6,
      .offset = offsetof(struct ipv6_hdr, src_addr),
   },
   {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint32_t),
      .field_index = IPSRC_FIELD1_IPV6,
      .input_index = IPSRC_FIELD1_IPV6,
      .offset = offsetof(struct ipv6_hdr, src_addr) + 1*sizeof (uint32_t),
   },
   {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint32_t),
      .field_index = IPSRC_FIELD2_IPV6,
      .input_index = IPSRC_FIELD2_IPV6,
      .offset = offsetof(struct ipv6_hdr, src_addr) + 2*sizeof (uint32_t),
   },
   {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint32_t),
      .field_index = IPSRC_FIELD3_IPV6,
      .input_index = IPSRC_FIELD3_IPV6,
      .offset = offsetof(struct ipv6_hdr, src_addr) + 3*sizeof (uint32_t),
   },

///destination ip
   {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint32_t),
      .field_index = IPDST_FIELD0_IPV6,
      .input_index = IPDST_FIELD0_IPV6,
      .offset = offsetof(struct ipv6_hdr, dst_addr),
   },
   {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint32_t),
      .field_index = IPDST_FIELD1_IPV6,
      .input_index = IPDST_FIELD1_IPV6,
      .offset = offsetof(struct ipv6_hdr, dst_addr) + 1*sizeof (uint32_t),
   },
   {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint32_t),
      .field_index = IPDST_FIELD2_IPV6,
      .input_index = IPDST_FIELD2_IPV6,
      .offset = offsetof(struct ipv6_hdr, dst_addr) + 2*sizeof (uint32_t),
   },
   {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint32_t),
      .field_index = IPDST_FIELD3_IPV6,
      .input_index = IPDST_FIELD3_IPV6,
      .offset = offsetof(struct ipv6_hdr, dst_addr) + 3*sizeof (uint32_t),
   },

   ///ports
    {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint32_t),
      .field_index = PORTS_FIELD_IPV6,
      .input_index = PORTS_FIELD_IPV6,
      .offset = sizeof(struct ipv6_hdr) ,
   },
    //LIF grp and addr ctx
   {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint32_t),
      .field_index = LIF_GRP_INFO_FIELD_IPV6,
      .input_index = LIF_GRP_INFO_FIELD_IPV6,
      .offset = sizeof(struct ipv6_hdr) +  sizeof (uint32_t),
   },
   {
      .type = RTE_ACL_FIELD_TYPE_BITMASK,
      .size = sizeof (uint32_t),
      .field_index = ADDR_CTX_FIELD_IPV6,
      .input_index = ADDR_CTX_FIELD_IPV6,
      .offset = sizeof(struct ipv6_hdr) +  2*sizeof (uint32_t),
   }
};

RTE_ACL_RULE_DEF(rule, NUM_FIELDS_IPV6);

static const struct rule rules[] = {
        {
                .data.userdata = 1,
                .data.priority = 1,
                .data.category_mask = 1,
                .field[NEXT_HDR_FIELD_IPV6].value.u8 = IPPROTO_ICMPV6,
                .field[NEXT_HDR_FIELD_IPV6].mask_range.u8 = UINT8_MAX,
        },
        {
                .data.userdata = 2,
                .data.priority = 2,
                .data.category_mask = 1,
                .field[NEXT_HDR_FIELD_IPV6].value.u8 = IPPROTO_ICMPV6,
                .field[NEXT_HDR_FIELD_IPV6].mask_range.u8 = UINT8_MAX,
        },
};

static const struct {
        struct ipv6_hdr hdr;
        uint32_t ports;
        uint32_t lif_grp;
        uint32_t addr_ctx;
} data = {
        .hdr = {.proto = IPPROTO_ICMPV6,},
};

static const struct rte_acl_param prm = {
        .name = "xz1",
        .socket_id = SOCKET_ID_ANY,
        .rule_size = RTE_ACL_RULE_SZ(NUM_FIELDS_IPV6),
        .max_rule_num = 256,
};

static void
acl_test1(void)
{
        int32_t rc;
        uint32_t res;
        struct rte_acl_ctx *ctx;
        struct rte_acl_config cfg;
        const uint8_t *dp;

        dp = (const uint8_t *)&data;

        cfg.num_categories = 1;
        cfg.num_fields = RTE_DIM(ipv6_defs);
        memcpy(&cfg.defs, ipv6_defs, sizeof(ipv6_defs));

        ctx = rte_acl_create(&prm);
        assert(ctx != NULL);

        rte_acl_add_rules(ctx, (const struct rte_acl_rule *)&rules[0], 1);
        rte_acl_add_rules(ctx, (const struct rte_acl_rule *)&rules[1], 1);
        rc = rte_acl_build(ctx, &cfg);
        rte_acl_dump(ctx);
        assert(rc == 0);

        rc = rte_acl_classify(ctx, &dp, &res, 1, 1);
        assert(rc == 0);
        assert(res == 2);
        printf("rte_acl_classify() returns %d, res=%u\n", rc, res);

        rte_acl_reset(ctx);
        rte_acl_add_rules(ctx, (const struct rte_acl_rule *)&rules[1], 1);
        rte_acl_add_rules(ctx, (const struct rte_acl_rule *)&rules[0], 1);
        rc = rte_acl_build(ctx, &cfg);
        rte_acl_dump(ctx);
        assert(rc == 0);

        rc = rte_acl_classify(ctx, &dp, &res, 1, 1);
        assert(rc == 0);
        assert(res == 2);
        printf("rte_acl_classify() returns %d, res=%u\n", rc, res);
}

      reply	other threads:[~2014-10-14 15:13 UTC|newest]

Thread overview: 6+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2014-10-14  9:55 Karmarkar Suyash
2014-10-14 10:45 ` Ananyev, Konstantin
2014-10-14 12:36   ` Karmarkar Suyash
2014-10-14 14:44     ` Ananyev, Konstantin
2014-10-14 15:06       ` Karmarkar Suyash
2014-10-14 15:17         ` Ananyev, Konstantin [this message]

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=2601191342CEEE43887BDE71AB9772582139386C@IRSMSX105.ger.corp.intel.com \
    --to=konstantin.ananyev@intel.com \
    --cc=dev@dpdk.org \
    --cc=ppatil@sonusnet.com \
    --cc=skarmarkar@sonusnet.com \
    --cc=sodey@sonusnet.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

DPDK patches and discussions

This inbox may be cloned and mirrored by anyone:

	git clone --mirror https://inbox.dpdk.org/dev/0 dev/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 dev dev/ https://inbox.dpdk.org/dev \
		dev@dpdk.org
	public-inbox-index dev

Example config snippet for mirrors.
Newsgroup available over NNTP:
	nntp://inbox.dpdk.org/inbox.dpdk.dev


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git