DPDK patches and discussions
 help / color / Atom feed
From: Gregory Etelson <getelson@nvidia.com>
To: Ajit Khaparde <ajit.khaparde@broadcom.com>
Cc: dpdk-dev <dev@dpdk.org>, Matan Azrad <matan@nvidia.com>,
	Raslan Darawsheh <rasland@nvidia.com>,
	Ori Kam <orika@mellanox.com>, Wenzhuo Lu <wenzhuo.lu@intel.com>,
	Beilei Xing <beilei.xing@intel.com>,
	"Bernard Iremonger" <bernard.iremonger@intel.com>,
	John McNamara <john.mcnamara@intel.com>,
	Marko Kovacevic <marko.kovacevic@intel.com>,
	"Eli Britstein" <elibr@nvidia.com>, Oz Shlomo <ozsh@nvidia.com>
Subject: Re: [dpdk-dev] [PATCH v3 4/4] app/testpmd: add commands for tunnel offload API
Date: Thu, 1 Oct 2020 09:05:00 +0000
Message-ID: <BY5PR12MB366897490E317D44331066AEA5300@BY5PR12MB3668.namprd12.prod.outlook.com> (raw)
In-Reply-To: <CACZ4nhvRYvxB2mSeyiSCv8CXm8adHCxP3SgpbV-fdC-ZQhhTiA@mail.gmail.com>

Hello Ajit,

> -----Original Message-----
> On Wed, Sep 30, 2020 at 2:21 AM Gregory Etelson <getelson@nvidia.com>
> wrote:
> >
> > Tunnel Offload API provides hardware independent, unified model
> > to offload tunneled traffic. Key model elements are:
> >  - apply matches to both outer and inner packet headers
> >    during entire offload procedure;
> >  - restore outer header of partially offloaded packet;
> >  - model is implemented as a set of helper functions.
> >
> > Implementation details:
> >
> > * Create application tunnel:
> > flow tunnel create <port> type <tunnel type>
> > On success, the command creates application tunnel object and returns
> > the tunnel descriptor. Tunnel descriptor is used in subsequent flow
> > creation commands to reference the tunnel.
> >
> > * Create tunnel steering flow rule:
> > tunnel_set <tunnel descriptor> parameter used with steering rule
> > template.
> >
> > * Create tunnel matching flow rule:
> > tunnel_match <tunnel descriptor> used with matching rule template.
> >
> > * If tunnel steering rule was offloaded, outer header of a partially
> > offloaded packet is restored after miss.
> >
> > Example:
> > test packet=
> > <Ether  dst=24:8a:07:8d:ae:d6 src=50:6b:4b:cc:fc:e2 type=IPv4 |
> > <IP  version=4 ihl=5 proto=udp src=1.1.1.1 dst=1.1.1.10 |
> > <UDP  sport=4789 dport=4789 len=58 chksum=0x7f7b |
> > <VXLAN  NextProtocol=Ethernet vni=0x0 |
> > <Ether  dst=24:aa:aa:aa:aa:d6 src=50:bb:bb:bb:bb:e2 type=IPv4 |
> > <IP  version=4 ihl=5 proto=icmp src=2.2.2.2 dst=2.2.2.200 |
> > <ICMP  type=echo-request code=0 chksum=0xf7ff id=0x0 seq=0x0 |>>>>>>>
> > >>> len(packet)
> > 92
> >
> > testpmd> flow flush 0
> > testpmd> port 0/queue 0: received 1 packets
> > src=50:6B:4B:CC:FC:E2 - dst=24:8A:07:8D:AE:D6 - type=0x0800 -
> > length=92
> >
> > testpmd> flow tunnel 0 type vxlan
> > port 0: flow tunnel #1 type vxlan
> > testpmd> flow create 0 ingress group 0 tunnel_set 1
> >          pattern eth /ipv4 / udp dst is 4789 / vxlan / end
> >          actions  jump group 0 / end
> 
> I could not get enough time to completely look at this.
> Can you help understand the sequence a bit.
> 
> So when this flow create is issued, it looks like the application issues
> one of the helper APIs.
> In response the PMD returns the vendor specific items/actions.
> So what happens to the original match and action criteria provided by the
> user
> or applications?
> 
> Does the vendor provided actions and items in the tunnel descriptor
> take precedence over what was used by the application?
> 
> And is the criteria provided by the PMD opaque to the application?
> Such that only the PMD can decipher it when the application calls it
> for subsequent flow create(s)?
> 

Flow rules that implement tunnel offload API are compiled from application and
PMD actions and items. Both application and PMD elements are equally important
for offload rule creation. Application is "aware" what type of tunnel offload
flow rule, decap_set or match, it builds. Therefore, application elements are
created according to tunnel offload rule type and the API helper function, that
matches selected rule type, is activated to provide PMD elements.
PMD elements are opaque. When all elements are present, application concatenates
PMD items with application items and PMD actions with application actions.
As the result application will have pattern & actions arrays for flow rule
creation. For the decap_set rule, the API expects application to provide pattern
that describes a tunnel and the JUMP action, although the JUMP is not strictly
required. And for the match rule, application pattern should describe packet
headers and actions refer to inner parts.

> > Flow rule #0 created
> > testpmd> port 0/queue 0: received 1 packets
> > tunnel restore info: - vxlan tunnel - outer header present # <--
> >   src=50:6B:4B:CC:FC:E2 - dst=24:8A:07:8D:AE:D6 - type=0x0800 -
> > length=92
> >
> > testpmd> flow create 0 ingress group 0 tunnel_match 1
> >          pattern eth / ipv4 / udp dst is 4789 / vxlan / eth / ipv4 /
> >          end
> >          actions set_mac_dst mac_addr 02:CA:FE:CA:FA:80 /
> >          queue index 0 / end
> > Flow rule #1 created
> > testpmd> port 0/queue 0: received 1 packets
> >   src=50:BB:BB:BB:BB:E2 - dst=02:CA:FE:CA:FA:80 - type=0x0800 -
> > length=42
> >
> > * Destroy flow tunnel
> > flow tunnel destroy <port> id <tunnel id>
> >
> > * Show existing flow tunnels
> > flow tunnel list <port>
> >
> > Signed-off-by: Gregory Etelson <getelson@nvidia.com>
> > ---
> > v2:
> > * introduce testpmd support for tunnel offload API
> >
> > v3:
> > * update flow tunnel commands
> > ---
> >  app/test-pmd/cmdline_flow.c                 | 170 ++++++++++++-
> >  app/test-pmd/config.c                       | 253 +++++++++++++++++++-
> >  app/test-pmd/testpmd.c                      |   5 +-
> >  app/test-pmd/testpmd.h                      |  34 ++-
> >  app/test-pmd/util.c                         |  35 ++-
> >  doc/guides/testpmd_app_ug/testpmd_funcs.rst |  49 ++++
> >  6 files changed, 533 insertions(+), 13 deletions(-)
> >
> > diff --git a/app/test-pmd/cmdline_flow.c b/app/test-pmd/cmdline_flow.c
> > index 6263d307ed..0fb61860cd 100644
> > --- a/app/test-pmd/cmdline_flow.c
> > +++ b/app/test-pmd/cmdline_flow.c
> > @@ -69,6 +69,14 @@ enum index {
> >         LIST,
> >         AGED,
> >         ISOLATE,
> > +       TUNNEL,
> > +
> > +       /* Tunnel argumens. */
> > +       TUNNEL_CREATE,
> > +       TUNNEL_CREATE_TYPE,
> > +       TUNNEL_LIST,
> > +       TUNNEL_DESTROY,
> > +       TUNNEL_DESTROY_ID,
> >
> >         /* Destroy arguments. */
> >         DESTROY_RULE,
> > @@ -88,6 +96,8 @@ enum index {
> >         INGRESS,
> >         EGRESS,
> >         TRANSFER,
> > +       TUNNEL_SET,
> > +       TUNNEL_MATCH,
> >
> >         /* Validate/create pattern. */
> >         PATTERN,
> > @@ -653,6 +663,7 @@ struct buffer {
> >         union {
> >                 struct {
> >                         struct rte_flow_attr attr;
> > +                       struct tunnel_ops tunnel_ops;
> >                         struct rte_flow_item *pattern;
> >                         struct rte_flow_action *actions;
> >                         uint32_t pattern_n;
> > @@ -713,10 +724,32 @@ static const enum index next_vc_attr[] = {
> >         INGRESS,
> >         EGRESS,
> >         TRANSFER,
> > +       TUNNEL_SET,
> > +       TUNNEL_MATCH,
> >         PATTERN,
> >         ZERO,
> >  };
> >
> > +static const enum index tunnel_create_attr[] = {
> > +       TUNNEL_CREATE,
> > +       TUNNEL_CREATE_TYPE,
> > +       END,
> > +       ZERO,
> > +};
> > +
> > +static const enum index tunnel_destroy_attr[] = {
> > +       TUNNEL_DESTROY,
> > +       TUNNEL_DESTROY_ID,
> > +       END,
> > +       ZERO,
> > +};
> > +
> > +static const enum index tunnel_list_attr[] = {
> > +       TUNNEL_LIST,
> > +       END,
> > +       ZERO,
> > +};
> > +
> >  static const enum index next_destroy_attr[] = {
> >         DESTROY_RULE,
> >         END,
> > @@ -1516,6 +1549,9 @@ static int parse_aged(struct context *, const
> struct token *,
> >  static int parse_isolate(struct context *, const struct token *,
> >                          const char *, unsigned int,
> >                          void *, unsigned int);
> > +static int parse_tunnel(struct context *, const struct token *,
> > +                       const char *, unsigned int,
> > +                       void *, unsigned int);
> >  static int parse_int(struct context *, const struct token *,
> >                      const char *, unsigned int,
> >                      void *, unsigned int);
> > @@ -1698,7 +1734,8 @@ static const struct token token_list[] = {
> >                               LIST,
> >                               AGED,
> >                               QUERY,
> > -                             ISOLATE)),
> > +                             ISOLATE,
> > +                             TUNNEL)),
> >                 .call = parse_init,
> >         },
> >         /* Sub-level commands. */
> > @@ -1772,6 +1809,49 @@ static const struct token token_list[] = {
> >                              ARGS_ENTRY(struct buffer, port)),
> >                 .call = parse_isolate,
> >         },
> > +       [TUNNEL] = {
> > +               .name = "tunnel",
> > +               .help = "new tunnel API",
> > +               .next = NEXT(NEXT_ENTRY
> > +                            (TUNNEL_CREATE, TUNNEL_LIST, TUNNEL_DESTROY)),
> > +               .call = parse_tunnel,
> > +       },
> > +       /* Tunnel arguments. */
> > +       [TUNNEL_CREATE] = {
> > +               .name = "create",
> > +               .help = "create new tunnel object",
> > +               .next = NEXT(tunnel_create_attr, NEXT_ENTRY(PORT_ID)),
> > +               .args = ARGS(ARGS_ENTRY(struct buffer, port)),
> > +               .call = parse_tunnel,
> > +       },
> > +       [TUNNEL_CREATE_TYPE] = {
> > +               .name = "type",
> > +               .help = "create new tunnel",
> > +               .next = NEXT(tunnel_create_attr, NEXT_ENTRY(FILE_PATH)),
> > +               .args = ARGS(ARGS_ENTRY(struct tunnel_ops, type)),
> > +               .call = parse_tunnel,
> > +       },
> > +       [TUNNEL_DESTROY] = {
> > +               .name = "destroy",
> > +               .help = "destroy tunel",
> > +               .next = NEXT(tunnel_destroy_attr, NEXT_ENTRY(PORT_ID)),
> > +               .args = ARGS(ARGS_ENTRY(struct buffer, port)),
> > +               .call = parse_tunnel,
> > +       },
> > +       [TUNNEL_DESTROY_ID] = {
> > +               .name = "id",
> > +               .help = "tunnel identifier to testroy",
> > +               .next = NEXT(tunnel_destroy_attr, NEXT_ENTRY(UNSIGNED)),
> > +               .args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)),
> > +               .call = parse_tunnel,
> > +       },
> > +       [TUNNEL_LIST] = {
> > +               .name = "list",
> > +               .help = "list existing tunnels",
> > +               .next = NEXT(tunnel_list_attr, NEXT_ENTRY(PORT_ID)),
> > +               .args = ARGS(ARGS_ENTRY(struct buffer, port)),
> > +               .call = parse_tunnel,
> > +       },
> >         /* Destroy arguments. */
> >         [DESTROY_RULE] = {
> >                 .name = "rule",
> > @@ -1835,6 +1915,20 @@ static const struct token token_list[] = {
> >                 .next = NEXT(next_vc_attr),
> >                 .call = parse_vc,
> >         },
> > +       [TUNNEL_SET] = {
> > +               .name = "tunnel_set",
> > +               .help = "tunnel steer rule",
> > +               .next = NEXT(next_vc_attr, NEXT_ENTRY(UNSIGNED)),
> > +               .args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)),
> > +               .call = parse_vc,
> > +       },
> > +       [TUNNEL_MATCH] = {
> > +               .name = "tunnel_match",
> > +               .help = "tunnel match rule",
> > +               .next = NEXT(next_vc_attr, NEXT_ENTRY(UNSIGNED)),
> > +               .args = ARGS(ARGS_ENTRY(struct tunnel_ops, id)),
> > +               .call = parse_vc,
> > +       },
> >         /* Validate/create pattern. */
> >         [PATTERN] = {
> >                 .name = "pattern",
> > @@ -4054,12 +4148,28 @@ parse_vc(struct context *ctx, const struct
> token *token,
> >                 return len;
> >         }
> >         ctx->objdata = 0;
> > -       ctx->object = &out->args.vc.attr;
> > +       switch (ctx->curr) {
> > +       default:
> > +               ctx->object = &out->args.vc.attr;
> > +               break;
> > +       case TUNNEL_SET:
> > +       case TUNNEL_MATCH:
> > +               ctx->object = &out->args.vc.tunnel_ops;
> > +               break;
> > +       }
> >         ctx->objmask = NULL;
> >         switch (ctx->curr) {
> >         case GROUP:
> >         case PRIORITY:
> >                 return len;
> > +       case TUNNEL_SET:
> > +               out->args.vc.tunnel_ops.enabled = 1;
> > +               out->args.vc.tunnel_ops.actions = 1;
> > +               return len;
> > +       case TUNNEL_MATCH:
> > +               out->args.vc.tunnel_ops.enabled = 1;
> > +               out->args.vc.tunnel_ops.items = 1;
> > +               return len;
> >         case INGRESS:
> >                 out->args.vc.attr.ingress = 1;
> >                 return len;
> > @@ -5597,6 +5707,47 @@ parse_isolate(struct context *ctx, const struct
> token *token,
> >         return len;
> >  }
> >
> > +static int
> > +parse_tunnel(struct context *ctx, const struct token *token,
> > +            const char *str, unsigned int len,
> > +            void *buf, unsigned int size)
> > +{
> > +       struct buffer *out = buf;
> > +
> > +       /* Token name must match. */
> > +       if (parse_default(ctx, token, str, len, NULL, 0) < 0)
> > +               return -1;
> > +       /* Nothing else to do if there is no buffer. */
> > +       if (!out)
> > +               return len;
> > +       if (!out->command) {
> > +               if (ctx->curr != TUNNEL)
> > +                       return -1;
> > +               if (sizeof(*out) > size)
> > +                       return -1;
> > +               out->command = ctx->curr;
> > +               ctx->objdata = 0;
> > +               ctx->object = out;
> > +               ctx->objmask = NULL;
> > +       } else {
> > +               switch (ctx->curr) {
> > +               default:
> > +                       break;
> > +               case TUNNEL_CREATE:
> > +               case TUNNEL_DESTROY:
> > +               case TUNNEL_LIST:
> > +                       out->command = ctx->curr;
> > +                       break;
> > +               case TUNNEL_CREATE_TYPE:
> > +               case TUNNEL_DESTROY_ID:
> > +                       ctx->object = &out->args.vc.tunnel_ops;
> > +                       break;
> > +               }
> > +       }
> > +
> > +       return len;
> > +}
> > +
> >  /**
> >   * Parse signed/unsigned integers 8 to 64-bit long.
> >   *
> > @@ -6543,11 +6694,13 @@ cmd_flow_parsed(const struct buffer *in)
> >         switch (in->command) {
> >         case VALIDATE:
> >                 port_flow_validate(in->port, &in->args.vc.attr,
> > -                                  in->args.vc.pattern, in->args.vc.actions);
> > +                                  in->args.vc.pattern, in->args.vc.actions,
> > +                                  &in->args.vc.tunnel_ops);
> >                 break;
> >         case CREATE:
> >                 port_flow_create(in->port, &in->args.vc.attr,
> > -                                in->args.vc.pattern, in->args.vc.actions);
> > +                                in->args.vc.pattern, in->args.vc.actions,
> > +                                &in->args.vc.tunnel_ops);
> >                 break;
> >         case DESTROY:
> >                 port_flow_destroy(in->port, in->args.destroy.rule_n,
> > @@ -6573,6 +6726,15 @@ cmd_flow_parsed(const struct buffer *in)
> >         case AGED:
> >                 port_flow_aged(in->port, in->args.aged.destroy);
> >                 break;
> > +       case TUNNEL_CREATE:
> > +               port_flow_tunnel_create(in->port, &in->args.vc.tunnel_ops);
> > +               break;
> > +       case TUNNEL_DESTROY:
> > +               port_flow_tunnel_destroy(in->port, in->args.vc.tunnel_ops.id);
> > +               break;
> > +       case TUNNEL_LIST:
> > +               port_flow_tunnel_list(in->port);
> > +               break;
> >         default:
> >                 break;
> >         }
> > diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c
> > index 2d9a456467..d0f86230d0 100644
> > --- a/app/test-pmd/config.c
> > +++ b/app/test-pmd/config.c
> > @@ -1339,6 +1339,115 @@ port_mtu_set(portid_t port_id, uint16_t mtu)
> >
> >  /* Generic flow management functions. */
> >
> > +static struct port_flow_tunnel *
> > +port_flow_locate_tunnel_id(struct rte_port *port, uint32_t
> port_tunnel_id)
> > +{
> > +       struct port_flow_tunnel *flow_tunnel;
> > +
> > +       LIST_FOREACH(flow_tunnel, &port->flow_tunnel_list, chain) {
> > +               if (flow_tunnel->id == port_tunnel_id)
> > +                       goto out;
> > +       }
> > +       flow_tunnel = NULL;
> > +
> > +out:
> > +       return flow_tunnel;
> > +}
> > +
> > +const char *
> > +port_flow_tunnel_type(struct rte_flow_tunnel *tunnel)
> > +{
> > +       const char *type;
> > +       switch (tunnel->type) {
> > +       default:
> > +               type = "unknown";
> > +               break;
> > +       case RTE_FLOW_ITEM_TYPE_VXLAN:
> > +               type = "vxlan";
> > +               break;
> > +       }
> > +
> > +       return type;
> > +}
> > +
> > +struct port_flow_tunnel *
> > +port_flow_locate_tunnel(uint16_t port_id, struct rte_flow_tunnel *tun)
> > +{
> > +       struct rte_port *port = &ports[port_id];
> > +       struct port_flow_tunnel *flow_tunnel;
> > +
> > +       LIST_FOREACH(flow_tunnel, &port->flow_tunnel_list, chain) {
> > +               if (!memcmp(&flow_tunnel->tunnel, tun, sizeof(*tun)))
> > +                       goto out;
> > +       }
> > +       flow_tunnel = NULL;
> > +
> > +out:
> > +       return flow_tunnel;
> > +}
> > +
> > +void port_flow_tunnel_list(portid_t port_id)
> > +{
> > +       struct rte_port *port = &ports[port_id];
> > +       struct port_flow_tunnel *flt;
> > +
> > +       LIST_FOREACH(flt, &port->flow_tunnel_list, chain) {
> > +               printf("port %u tunnel #%u type=%s",
> > +                       port_id, flt->id, port_flow_tunnel_type(&flt->tunnel));
> > +               if (flt->tunnel.tun_id)
> > +                       printf(" id=%lu", flt->tunnel.tun_id);
> > +               printf("\n");
> > +       }
> > +}
> > +
> > +void port_flow_tunnel_destroy(portid_t port_id, uint32_t tunnel_id)
> > +{
> > +       struct rte_port *port = &ports[port_id];
> > +       struct port_flow_tunnel *flt;
> > +
> > +       LIST_FOREACH(flt, &port->flow_tunnel_list, chain) {
> > +               if (flt->id == tunnel_id)
> > +                       break;
> > +       }
> > +       if (flt) {
> > +               LIST_REMOVE(flt, chain);
> > +               free(flt);
> > +               printf("port %u: flow tunnel #%u destroyed\n",
> > +                       port_id, tunnel_id);
> > +       }
> > +}
> > +
> > +void port_flow_tunnel_create(portid_t port_id, const struct tunnel_ops
> *ops)
> > +{
> > +       struct rte_port *port = &ports[port_id];
> > +       enum rte_flow_item_type type;
> > +       struct port_flow_tunnel *flt;
> > +
> > +       if (!strcmp(ops->type, "vxlan"))
> > +               type = RTE_FLOW_ITEM_TYPE_VXLAN;
> > +       else {
> > +               printf("cannot offload \"%s\" tunnel type\n", ops->type);
> > +               return;
> > +       }
> > +       LIST_FOREACH(flt, &port->flow_tunnel_list, chain) {
> > +               if (flt->tunnel.type == type)
> > +                       break;
> > +       }
> > +       if (!flt) {
> > +               flt = calloc(1, sizeof(*flt));
> > +               if (!flt) {
> > +                       printf("failed to allocate port flt object\n");
> > +                       return;
> > +               }
> > +               flt->tunnel.type = type;
> > +               flt->id = LIST_EMPTY(&port->flow_tunnel_list) ? 1 :
> > +                                 LIST_FIRST(&port->flow_tunnel_list)->id + 1;
> > +               LIST_INSERT_HEAD(&port->flow_tunnel_list, flt, chain);
> > +       }
> > +       printf("port %d: flow tunnel #%u type %s\n",
> > +               port_id, flt->id, ops->type);
> > +}
> > +
> >  /** Generate a port_flow entry from attributes/pattern/actions. */
> >  static struct port_flow *
> >  port_flow_new(const struct rte_flow_attr *attr,
> > @@ -1463,19 +1572,137 @@ rss_config_display(struct rte_flow_action_rss
> *rss_conf)
> >         }
> >  }
> >
> > +static struct port_flow_tunnel *
> > +port_flow_tunnel_offload_cmd_prep(portid_t port_id,
> > +                                 const struct rte_flow_item *pattern,
> > +                                 const struct rte_flow_action *actions,
> > +                                 const struct tunnel_ops *tunnel_ops)
> > +{
> > +       int ret;
> > +       struct rte_port *port;
> > +       struct port_flow_tunnel *pft;
> > +       struct rte_flow_error error;
> > +
> > +       port = &ports[port_id];
> > +       pft = port_flow_locate_tunnel_id(port, tunnel_ops->id);
> > +       if (!pft) {
> > +               printf("failed to locate port flow tunnel #%u\n",
> > +                       tunnel_ops->id);
> > +               return NULL;
> > +       }
> > +       if (tunnel_ops->actions) {
> > +               uint32_t num_actions;
> > +               const struct rte_flow_action *aptr;
> > +
> > +               ret = rte_flow_tunnel_decap_set(port_id, &pft->tunnel,
> > +                                               &pft->pmd_actions,
> > +                                               &pft->num_pmd_actions,
> > +                                               &error);
> > +               if (ret) {
> > +                       port_flow_complain(&error);
> > +                       return NULL;
> > +               }
> > +               for (aptr = actions, num_actions = 1;
> > +                    aptr->type != RTE_FLOW_ACTION_TYPE_END;
> > +                    aptr++, num_actions++);
> > +               pft->actions = malloc(
> > +                               (num_actions +  pft->num_pmd_actions) *
> > +                               sizeof(actions[0]));
> > +               if (!pft->actions) {
> > +                       rte_flow_tunnel_action_decap_release(
> > +                                       port_id, pft->actions,
> > +                                       pft->num_pmd_actions, &error);
> > +                       return NULL;
> > +               }
> > +               rte_memcpy(pft->actions, pft->pmd_actions,
> > +                          pft->num_pmd_actions * sizeof(actions[0]));
> > +               rte_memcpy(pft->actions + pft->num_pmd_actions, actions,
> > +                          num_actions * sizeof(actions[0]));
> > +       }
> > +       if (tunnel_ops->items) {
> > +               uint32_t num_items;
> > +               const struct rte_flow_item *iptr;
> > +
> > +               ret = rte_flow_tunnel_match(port_id, &pft->tunnel,
> > +                                           &pft->pmd_items,
> > +                                           &pft->num_pmd_items,
> > +                                           &error);
> > +               if (ret) {
> > +                       port_flow_complain(&error);
> > +                       return NULL;
> > +               }
> > +               for (iptr = pattern, num_items = 1;
> > +                    iptr->type != RTE_FLOW_ITEM_TYPE_END;
> > +                    iptr++, num_items++);
> > +               pft->items = malloc((num_items + pft->num_pmd_items) *
> > +                                   sizeof(pattern[0]));
> > +               if (!pft->items) {
> > +                       rte_flow_tunnel_item_release(
> > +                                       port_id, pft->pmd_items,
> > +                                       pft->num_pmd_items, &error);
> > +                       return NULL;
> > +               }
> > +               rte_memcpy(pft->items, pft->pmd_items,
> > +                          pft->num_pmd_items * sizeof(pattern[0]));
> > +               rte_memcpy(pft->items + pft->num_pmd_items, pattern,
> > +                          num_items * sizeof(pattern[0]));
> > +       }
> > +
> > +       return pft;
> > +}
> > +
> > +static void
> > +port_flow_tunnel_offload_cmd_release(portid_t port_id,
> > +                                    const struct tunnel_ops *tunnel_ops,
> > +                                    struct port_flow_tunnel *pft)
> > +{
> > +       struct rte_flow_error error;
> > +
> > +       if (tunnel_ops->actions) {
> > +               free(pft->actions);
> > +               rte_flow_tunnel_action_decap_release(
> > +                       port_id, pft->pmd_actions,
> > +                       pft->num_pmd_actions, &error);
> > +               pft->actions = NULL;
> > +               pft->pmd_actions = NULL;
> > +       }
> > +       if (tunnel_ops->items) {
> > +               free(pft->items);
> > +               rte_flow_tunnel_item_release(port_id, pft->pmd_items,
> > +                                            pft->num_pmd_items,
> > +                                            &error);
> > +               pft->items = NULL;
> > +               pft->pmd_items = NULL;
> > +       }
> > +}
> > +
> >  /** Validate flow rule. */
> >  int
> >  port_flow_validate(portid_t port_id,
> >                    const struct rte_flow_attr *attr,
> >                    const struct rte_flow_item *pattern,
> > -                  const struct rte_flow_action *actions)
> > +                  const struct rte_flow_action *actions,
> > +                  const struct tunnel_ops *tunnel_ops)
> >  {
> >         struct rte_flow_error error;
> > +       struct port_flow_tunnel *pft = NULL;
> >
> >         /* Poisoning to make sure PMDs update it in case of error. */
> >         memset(&error, 0x11, sizeof(error));
> > +       if (tunnel_ops->enabled) {
> > +               pft = port_flow_tunnel_offload_cmd_prep(port_id, pattern,
> > +                                                       actions, tunnel_ops);
> > +               if (!pft)
> > +                       return -ENOENT;
> > +               if (pft->items)
> > +                       pattern = pft->items;
> > +               if (pft->actions)
> > +                       actions = pft->actions;
> > +       }
> >         if (rte_flow_validate(port_id, attr, pattern, actions, &error))
> >                 return port_flow_complain(&error);
> > +       if (tunnel_ops->enabled)
> > +               port_flow_tunnel_offload_cmd_release(port_id, tunnel_ops, pft);
> >         printf("Flow rule validated\n");
> >         return 0;
> >  }
> > @@ -1505,13 +1732,15 @@ int
> >  port_flow_create(portid_t port_id,
> >                  const struct rte_flow_attr *attr,
> >                  const struct rte_flow_item *pattern,
> > -                const struct rte_flow_action *actions)
> > +                const struct rte_flow_action *actions,
> > +                const struct tunnel_ops *tunnel_ops)
> >  {
> >         struct rte_flow *flow;
> >         struct rte_port *port;
> >         struct port_flow *pf;
> >         uint32_t id = 0;
> >         struct rte_flow_error error;
> > +       struct port_flow_tunnel *pft = NULL;
> >
> >         port = &ports[port_id];
> >         if (port->flow_list) {
> > @@ -1522,6 +1751,16 @@ port_flow_create(portid_t port_id,
> >                 }
> >                 id = port->flow_list->id + 1;
> >         }
> > +       if (tunnel_ops->enabled) {
> > +               pft = port_flow_tunnel_offload_cmd_prep(port_id, pattern,
> > +                                                       actions, tunnel_ops);
> > +               if (!pft)
> > +                       return -ENOENT;
> > +               if (pft->items)
> > +                       pattern = pft->items;
> > +               if (pft->actions)
> > +                       actions = pft->actions;
> > +       }
> >         pf = port_flow_new(attr, pattern, actions, &error);
> >         if (!pf)
> >                 return port_flow_complain(&error);
> > @@ -1537,6 +1776,8 @@ port_flow_create(portid_t port_id,
> >         pf->id = id;
> >         pf->flow = flow;
> >         port->flow_list = pf;
> > +       if (tunnel_ops->enabled)
> > +               port_flow_tunnel_offload_cmd_release(port_id, tunnel_ops, pft);
> >         printf("Flow rule #%u created\n", pf->id);
> >         return 0;
> >  }
> > @@ -1831,7 +2072,9 @@ port_flow_list(portid_t port_id, uint32_t n, const
> uint32_t group[n])
> >                        pf->rule.attr->egress ? 'e' : '-',
> >                        pf->rule.attr->transfer ? 't' : '-');
> >                 while (item->type != RTE_FLOW_ITEM_TYPE_END) {
> > -                       if (rte_flow_conv(RTE_FLOW_CONV_OP_ITEM_NAME_PTR,
> > +                       if ((uint32_t)item->type > INT_MAX)
> > +                               name = "PMD_INTERNAL";
> > +                       else if
> (rte_flow_conv(RTE_FLOW_CONV_OP_ITEM_NAME_PTR,
> >                                           &name, sizeof(name),
> >                                           (void *)(uintptr_t)item->type,
> >                                           NULL) <= 0)
> > @@ -1842,7 +2085,9 @@ port_flow_list(portid_t port_id, uint32_t n, const
> uint32_t group[n])
> >                 }
> >                 printf("=>");
> >                 while (action->type != RTE_FLOW_ACTION_TYPE_END) {
> > -                       if (rte_flow_conv(RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
> > +                       if ((uint32_t)action->type > INT_MAX)
> > +                               name = "PMD_INTERNAL";
> > +                       else if
> (rte_flow_conv(RTE_FLOW_CONV_OP_ACTION_NAME_PTR,
> >                                           &name, sizeof(name),
> >                                           (void *)(uintptr_t)action->type,
> >                                           NULL) <= 0)
> > diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c
> > index fe6450cc0d..e484079147 100644
> > --- a/app/test-pmd/testpmd.c
> > +++ b/app/test-pmd/testpmd.c
> > @@ -3588,6 +3588,8 @@ init_port_dcb_config(portid_t pid,
> >  static void
> >  init_port(void)
> >  {
> > +       int i;
> > +
> >         /* Configuration of Ethernet ports. */
> >         ports = rte_zmalloc("testpmd: ports",
> >                             sizeof(struct rte_port) * RTE_MAX_ETHPORTS,
> > @@ -3597,7 +3599,8 @@ init_port(void)
> >                                 "rte_zmalloc(%d struct rte_port) failed\n",
> >                                 RTE_MAX_ETHPORTS);
> >         }
> > -
> > +       for (i = 0; i < RTE_MAX_ETHPORTS; i++)
> > +               LIST_INIT(&ports[i].flow_tunnel_list);
> >         /* Initialize ports NUMA structures */
> >         memset(port_numa, NUMA_NO_CONFIG, RTE_MAX_ETHPORTS);
> >         memset(rxring_numa, NUMA_NO_CONFIG, RTE_MAX_ETHPORTS);
> > diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h
> > index f139fe7a0a..1dd8cfd3d8 100644
> > --- a/app/test-pmd/testpmd.h
> > +++ b/app/test-pmd/testpmd.h
> > @@ -12,6 +12,7 @@
> >  #include <rte_gro.h>
> >  #include <rte_gso.h>
> >  #include <cmdline.h>
> > +#include <sys/queue.h>
> >
> >  #define RTE_PORT_ALL            (~(portid_t)0x0)
> >
> > @@ -142,6 +143,26 @@ struct port_flow {
> >         uint8_t data[]; /**< Storage for flow rule description */
> >  };
> >
> > +struct port_flow_tunnel {
> > +       LIST_ENTRY(port_flow_tunnel) chain;
> > +       struct rte_flow_action *pmd_actions;
> > +       struct rte_flow_item   *pmd_items;
> > +       uint32_t id;
> > +       uint32_t num_pmd_actions;
> > +       uint32_t num_pmd_items;
> > +       struct rte_flow_tunnel tunnel;
> > +       struct rte_flow_action *actions;
> > +       struct rte_flow_item *items;
> > +};
> > +
> > +struct tunnel_ops {
> > +       uint32_t id;
> > +       char type[16];
> > +       uint32_t enabled:1;
> > +       uint32_t actions:1;
> > +       uint32_t items:1;
> > +};
> > +
> >  /**
> >   * The data structure associated with each port.
> >   */
> > @@ -172,6 +193,7 @@ struct rte_port {
> >         uint32_t                mc_addr_nb; /**< nb. of addr. in mc_addr_pool */
> >         uint8_t                 slave_flag; /**< bonding slave port */
> >         struct port_flow        *flow_list; /**< Associated flows. */
> > +       LIST_HEAD(, port_flow_tunnel) flow_tunnel_list;
> >         const struct rte_eth_rxtx_callback
> *rx_dump_cb[RTE_MAX_QUEUES_PER_PORT+1];
> >         const struct rte_eth_rxtx_callback
> *tx_dump_cb[RTE_MAX_QUEUES_PER_PORT+1];
> >         /**< metadata value to insert in Tx packets. */
> > @@ -749,11 +771,13 @@ void port_reg_set(portid_t port_id, uint32_t
> reg_off, uint32_t value);
> >  int port_flow_validate(portid_t port_id,
> >                        const struct rte_flow_attr *attr,
> >                        const struct rte_flow_item *pattern,
> > -                      const struct rte_flow_action *actions);
> > +                      const struct rte_flow_action *actions,
> > +                      const struct tunnel_ops *tunnel_ops);
> >  int port_flow_create(portid_t port_id,
> >                      const struct rte_flow_attr *attr,
> >                      const struct rte_flow_item *pattern,
> > -                    const struct rte_flow_action *actions);
> > +                    const struct rte_flow_action *actions,
> > +                    const struct tunnel_ops *tunnel_ops);
> >  void update_age_action_context(const struct rte_flow_action *actions,
> >                      struct port_flow *pf);
> >  int port_flow_destroy(portid_t port_id, uint32_t n, const uint32_t *rule);
> > @@ -763,6 +787,12 @@ int port_flow_query(portid_t port_id, uint32_t
> rule,
> >                     const struct rte_flow_action *action);
> >  void port_flow_list(portid_t port_id, uint32_t n, const uint32_t *group);
> >  void port_flow_aged(portid_t port_id, uint8_t destroy);
> > +const char *port_flow_tunnel_type(struct rte_flow_tunnel *tunnel);
> > +struct port_flow_tunnel *
> > +port_flow_locate_tunnel(uint16_t port_id, struct rte_flow_tunnel *tun);
> > +void port_flow_tunnel_list(portid_t port_id);
> > +void port_flow_tunnel_destroy(portid_t port_id, uint32_t tunnel_id);
> > +void port_flow_tunnel_create(portid_t port_id, const struct tunnel_ops
> *ops);
> >  int port_flow_isolate(portid_t port_id, int set);
> >
> >  void rx_ring_desc_display(portid_t port_id, queueid_t rxq_id, uint16_t
> rxd_id);
> > diff --git a/app/test-pmd/util.c b/app/test-pmd/util.c
> > index 8488fa1a8f..781a813759 100644
> > --- a/app/test-pmd/util.c
> > +++ b/app/test-pmd/util.c
> > @@ -48,18 +48,49 @@ dump_pkt_burst(uint16_t port_id, uint16_t queue,
> struct rte_mbuf *pkts[],
> >                is_rx ? "received" : "sent",
> >                (unsigned int) nb_pkts);
> >         for (i = 0; i < nb_pkts; i++) {
> > +               int ret;
> > +               struct rte_flow_error error;
> > +               struct rte_flow_restore_info info = { 0, };
> > +
> >                 mb = pkts[i];
> >                 eth_hdr = rte_pktmbuf_read(mb, 0, sizeof(_eth_hdr), &_eth_hdr);
> >                 eth_type = RTE_BE_TO_CPU_16(eth_hdr->ether_type);
> > -               ol_flags = mb->ol_flags;
> >                 packet_type = mb->packet_type;
> >                 is_encapsulation = RTE_ETH_IS_TUNNEL_PKT(packet_type);
> > -
> > +               ret = rte_flow_get_restore_info(port_id, mb, &info, &error);
> > +               if (!ret) {
> > +                       printf("restore info:");
> > +                       if (info.flags & RTE_FLOW_RESTORE_INFO_TUNNEL) {
> > +                               struct port_flow_tunnel *port_tunnel;
> > +
> > +                               port_tunnel = port_flow_locate_tunnel
> > +                                             (port_id, &info.tunnel);
> > +                               printf(" - tunnel");
> > +                               if (port_tunnel)
> > +                                       printf(" #%u", port_tunnel->id);
> > +                               else
> > +                                       printf(" %s", "-none-");
> > +                               printf(" type %s",
> > +                                       port_flow_tunnel_type(&info.tunnel));
> > +                       } else {
> > +                               printf(" - no tunnel info");
> > +                       }
> > +                       if (info.flags & RTE_FLOW_RESTORE_INFO_ENCAPSULATED)
> > +                               printf(" - outer header present");
> > +                       else
> > +                               printf(" - no outer header");
> > +                       if (info.flags & RTE_FLOW_RESTORE_INFO_GROUP_ID)
> > +                               printf(" - miss group %u", info.group_id);
> > +                       else
> > +                               printf(" - no miss group");
> > +                       printf("\n");
> > +               }
> >                 print_ether_addr("  src=", &eth_hdr->s_addr);
> >                 print_ether_addr(" - dst=", &eth_hdr->d_addr);
> >                 printf(" - type=0x%04x - length=%u - nb_segs=%d",
> >                        eth_type, (unsigned int) mb->pkt_len,
> >                        (int)mb->nb_segs);
> > +               ol_flags = mb->ol_flags;
> >                 if (ol_flags & PKT_RX_RSS_HASH) {
> >                         printf(" - RSS hash=0x%x", (unsigned int) mb->hash.rss);
> >                         printf(" - RSS queue=0x%x", (unsigned int) queue);
> > diff --git a/doc/guides/testpmd_app_ug/testpmd_funcs.rst
> b/doc/guides/testpmd_app_ug/testpmd_funcs.rst
> > index a972ef8951..97fcbfd329 100644
> > --- a/doc/guides/testpmd_app_ug/testpmd_funcs.rst
> > +++ b/doc/guides/testpmd_app_ug/testpmd_funcs.rst
> > @@ -3720,6 +3720,45 @@ following sections.
> >
> >     flow aged {port_id} [destroy]
> >
> > +- Tunnel offload - create a tunnel stub::
> > +
> > +   flow tunnel create {port_id} type {tunnel_type}
> > +
> > +- Tunnel offload - destroy a tunnel stub::
> > +
> > +   flow tunnel destroy {port_id} id {tunnel_id}
> > +
> > +- Tunnel offload - list port tunnel stubs::
> > +
> > +   flow tunnel list {port_id}
> > +
> > +Creating a tunnel stub for offload
> > +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> > +
> > +``flow tunnel create`` setup a tunnel stub for tunnel offload flow rules::
> > +
> > +   flow tunnel create {port_id} type {tunnel_type}
> > +
> > +If successful, it will return a tunnel stub ID usable with other commands::
> > +
> > +   port [...]: flow tunnel #[...] type [...]
> > +
> > +Tunnel stub ID is relative to a port.
> > +
> > +Destroying tunnel offload stub
> > +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> > +
> > +``flow tunnel destroy`` destroy port tunnel stub::
> > +
> > +   flow tunnel destroy {port_id} id {tunnel_id}
> > +
> > +Listing tunnel offload stubs
> > +~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> > +
> > +``flow tunnel list`` list port tunnel offload stubs::
> > +
> > +   flow tunnel list {port_id}
> > +
> >  Validating flow rules
> >  ~~~~~~~~~~~~~~~~~~~~~
> >
> > @@ -3766,6 +3805,7 @@ to ``rte_flow_create()``::
> >
> >     flow create {port_id}
> >        [group {group_id}] [priority {level}] [ingress] [egress] [transfer]
> > +      [tunnel_set {tunnel_id}] [tunnel_match {tunnel_id}]
> >        pattern {item} [/ {item} [...]] / end
> >        actions {action} [/ {action} [...]] / end
> >
> > @@ -3780,6 +3820,7 @@ Otherwise it will show an error message of the
> form::
> >  Parameters describe in the following order:
> >
> >  - Attributes (*group*, *priority*, *ingress*, *egress*, *transfer* tokens).
> > +- Tunnel offload specification (tunnel_set, tunnel_match)
> >  - A matching pattern, starting with the *pattern* token and terminated by
> an
> >    *end* pattern item.
> >  - Actions, starting with the *actions* token and terminated by an *end*
> > @@ -3823,6 +3864,14 @@ Most rules affect RX therefore contain the
> ``ingress`` token::
> >
> >     testpmd> flow create 0 ingress pattern [...]
> >
> > +Tunnel offload
> > +^^^^^^^^^^^^^^
> > +
> > +Indicate tunnel offload rule type
> > +
> > +- ``tunnel_set {tunnel_id}``: mark rule as tunnel offload decap_set type.
> > +- ``tunnel_match {tunnel_id}``:  mark rule as tunel offload match type.
> > +
> >  Matching pattern
> >  ^^^^^^^^^^^^^^^^
> >
> > --
> > 2.25.1
> >

  reply index

Thread overview: 90+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2020-06-25 16:03 [dpdk-dev] [PATCH 0/2] ethdev: tunnel offload model Gregory Etelson
2020-06-25 16:03 ` [dpdk-dev] [PATCH 1/2] ethdev: allow negative values in flow rule types Gregory Etelson
2020-07-05 13:34   ` Andrew Rybchenko
2020-08-19 14:33     ` Gregory Etelson
2020-06-25 16:03 ` [dpdk-dev] [PATCH 2/2] ethdev: tunnel offload model Gregory Etelson
     [not found]   ` <DB8PR05MB6761ED02BCD188771BDCDE64A86F0@DB8PR05MB6761.eurprd05.prod.outlook.com>
     [not found]     ` <38d3513f-1261-0fbc-7c56-f83ced61f97a@ashroe.eu>
2020-07-01  6:52       ` Gregory Etelson
2020-07-13  8:21         ` Thomas Monjalon
2020-07-13 13:23           ` Gregory Etelson
2020-07-05 14:50   ` Andrew Rybchenko
2020-08-19 14:30     ` Gregory Etelson
2020-07-05 13:39 ` [dpdk-dev] [PATCH 0/2] " Andrew Rybchenko
2020-09-08 20:15 ` [dpdk-dev] [PATCH v2 0/4] Tunnel Offload API Gregory Etelson
2020-09-08 20:15   ` [dpdk-dev] [PATCH v2 1/4] ethdev: allow negative values in flow rule types Gregory Etelson
2020-09-15  4:36     ` Ajit Khaparde
2020-09-15  8:46       ` Andrew Rybchenko
2020-09-15 10:27         ` Gregory Etelson
2020-09-16 17:21           ` Gregory Etelson
2020-09-17  6:49             ` Andrew Rybchenko
2020-09-17  7:47               ` Ori Kam
2020-09-17 15:15                 ` Andrew Rybchenko
2020-09-17  7:56               ` Gregory Etelson
2020-09-17 15:18                 ` Andrew Rybchenko
2020-09-15  8:45     ` Andrew Rybchenko
2020-09-15 16:17       ` Gregory Etelson
2020-09-08 20:15   ` [dpdk-dev] [PATCH v2 2/4] ethdev: tunnel offload model Gregory Etelson
2020-09-08 20:15   ` [dpdk-dev] [PATCH v2 3/4] net/mlx5: implement tunnel offload API Gregory Etelson
2020-09-08 20:15   ` [dpdk-dev] [PATCH v2 4/4] app/testpmd: support " Gregory Etelson
2020-09-15  4:47     ` Ajit Khaparde
2020-09-15 10:44       ` Gregory Etelson
2020-09-30  9:18 ` [dpdk-dev] [PATCH v3 0/4] Tunnel Offload API Gregory Etelson
2020-09-30  9:18   ` [dpdk-dev] [PATCH v3 1/4] ethdev: allow negative values in flow rule types Gregory Etelson
2020-10-04  5:40     ` Ajit Khaparde
2020-10-04  9:24       ` Gregory Etelson
2020-09-30  9:18   ` [dpdk-dev] [PATCH v3 2/4] ethdev: tunnel offload model Gregory Etelson
2020-09-30  9:18   ` [dpdk-dev] [PATCH v3 3/4] net/mlx5: implement tunnel offload API Gregory Etelson
2020-09-30  9:18   ` [dpdk-dev] [PATCH v3 4/4] app/testpmd: add commands for " Gregory Etelson
2020-10-01  5:32     ` Ajit Khaparde
2020-10-01  9:05       ` Gregory Etelson [this message]
2020-10-04  5:40         ` Ajit Khaparde
2020-10-04  9:29           ` Gregory Etelson
2020-10-04 13:50 ` [dpdk-dev] [PATCH v4 0/4] Tunnel Offload API Gregory Etelson
2020-10-04 13:50   ` [dpdk-dev] [PATCH v4 1/4] ethdev: allow negative values in flow rule types Gregory Etelson
2020-10-14 23:40     ` Thomas Monjalon
2020-10-04 13:50   ` [dpdk-dev] [PATCH v4 2/4] ethdev: tunnel offload model Gregory Etelson
2020-10-06  9:47     ` Sriharsha Basavapatna
2020-10-07 12:36       ` Gregory Etelson
2020-10-14 17:23         ` Ferruh Yigit
2020-10-16  9:15           ` Gregory Etelson
2020-10-14 23:55     ` Thomas Monjalon
2020-10-04 13:50   ` [dpdk-dev] [PATCH v4 3/4] net/mlx5: implement tunnel offload API Gregory Etelson
2020-10-04 13:50   ` [dpdk-dev] [PATCH v4 4/4] app/testpmd: add commands for " Gregory Etelson
2020-10-04 13:59     ` Ori Kam
2020-10-14 17:25   ` [dpdk-dev] [PATCH v4 0/4] Tunnel Offload API Ferruh Yigit
2020-10-15 12:41 ` [dpdk-dev] [PATCH v5 0/3] " Gregory Etelson
2020-10-15 12:41   ` [dpdk-dev] [PATCH v5 1/3] ethdev: allow negative values in flow rule types Gregory Etelson
2020-10-15 12:41   ` [dpdk-dev] [PATCH v5 2/3] ethdev: tunnel offload model Gregory Etelson
2020-10-15 12:41   ` [dpdk-dev] [PATCH v5 3/3] app/testpmd: add commands for tunnel offload API Gregory Etelson
2020-10-15 22:47   ` [dpdk-dev] [PATCH v5 0/3] Tunnel Offload API Ferruh Yigit
2020-10-16  8:55 ` [dpdk-dev] [PATCH v6 " Gregory Etelson
2020-10-16  8:55   ` [dpdk-dev] [PATCH v6 1/3] ethdev: allow negative values in flow rule types Gregory Etelson
2020-10-16  8:55   ` [dpdk-dev] [PATCH v6 2/3] ethdev: tunnel offload model Gregory Etelson
2020-10-16  8:55   ` [dpdk-dev] [PATCH v6 3/3] app/testpmd: add commands for tunnel offload API Gregory Etelson
2020-10-16 10:33 ` [dpdk-dev] [PATCH v7 0/3] Tunnel Offload API Gregory Etelson
2020-10-16 10:33   ` [dpdk-dev] [PATCH v7 1/3] ethdev: allow negative values in flow rule types Gregory Etelson
2020-10-16 10:33   ` [dpdk-dev] [PATCH v7 2/3] ethdev: tunnel offload model Gregory Etelson
2020-10-16 10:34   ` [dpdk-dev] [PATCH v7 3/3] app/testpmd: add commands for tunnel offload API Gregory Etelson
2020-10-16 12:10   ` [dpdk-dev] [PATCH v7 0/3] Tunnel Offload API Ferruh Yigit
2020-10-16 12:51 ` [dpdk-dev] [PATCH v8 " Gregory Etelson
2020-10-16 12:51   ` [dpdk-dev] [PATCH v8 1/3] ethdev: allow negative values in flow rule types Gregory Etelson
2020-10-16 12:51   ` [dpdk-dev] [PATCH v8 2/3] ethdev: tunnel offload model Gregory Etelson
2020-10-16 15:41     ` Kinsella, Ray
2020-10-16 12:51   ` [dpdk-dev] [PATCH v8 3/3] app/testpmd: add commands for tunnel offload API Gregory Etelson
2020-10-16 13:19   ` [dpdk-dev] [PATCH v8 0/3] Tunnel Offload API Ferruh Yigit
2020-10-16 14:20     ` Ferruh Yigit
2020-10-18 12:15 ` [dpdk-dev] [PATCH] ethdev: rename tunnel offload callbacks Gregory Etelson
2020-10-19  8:31   ` Ferruh Yigit
2020-10-19  9:56     ` Kinsella, Ray
2020-10-19 21:29       ` Thomas Monjalon
2020-10-21  9:22 ` [dpdk-dev] [PATCH] net/mlx5: implement tunnel offload API Gregory Etelson
2020-10-22 16:00 ` [dpdk-dev] [PATCH v2] " Gregory Etelson
2020-10-23 13:49 ` [dpdk-dev] [PATCH v3] " Gregory Etelson
2020-10-23 13:57 ` [dpdk-dev] [PATCH v4] " Gregory Etelson
2020-10-25 14:08 ` [dpdk-dev] [PATCH v5] " Gregory Etelson
2020-10-25 15:01   ` Raslan Darawsheh
2020-10-27 16:12 ` [dpdk-dev] [PATCH] net/mlx5: tunnel offload code cleanup Gregory Etelson
2020-10-27 16:29   ` Slava Ovsiienko
2020-10-27 17:16   ` Raslan Darawsheh
2020-10-28 12:33     ` Andrew Rybchenko
2020-10-28  4:58 ` [dpdk-dev] [PATCH] net/mlx5: fix tunnel flow destroy Gregory Etelson
2020-11-02 16:27   ` Raslan Darawsheh

Reply instructions:

You may reply publically 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=BY5PR12MB366897490E317D44331066AEA5300@BY5PR12MB3668.namprd12.prod.outlook.com \
    --to=getelson@nvidia.com \
    --cc=ajit.khaparde@broadcom.com \
    --cc=beilei.xing@intel.com \
    --cc=bernard.iremonger@intel.com \
    --cc=dev@dpdk.org \
    --cc=elibr@nvidia.com \
    --cc=john.mcnamara@intel.com \
    --cc=marko.kovacevic@intel.com \
    --cc=matan@nvidia.com \
    --cc=orika@mellanox.com \
    --cc=ozsh@nvidia.com \
    --cc=rasland@nvidia.com \
    --cc=wenzhuo.lu@intel.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

Archives are clonable:
	git clone --mirror http://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/ http://inbox.dpdk.org/dev \
		dev@dpdk.org
	public-inbox-index dev


Newsgroup available over NNTP:
	nntp://inbox.dpdk.org/inbox.dpdk.dev


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