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 5C1CFA04B5; Thu, 1 Oct 2020 07:32:32 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id AD4341D57F; Thu, 1 Oct 2020 07:32:30 +0200 (CEST) Received: from mail-ot1-f66.google.com (mail-ot1-f66.google.com [209.85.210.66]) by dpdk.org (Postfix) with ESMTP id 570E81D57D for ; Thu, 1 Oct 2020 07:32:28 +0200 (CEST) Received: by mail-ot1-f66.google.com with SMTP id o8so4232034otl.4 for ; Wed, 30 Sep 2020 22:32:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=broadcom.com; s=google; h=mime-version:references:in-reply-to:from:date:message-id:subject:to :cc; bh=89MkU4qEencZ1cWX+hJ3yDsbO4yDsszJeaN5XHvoBKI=; b=Js0CoDW1kfzgrn7fyQlzLZWUDaz3ug1Bd5AeOOzrf1p+OIn2/g7HkYIl2pqyD0f1pV 5t1E4CbaMmxemYSbiq+BNp8I3L+qgwdpaScuh+T8s/Ybe0oDObMAiAXKpR0qYQ9r9Rz4 300vMSiNqVI9pccL7+G48k5jk6YkjpBcpjgMI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=89MkU4qEencZ1cWX+hJ3yDsbO4yDsszJeaN5XHvoBKI=; b=ppB6kHW7SwMJ2+RsFyChSvtXBTbthn0teEFCC5zy83xg3GpbpRLdOY9r8Crz0vjG+C swMalN4K93O6QkPAizryoTLv7b05aUk6X8TCTkcd+Nhdng4adFgBWdWl+muAm61RA805 SqBvIOpZNVo3SK0i7ES3ZWoB8b2cokvnecyaiDxASGOOqDaL6dqS34ES95swfdiLV6Tf +Vx1hSM9qCEyJqoDREPn9OlpH2pxTdtXbnMaePVoOhcVLxB/LTOdQDZ5uyc8XiBw1QxM raHCDzEZNMnPTY1ireej1YaNYk+5mGFkhq/jPAow5i4cDzx9fKyh23SIcrUdMty1iwG7 fTdA== X-Gm-Message-State: AOAM533GWMwmHLd5BSUhUUEG4WpJaz1LXR4NmLCSH9SznAeOFXspE4LF zt3jihaLfGVa8hKfBtOJ9hdNLbI5EfbSJ7oKgA2hlA== X-Google-Smtp-Source: ABdhPJwrIaLOOHoPsVhpmfjZS+y7K9OVW1Jf5c/2kkqp2PTbAh8RnMpy2b0lLnjucnn0P8CvXWfht4aZwunCvQxDVHs= X-Received: by 2002:a9d:5509:: with SMTP id l9mr4101649oth.154.1601530346177; Wed, 30 Sep 2020 22:32:26 -0700 (PDT) MIME-Version: 1.0 References: <20200625160348.26220-1-getelson@mellanox.com> <20200930091854.19768-1-getelson@nvidia.com> <20200930091854.19768-5-getelson@nvidia.com> In-Reply-To: <20200930091854.19768-5-getelson@nvidia.com> From: Ajit Khaparde Date: Wed, 30 Sep 2020 22:32:09 -0700 Message-ID: To: Gregory Etelson Cc: dpdk-dev , Matan Azrad , rasland@nvidia.com, Ori Kam , Wenzhuo Lu , Beilei Xing , Bernard Iremonger , John McNamara , Marko Kovacevic Content-Type: text/plain; charset="UTF-8" X-Content-Filtered-By: Mailman/MimeDel 2.1.15 Subject: Re: [dpdk-dev] [PATCH v3 4/4] app/testpmd: add commands for tunnel offload API 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" On Wed, Sep 30, 2020 at 2:21 AM Gregory Etelson 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 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 parameter used with steering rule > template. > > * Create tunnel matching flow rule: > tunnel_match 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= > >>>>>> > >>> 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 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 id > > * Show existing flow tunnels > flow tunnel list > > Signed-off-by: Gregory Etelson > --- > 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 > #include > #include > +#include > > #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=", ð_hdr->s_addr); > print_ether_addr(" - dst=", ð_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 >