Re: [dpdk-dev] Bug in IPACL library of DPDK-1.6.0

["Ananyev, Konstantin" <konstantin.ananyev@intel.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);
}