From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wm0-f42.google.com (mail-wm0-f42.google.com [74.125.82.42]) by dpdk.org (Postfix) with ESMTP id 51C651BACC for ; Tue, 10 Apr 2018 18:34:33 +0200 (CEST) Received: by mail-wm0-f42.google.com with SMTP id r82so24736610wme.0 for ; Tue, 10 Apr 2018 09:34:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=6wind-com.20150623.gappssmtp.com; s=20150623; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:in-reply-to; bh=Gi1yLLzv4gglFr/naVRWdk0iVu4lV93FeozAqtRKHl0=; b=eA64XykTFh4aQVML6KfNnmZsjRqRWMWiZr74ZgGymKlWpeMz5Jxzml540kpQuMFzvS gLRbAPMf5/RUAzALEa6kqv+thQm90owt/Pu6dG30U/bCmDsmzd0rFhHDgkrqt6xuvUK8 xUmET1pKG+R1nMnFFsi9ghrvb0NyjAzfC6Fg5ZCCYi4EO2zbSmLB2MTpFP8rvShldCaY zkKRqM7LpeLboqYxxDjhekEpdDzVT2UuIoN9hPNyWrdYAGxtDhvqYhwj3XxGoZwK4QL0 NoOQROfaJFGzQ/Ut+n7qr5NRe3luk79MyMienzhrpsdIkAowMR1MhVnvPoPVKbJ0V5bF qFlQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:in-reply-to; bh=Gi1yLLzv4gglFr/naVRWdk0iVu4lV93FeozAqtRKHl0=; b=iBI/YS0S9d2MkAyOIU+aJoY6+ync2iDV2G6quq/EdeNSzxH8qIFSYDlTotBr18Fr7P 7xlll78VWeX8Es5wxW7R9MXwHCeE9kcXCfUjdZ1Jj6W0K45xPlr8T5Qn9z7SzvWBE2+t OCQ8slhkFS5xp8rMLKFGLGWaQsF2wlbS3O9ZmVf8sxp/T/02iUmI6o3eeF7Wgq001qOB UUkvkxn9QVUMV8bIDR3uIphHkVsrmVMjjpn5zz/zKzBTFwPXK4wsGIaRSwlOlSXBNW22 GpDTKqhlGjhtae2BHXzYMsioHbv008OTKoRxrXN19xUIEZdTzkNHYNX7uKLQ6d0g+lai HGEw== X-Gm-Message-State: ALQs6tDFuCmVrKmZtirTrR/KykhKiHi4REyQ78BvbpB3H+RGFP0jaj0J KrdhXq7qKmuDDr7n/wGWs4jv359V X-Google-Smtp-Source: AIpwx48JG7085nvdAzosOmtCKLCFHQ9vctOwCTbxCwMHflKwcnlhRHS4Kd/gdJbBI2G8L/J2SH91fg== X-Received: by 10.28.88.141 with SMTP id m135mr140495wmb.156.1523378072850; Tue, 10 Apr 2018 09:34:32 -0700 (PDT) Received: from 6wind.com (host.78.145.23.62.rev.coltfrance.com. [62.23.145.78]) by smtp.gmail.com with ESMTPSA id m62sm3770892wmc.25.2018.04.10.09.34.32 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 10 Apr 2018 09:34:32 -0700 (PDT) Date: Tue, 10 Apr 2018 18:34:19 +0200 From: Adrien Mazarguil To: dev@dpdk.org Cc: stable@dpdk.org, Gaetan Rivet , Thomas Monjalon Message-ID: <20180410161132.8776-10-adrien.mazarguil@6wind.com> References: <20180406131243.19037-1-adrien.mazarguil@6wind.com> <20180410161132.8776-1-adrien.mazarguil@6wind.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20180410161132.8776-1-adrien.mazarguil@6wind.com> X-Mailer: git-send-email 2.11.0 Subject: [dpdk-dev] [PATCH v4 09/11] ethdev: fix shallow copy of flow API RSS action 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: , X-List-Received-Date: Tue, 10 Apr 2018 16:34:33 -0000 The rss_conf field is defined as a pointer to struct rte_eth_rss_conf. Even assuming it is permanently allocated and a pointer copy is safe, pointed data may change and not reflect an applied flow rule anymore. This patch aligns with testpmd by making a deep copy instead. Fixes: 18da437b5f63 ("ethdev: add flow rule copy function") Cc: stable@dpdk.org Cc: Gaetan Rivet Signed-off-by: Adrien Mazarguil Cc: Thomas Monjalon --- lib/librte_ether/rte_flow.c | 145 +++++++++++++++++++++++++++------------ 1 file changed, 102 insertions(+), 43 deletions(-) diff --git a/lib/librte_ether/rte_flow.c b/lib/librte_ether/rte_flow.c index 38f2d27be..ba6feddee 100644 --- a/lib/librte_ether/rte_flow.c +++ b/lib/librte_ether/rte_flow.c @@ -255,60 +255,119 @@ rte_flow_error_set(struct rte_flow_error *error, return -code; } -/** Compute storage space needed by item specification. */ -static void -flow_item_spec_size(const struct rte_flow_item *item, - size_t *size, size_t *pad) +/** Pattern item specification types. */ +enum item_spec_type { + ITEM_SPEC, + ITEM_LAST, + ITEM_MASK, +}; + +/** Compute storage space needed by item specification and copy it. */ +static size_t +flow_item_spec_copy(void *buf, const struct rte_flow_item *item, + enum item_spec_type type) { - if (!item->spec) { - *size = 0; + size_t size = 0; + const void *item_spec = + type == ITEM_SPEC ? item->spec : + type == ITEM_LAST ? item->last : + type == ITEM_MASK ? item->mask : + NULL; + + if (!item_spec) goto empty; - } switch (item->type) { union { const struct rte_flow_item_raw *raw; - } spec; + } src; + union { + struct rte_flow_item_raw *raw; + } dst; - /* Not a fall-through */ case RTE_FLOW_ITEM_TYPE_RAW: - spec.raw = item->spec; - *size = offsetof(struct rte_flow_item_raw, pattern) + - spec.raw->length * sizeof(*spec.raw->pattern); + src.raw = item_spec; + dst.raw = buf; + size = offsetof(struct rte_flow_item_raw, pattern) + + src.raw->length * sizeof(*src.raw->pattern); + if (dst.raw) + memcpy(dst.raw, src.raw, size); break; default: - *size = rte_flow_desc_item[item->type].size; + size = rte_flow_desc_item[item->type].size; + if (buf) + memcpy(buf, item_spec, size); break; } empty: - *pad = RTE_ALIGN_CEIL(*size, sizeof(double)) - *size; + return RTE_ALIGN_CEIL(size, sizeof(double)); } -/** Compute storage space needed by action configuration. */ -static void -flow_action_conf_size(const struct rte_flow_action *action, - size_t *size, size_t *pad) +/** Compute storage space needed by action configuration and copy it. */ +static size_t +flow_action_conf_copy(void *buf, const struct rte_flow_action *action) { - if (!action->conf) { - *size = 0; + size_t size = 0; + + if (!action->conf) goto empty; - } switch (action->type) { union { const struct rte_flow_action_rss *rss; - } conf; + } src; + union { + struct rte_flow_action_rss *rss; + } dst; + size_t off; - /* Not a fall-through. */ case RTE_FLOW_ACTION_TYPE_RSS: - conf.rss = action->conf; - *size = offsetof(struct rte_flow_action_rss, queue) + - conf.rss->num * sizeof(*conf.rss->queue); + src.rss = action->conf; + dst.rss = buf; + off = 0; + if (dst.rss) + *dst.rss = (struct rte_flow_action_rss){ + .num = src.rss->num, + }; + off += offsetof(struct rte_flow_action_rss, queue); + if (src.rss->num) { + size = sizeof(*src.rss->queue) * src.rss->num; + if (dst.rss) + memcpy(dst.rss->queue, src.rss->queue, size); + off += size; + } + off = RTE_ALIGN_CEIL(off, sizeof(double)); + if (dst.rss) { + dst.rss->rss_conf = (void *)((uintptr_t)dst.rss + off); + *(struct rte_eth_rss_conf *)(uintptr_t) + dst.rss->rss_conf = (struct rte_eth_rss_conf){ + .rss_key_len = src.rss->rss_conf->rss_key_len, + .rss_hf = src.rss->rss_conf->rss_hf, + }; + } + off += sizeof(*src.rss->rss_conf); + if (src.rss->rss_conf->rss_key_len) { + off = RTE_ALIGN_CEIL(off, sizeof(double)); + size = sizeof(*src.rss->rss_conf->rss_key) * + src.rss->rss_conf->rss_key_len; + if (dst.rss) { + ((struct rte_eth_rss_conf *)(uintptr_t) + dst.rss->rss_conf)->rss_key = + (void *)((uintptr_t)dst.rss + off); + memcpy(dst.rss->rss_conf->rss_key, + src.rss->rss_conf->rss_key, + size); + } + off += size; + } + size = off; break; default: - *size = rte_flow_desc_action[action->type].size; + size = rte_flow_desc_action[action->type].size; + if (buf) + memcpy(buf, action->conf, size); break; } empty: - *pad = RTE_ALIGN_CEIL(*size, sizeof(double)) - *size; + return RTE_ALIGN_CEIL(size, sizeof(double)); } /** Store a full rte_flow description. */ @@ -320,7 +379,6 @@ rte_flow_copy(struct rte_flow_desc *desc, size_t len, { struct rte_flow_desc *fd = NULL; size_t tmp; - size_t pad; size_t off1 = 0; size_t off2 = 0; size_t size = 0; @@ -345,24 +403,26 @@ rte_flow_copy(struct rte_flow_desc *desc, size_t len, dst = memcpy(fd->data + off1, item, sizeof(*item)); off1 += sizeof(*item); - flow_item_spec_size(item, &tmp, &pad); if (item->spec) { if (fd) - dst->spec = memcpy(fd->data + off2, - item->spec, tmp); - off2 += tmp + pad; + dst->spec = fd->data + off2; + off2 += flow_item_spec_copy + (fd ? fd->data + off2 : NULL, item, + ITEM_SPEC); } if (item->last) { if (fd) - dst->last = memcpy(fd->data + off2, - item->last, tmp); - off2 += tmp + pad; + dst->last = fd->data + off2; + off2 += flow_item_spec_copy + (fd ? fd->data + off2 : NULL, item, + ITEM_LAST); } if (item->mask) { if (fd) - dst->mask = memcpy(fd->data + off2, - item->mask, tmp); - off2 += tmp + pad; + dst->mask = fd->data + off2; + off2 += flow_item_spec_copy + (fd ? fd->data + off2 : NULL, item, + ITEM_MASK); } off2 = RTE_ALIGN_CEIL(off2, sizeof(double)); } while ((item++)->type != RTE_FLOW_ITEM_TYPE_END); @@ -387,12 +447,11 @@ rte_flow_copy(struct rte_flow_desc *desc, size_t len, dst = memcpy(fd->data + off1, action, sizeof(*action)); off1 += sizeof(*action); - flow_action_conf_size(action, &tmp, &pad); if (action->conf) { if (fd) - dst->conf = memcpy(fd->data + off2, - action->conf, tmp); - off2 += tmp + pad; + dst->conf = fd->data + off2; + off2 += flow_action_conf_copy + (fd ? fd->data + off2 : NULL, action); } off2 = RTE_ALIGN_CEIL(off2, sizeof(double)); } while ((action++)->type != RTE_FLOW_ACTION_TYPE_END); -- 2.11.0