From patchwork Mon May 18 19:27:27 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sriharsha Basavapatna X-Patchwork-Id: 1292740 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=openvswitch.org (client-ip=140.211.166.137; helo=fraxinus.osuosl.org; envelope-from=ovs-dev-bounces@openvswitch.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=openvswitch.org Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=broadcom.com header.i=@broadcom.com header.a=rsa-sha256 header.s=google header.b=PH1wisYV; dkim-atps=neutral Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 49QpvR1Rzwz9sT6 for ; Tue, 19 May 2020 05:28:02 +1000 (AEST) Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id D011785C4C; Mon, 18 May 2020 19:28:00 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id gHOT9v6b6rv3; Mon, 18 May 2020 19:27:56 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by fraxinus.osuosl.org (Postfix) with ESMTP id E219386C71; Mon, 18 May 2020 19:27:56 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id D52CFC0888; Mon, 18 May 2020 19:27:56 +0000 (UTC) X-Original-To: dev@openvswitch.org Delivered-To: ovs-dev@lists.linuxfoundation.org Received: from silver.osuosl.org (smtp3.osuosl.org [140.211.166.136]) by lists.linuxfoundation.org (Postfix) with ESMTP id 565B6C0888 for ; Mon, 18 May 2020 19:27:55 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by silver.osuosl.org (Postfix) with ESMTP id 0023D221AF for ; Mon, 18 May 2020 19:27:54 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from silver.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id P0SbD32X8sb6 for ; Mon, 18 May 2020 19:27:52 +0000 (UTC) X-Greylist: from auto-whitelisted by SQLgrey-1.7.6 Received: from mail-wm1-f68.google.com (mail-wm1-f68.google.com [209.85.128.68]) by silver.osuosl.org (Postfix) with ESMTPS id D160720341 for ; Mon, 18 May 2020 19:27:51 +0000 (UTC) Received: by mail-wm1-f68.google.com with SMTP id z72so784104wmc.2 for ; Mon, 18 May 2020 12:27:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=broadcom.com; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=s9M0XzP6Jpk9Aq+RnPs3HlIGu4EPiRqZEmK/Fcci60M=; b=PH1wisYVV29ogQdgsD0ebYJQgN/p7FU9R+Opdh/gHRmgsvkoG5/AaVkL/SdaA9gdv5 MkVDBMdOzhck+Qdx90oNVtvIX64oCwCjyi5lOI1h2ezzv9XA1h74KFgKW7Xczp2t6YlW QXqr3B0qhUlE6lTW27TAoqkjJNf/YqM5VZ+ZY= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=s9M0XzP6Jpk9Aq+RnPs3HlIGu4EPiRqZEmK/Fcci60M=; b=nOcIRyzh3LDFQmOddjXQMD8acPpx2vt/ci0EOCQJ0/70ac87pOBwTOQmfHr4kQTZ62 RpPuiqArs+PV7nSETWHrPLrJQCk/MQyKivX0HLkfaN9hQnlfm3O7N67TvnaCa59nBGVf UIb+dfzmdGi0gp1hrlRjznlAvmNR4rwf1IaTeLcgFD2y13HZw8CuqzSocfwMsluLaOPD vtGjpcQNqC3btCxxAPQvauDrECYz3cUqL6H0ZD4qiRdrhPKhDE8zuwEIxehjCxoCcN1/ r6d89mh/aBWZai90mD2EWpsL82vH4pIsDVmCFJRgDUVw34ib5lg6LnmMwjyRWesuW7xl PuIQ== X-Gm-Message-State: AOAM532luy1NTTs8T6SPBR7UM3xaK20agC28ILrZ1dzjMYK59QXkhvza Gi6rTH8/f+tMhzjyIX41gYzxxZ8cvMdD3ei04OJrkty176G4R52zu05fKAb26dcHLwHV80ErKGo FH7/6Iuur6VZ/mses11KIcM9z49+SCsBskRRUpUYBuzA5jZnxhPl7V7X6qomo2zhUO+xVcsdErX e5dhHH X-Google-Smtp-Source: ABdhPJwpeKVQnn9kNylZU+09ekSnqV15JDKNNU6Q/s2TFCMTYhFuqTKASeJy90JZ4y/Vy5+jRDYRCw== X-Received: by 2002:a1c:e3d7:: with SMTP id a206mr871149wmh.141.1589830068702; Mon, 18 May 2020 12:27:48 -0700 (PDT) Received: from dhcp-10-123-153-36.dhcp.broadcom.net ([192.19.234.250]) by smtp.gmail.com with ESMTPSA id z18sm590153wmk.46.2020.05.18.12.27.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 May 2020 12:27:48 -0700 (PDT) To: dev@openvswitch.org Date: Mon, 18 May 2020 15:27:27 -0400 Message-Id: <20200518192731.30804-2-sriharsha.basavapatna@broadcom.com> X-Mailer: git-send-email 2.25.0.rc2 In-Reply-To: <20200518192731.30804-1-sriharsha.basavapatna@broadcom.com> References: <20200518192731.30804-1-sriharsha.basavapatna@broadcom.com> MIME-Version: 1.0 Subject: [ovs-dev] [RFC v2 PATCH 1/5] dpif-netdev: Refactor dp_netdev_flow_offload_put() X-BeenThere: ovs-dev@openvswitch.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Sriharsha Basavapatna via dev From: Sriharsha Basavapatna Reply-To: Sriharsha Basavapatna Errors-To: ovs-dev-bounces@openvswitch.org Sender: "dev" This patch refactors dp_netdev_flow_offload_put() to prepare for more changes to support partial action offload, in subsequent patches. - Add a wrapper function to allocate flow-mark. - Move netdev_ports_get() to before flow-mark allocation. Signed-off-by: Sriharsha Basavapatna --- lib/dpif-netdev.c | 71 ++++++++++++++++++++++++++++++----------------- 1 file changed, 45 insertions(+), 26 deletions(-) diff --git a/lib/dpif-netdev.c b/lib/dpif-netdev.c index ea7b187b2..781b233f4 100644 --- a/lib/dpif-netdev.c +++ b/lib/dpif-netdev.c @@ -2357,6 +2357,43 @@ dp_netdev_flow_offload_del(struct dp_flow_offload_item *offload) return mark_to_flow_disassociate(offload->pmd, offload->flow); } +static int +dp_netdev_alloc_flow_mark(struct dp_netdev_flow *flow, bool modification, + uint32_t *markp) +{ + uint32_t mark; + + if (modification) { + mark = flow->mark; + ovs_assert(mark != INVALID_FLOW_MARK); + *markp = mark; + return 0; + } + + /* + * If a mega flow has already been offloaded (from other PMD + * instances), do not offload it again. + */ + mark = megaflow_to_mark_find(&flow->mega_ufid); + if (mark != INVALID_FLOW_MARK) { + VLOG_DBG("Flow has already been offloaded with mark %u\n", mark); + if (flow->mark != INVALID_FLOW_MARK) { + ovs_assert(flow->mark == mark); + } else { + mark_to_flow_associate(mark, flow); + } + return 1; + } + + mark = netdev_offload_flow_mark_alloc(); + if (mark == INVALID_FLOW_MARK) { + VLOG_ERR("Failed to allocate flow mark!\n"); + } + + *markp = mark; + return 0; +} + /* * There are two flow offload operations here: addition and modification. * @@ -2385,36 +2422,18 @@ dp_netdev_flow_offload_put(struct dp_flow_offload_item *offload) return -1; } - if (modification) { - mark = flow->mark; - ovs_assert(mark != INVALID_FLOW_MARK); - } else { - /* - * If a mega flow has already been offloaded (from other PMD - * instances), do not offload it again. - */ - mark = megaflow_to_mark_find(&flow->mega_ufid); - if (mark != INVALID_FLOW_MARK) { - VLOG_DBG("Flow has already been offloaded with mark %u\n", mark); - if (flow->mark != INVALID_FLOW_MARK) { - ovs_assert(flow->mark == mark); - } else { - mark_to_flow_associate(mark, flow); - } - return 0; - } + port = netdev_ports_get(in_port, dpif_type_str); + if (!port) { + return -1; + } - mark = netdev_offload_flow_mark_alloc(); - if (mark == INVALID_FLOW_MARK) { - VLOG_ERR("Failed to allocate flow mark!\n"); - } + if (dp_netdev_alloc_flow_mark(flow, modification, &mark)) { + /* flow already offloaded */ + netdev_close(port); + return 0; } info.flow_mark = mark; - port = netdev_ports_get(in_port, dpif_type_str); - if (!port) { - goto err_free; - } /* Taking a global 'port_mutex' to fulfill thread safety restrictions for * the netdev-offload-dpdk module. */ ovs_mutex_lock(&pmd->dp->port_mutex); From patchwork Mon May 18 19:27:28 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sriharsha Basavapatna X-Patchwork-Id: 1292742 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=openvswitch.org (client-ip=140.211.166.138; helo=whitealder.osuosl.org; envelope-from=ovs-dev-bounces@openvswitch.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=openvswitch.org Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=broadcom.com header.i=@broadcom.com header.a=rsa-sha256 header.s=google header.b=geIti0bo; dkim-atps=neutral Received: from whitealder.osuosl.org (smtp1.osuosl.org [140.211.166.138]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 49QpvV6S6dz9sT6 for ; Tue, 19 May 2020 05:28:06 +1000 (AEST) Received: from localhost (localhost [127.0.0.1]) by whitealder.osuosl.org (Postfix) with ESMTP id 136FE880E2; Mon, 18 May 2020 19:28:05 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from whitealder.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 81ivLER19qEz; Mon, 18 May 2020 19:27:59 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by whitealder.osuosl.org (Postfix) with ESMTP id 8871687FC1; Mon, 18 May 2020 19:27:58 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 71174C0888; Mon, 18 May 2020 19:27:58 +0000 (UTC) X-Original-To: dev@openvswitch.org Delivered-To: ovs-dev@lists.linuxfoundation.org Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) by lists.linuxfoundation.org (Postfix) with ESMTP id 9BE29C07FF for ; Mon, 18 May 2020 19:27:57 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id 8C17C86CAE for ; Mon, 18 May 2020 19:27:57 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id SYA5-UGKKLuX for ; Mon, 18 May 2020 19:27:53 +0000 (UTC) X-Greylist: from auto-whitelisted by SQLgrey-1.7.6 Received: from mail-wm1-f68.google.com (mail-wm1-f68.google.com [209.85.128.68]) by fraxinus.osuosl.org (Postfix) with ESMTPS id 0C14685C4C for ; Mon, 18 May 2020 19:27:53 +0000 (UTC) Received: by mail-wm1-f68.google.com with SMTP id z72so784172wmc.2 for ; Mon, 18 May 2020 12:27:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=broadcom.com; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=LnBFFsJqz118CNTvYD13tb81hun4lCIFbeXobXhEXJ0=; b=geIti0bo+EIaAS+Bwi3chlL1jNix1oc2jXMyfFx1NVYyYlH46G1Ro7yk1rsve+3UH0 wrKRUQdVB7pJ3CzUwvuTHPdc89PK8yugwy5LtWF+sGWYvxi2kzz3rmuUxzZ62N0whVeJ g1G0CgfYRvdnjnpVEiE+FkixyYsaClcnMhV/0= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=LnBFFsJqz118CNTvYD13tb81hun4lCIFbeXobXhEXJ0=; b=HBDDrFUiAgD4xavUtlN4c2mNfQG1qvAGIMusPdGd75d7TMSst45yUPtSFXaND8nKBk 9Za3EkTdtmfiK953ySBzeeZ+GT9cTdoXxMuWgtEnW683dK5IkYKmYaD8tEZ7+1eAfiSe OgUUqoCsjqEP5Jjb62igBPuhLLVE15mX/jMxmmpPv6voY8pNWIQTHstEgxCt2tngCesk mwhZcZkOOztRZ5RVpPjBBZ8IFeuLRkQyWk7KJRGG6OpQoXWQU67Jnu7dDOEuNkfvqg3T j9uc9oYDEG6JtmvtfSVYuO5s54pfYdENGb+hsJKI9od4ky2nJBV8CEE17u8YYQaBRxY/ UTTg== X-Gm-Message-State: AOAM533QmhpSC711kAxooltOLICuyOfOBixlvApiRbsHlChDMG9qFj5Z 6tZPPG3NuBzXsfSljKvRyYdtyliRtyhUIzLes83SZUDs6SKclqjmuHtqfBo29Vwq6tlS6scdHYN rBeY79cPzVIV+IT0PpDldiB6XQzNM/uNmHBTjyGB7z33dnx4KY52+tB3Fy7sdOo0UcOjdcETCZd xcdvap X-Google-Smtp-Source: ABdhPJxMRrJQ0aaCJ+ppxUSSi0f2fOlofluYqHV/Mri379EQNxzTHwq5ZsSDG1buvO/fMxwiZjpkrg== X-Received: by 2002:a1c:a947:: with SMTP id s68mr967317wme.25.1589830070856; Mon, 18 May 2020 12:27:50 -0700 (PDT) Received: from dhcp-10-123-153-36.dhcp.broadcom.net ([192.19.234.250]) by smtp.gmail.com with ESMTPSA id z18sm590153wmk.46.2020.05.18.12.27.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 May 2020 12:27:50 -0700 (PDT) To: dev@openvswitch.org Date: Mon, 18 May 2020 15:27:28 -0400 Message-Id: <20200518192731.30804-3-sriharsha.basavapatna@broadcom.com> X-Mailer: git-send-email 2.25.0.rc2 In-Reply-To: <20200518192731.30804-1-sriharsha.basavapatna@broadcom.com> References: <20200518192731.30804-1-sriharsha.basavapatna@broadcom.com> MIME-Version: 1.0 Subject: [ovs-dev] [RFC v2 PATCH 2/5] netdev-dpdk: provide a function to identify dpdk-vhost netdevs X-BeenThere: ovs-dev@openvswitch.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Sriharsha Basavapatna via dev From: Sriharsha Basavapatna Reply-To: Sriharsha Basavapatna Errors-To: ovs-dev-bounces@openvswitch.org Sender: "dev" This patch adds a function to determine if a given netdev belongs to the dpdk-vhost class, using the netdev_class specific data. Signed-off-by: Sriharsha Basavapatna --- lib/netdev-dpdk.c | 5 +++++ lib/netdev-dpdk.h | 1 + 2 files changed, 6 insertions(+) diff --git a/lib/netdev-dpdk.c b/lib/netdev-dpdk.c index 944e4a152..ad880f3ff 100644 --- a/lib/netdev-dpdk.c +++ b/lib/netdev-dpdk.c @@ -559,6 +559,11 @@ is_dpdk_class(const struct netdev_class *class) || class->destruct == netdev_dpdk_vhost_destruct; } +bool is_dpdk_vhost_netdev(struct netdev *netdev) +{ + return netdev->netdev_class->destruct == netdev_dpdk_vhost_destruct; +} + /* DPDK NIC drivers allocate RX buffers at a particular granularity, typically * aligned at 1k or less. If a declared mbuf size is not a multiple of this * value, insufficient buffers are allocated to accomodate the packet in its diff --git a/lib/netdev-dpdk.h b/lib/netdev-dpdk.h index 94e08e516..67e70d09f 100644 --- a/lib/netdev-dpdk.h +++ b/lib/netdev-dpdk.h @@ -37,6 +37,7 @@ void netdev_dpdk_register(void); void free_dpdk_buf(struct dp_packet *); bool netdev_dpdk_flow_api_supported(struct netdev *); +bool is_dpdk_vhost_netdev(struct netdev *); int netdev_dpdk_rte_flow_destroy(struct netdev *netdev, From patchwork Mon May 18 19:27:29 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sriharsha Basavapatna X-Patchwork-Id: 1292743 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=openvswitch.org (client-ip=140.211.166.133; helo=hemlock.osuosl.org; envelope-from=ovs-dev-bounces@openvswitch.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=openvswitch.org Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=broadcom.com header.i=@broadcom.com header.a=rsa-sha256 header.s=google header.b=baX0l1Eu; dkim-atps=neutral Received: from hemlock.osuosl.org (smtp2.osuosl.org [140.211.166.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 49QpvY5fTlz9sT6 for ; Tue, 19 May 2020 05:28:09 +1000 (AEST) Received: from localhost (localhost [127.0.0.1]) by hemlock.osuosl.org (Postfix) with ESMTP id 73DE488841; Mon, 18 May 2020 19:28:07 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from hemlock.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id yCuw9azSOqbP; Mon, 18 May 2020 19:28:03 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by hemlock.osuosl.org (Postfix) with ESMTP id 3AAC588817; Mon, 18 May 2020 19:28:03 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 2E479C0888; Mon, 18 May 2020 19:28:03 +0000 (UTC) X-Original-To: dev@openvswitch.org Delivered-To: ovs-dev@lists.linuxfoundation.org Received: from hemlock.osuosl.org (smtp2.osuosl.org [140.211.166.133]) by lists.linuxfoundation.org (Postfix) with ESMTP id 52722C07FF for ; Mon, 18 May 2020 19:28:01 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by hemlock.osuosl.org (Postfix) with ESMTP id 41C77886E6 for ; Mon, 18 May 2020 19:28:01 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from hemlock.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id Hu8IM3+u5Ovh for ; Mon, 18 May 2020 19:27:59 +0000 (UTC) X-Greylist: from auto-whitelisted by SQLgrey-1.7.6 Received: from mail-wm1-f65.google.com (mail-wm1-f65.google.com [209.85.128.65]) by hemlock.osuosl.org (Postfix) with ESMTPS id C46C288788 for ; Mon, 18 May 2020 19:27:55 +0000 (UTC) Received: by mail-wm1-f65.google.com with SMTP id n18so765014wmj.5 for ; Mon, 18 May 2020 12:27:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=broadcom.com; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=qdxdWywZ8E/vufHjuLrlohAnLzsdC5hb8Sw//igNZBE=; b=baX0l1EuNCeKb4LJqMRofAABbBhrQtvBypFrkJUHvP0RYlAXvikEC90BgvMGLPTieT IVZzd4yCZso992ntxy6dHaKwcGZ91F8Yig2neqse4OB+PTFtMwThyLPCHn4qJAak0ndO V5WLLLunMkJznNxthSGAfNbamTPUgk1mQON/I= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=qdxdWywZ8E/vufHjuLrlohAnLzsdC5hb8Sw//igNZBE=; b=UrNcLXiDAlHMqm+CrnX5oBTieBwrW4wyhX5kgf+XpYdjaYP+QOrjQZi9cPPh1Ceoeo uj98n439TKkiGUacFrk2z4yQWISNjhNMAFsk3VyuoDBv8NcLZm8qmTaAwSC7NfAI5et2 uXj6JlrnxM3G1+3V/lozS0ZR373NsCAHJi+PWAOTypIfI1wIPbeffDhSGRZAyUQUmX0D H13C9jaOglhLPrHYUyewZWshhIYqzX+6ikLLItbujv52HX5tjXjThJdkvtSbvnwMNtjU 7xACPpGRpG3NsMSfF1Q6277+fVZTJiVZZETIgb6zjf/9UsKRa+5a/ZqGiGNOew2zcn7R 4R+A== X-Gm-Message-State: AOAM531ATKNWSAW0Bbr9qoggCZahm7LczYakOnMIK+VNUEH9Xj4ZqcH8 3NAOGPjx65BI8+JpCc2pUkajdzUrBpalvqT5bEPND2MXWCQlR2G6BSpIVwpRwTkdrTeLnm2Im0b vHKOdL5v8wU4IlvaZb6PZpktOKnw9qIBqo9eIxHQdCayUzuA5GEWBHb+tlnxuOTzc/rT8Tz2tRH Tl2nrG X-Google-Smtp-Source: ABdhPJwpWI1vwqSO8bHESKphntSeBAV1YpIKCPQ/h5aLLjN1BqkwUsN0hsRZ+7aYw4YVhku18HaL2A== X-Received: by 2002:a05:600c:231a:: with SMTP id 26mr996058wmo.59.1589830073516; Mon, 18 May 2020 12:27:53 -0700 (PDT) Received: from dhcp-10-123-153-36.dhcp.broadcom.net ([192.19.234.250]) by smtp.gmail.com with ESMTPSA id z18sm590153wmk.46.2020.05.18.12.27.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 May 2020 12:27:52 -0700 (PDT) To: dev@openvswitch.org Date: Mon, 18 May 2020 15:27:29 -0400 Message-Id: <20200518192731.30804-4-sriharsha.basavapatna@broadcom.com> X-Mailer: git-send-email 2.25.0.rc2 In-Reply-To: <20200518192731.30804-1-sriharsha.basavapatna@broadcom.com> References: <20200518192731.30804-1-sriharsha.basavapatna@broadcom.com> MIME-Version: 1.0 Subject: [ovs-dev] [RFC v2 PATCH 3/5] dpif-netdev: Support partial-action-offload of VXLAN encap flow X-BeenThere: ovs-dev@openvswitch.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Sriharsha Basavapatna via dev From: Sriharsha Basavapatna Reply-To: Sriharsha Basavapatna Errors-To: ovs-dev-bounces@openvswitch.org Sender: "dev" In this patch, we support offloading of VXLAN_ENCAP action for a vhost-user port (aka "partial-action-offload"). At the time of offloading the flow, we determine if the flow can be offloaded to an egress device, if the input port is not offload capable such as a vhost-user port. We then offload the flow with a VXLAN_ENCAP RTE action, to the egress device. We do not add the OUTPUT RTE action, which indicates to the PMD that is is a partial action offload request. Note that since the action is being offloaded in egress direction, classification is expected to be done by OVS SW datapath and hence there's no need to offload a MARK action. If offload succeeds, we save the information in 'dp_netdev_flow' so that we skip execution of the corresponding action (subsequent patch) during SW datapath processing. Signed-off-by: Sriharsha Basavapatna --- lib/dpif-netdev.c | 216 ++++++++++++++++++++++++++++++++++++-- lib/netdev-offload-dpdk.c | 50 ++++++--- lib/netdev-offload.h | 2 + 3 files changed, 246 insertions(+), 22 deletions(-) diff --git a/lib/dpif-netdev.c b/lib/dpif-netdev.c index 781b233f4..4315f237c 100644 --- a/lib/dpif-netdev.c +++ b/lib/dpif-netdev.c @@ -538,6 +538,16 @@ struct dp_netdev_flow { bool dead; uint32_t mark; /* Unique flow mark assigned to a flow */ + /* The next two members are used to support partial offloading of + * actions. The boolean flag tells if this flow has its actions partially + * offloaded. The egress port# tells if the action should be offloaded + * on the egress (output) port instead of the in-port for the flow. Note + * that we support flows with a single egress port action. + * (see MAX_ACTION_ATTRS for related comments). + */ + bool partial_actions_offloaded; + odp_port_t egress_offload_port; + /* Statistics. */ struct dp_netdev_flow_stats stats; @@ -2351,10 +2361,176 @@ dp_netdev_append_flow_offload(struct dp_flow_offload_item *offload) ovs_mutex_unlock(&dp_flow_offload.mutex); } +static int +partial_offload_egress_flow_del(struct dp_netdev_pmd_thread *pmd, + struct dp_netdev_flow *flow) +{ + int ret; + struct netdev *port; + odp_port_t out_port = flow->egress_offload_port; + const char *dpif_type_str = dpif_normalize_type(pmd->dp->class->type); + + port = netdev_ports_get(out_port, dpif_type_str); + if (!port) { + return -1; + } + + /* Taking a global 'port_mutex' to fulfill thread safety + * restrictions for the netdev-offload-dpdk module. */ + ovs_mutex_lock(&pmd->dp->port_mutex); + ret = netdev_flow_del(port, &flow->mega_ufid, NULL); + ovs_mutex_unlock(&pmd->dp->port_mutex); + netdev_close(port); + + return ret; +} + static int dp_netdev_flow_offload_del(struct dp_flow_offload_item *offload) { - return mark_to_flow_disassociate(offload->pmd, offload->flow); + if (offload->flow->partial_actions_offloaded && + offload->flow->egress_offload_port != ODPP_NONE) { + return partial_offload_egress_flow_del(offload->pmd, offload->flow); + } else { + return mark_to_flow_disassociate(offload->pmd, offload->flow); + } +} + +/* Structure to hold a nl_parsed OVS action */ +struct action_attr { + int type; /* OVS action type */ + struct nlattr *action; /* action attribute */ +}; + +/* + * Maxium number of actions to be parsed while selecting a flow for partial + * action offload. This number is currently based on the minimum number of + * attributes seen with the tunnel encap action (clone, tunnel_push, output). + * This number includes output action to a single egress device (uplink) and + * supports neither multiple clone() actions nor multiple output actions. + * This number could change if and when we support other actions or + * combinations of actions for partial offload. + */ +#define MAX_ACTION_ATTRS 3 /* Max # action attributes supported */ + +/* + * This function parses the list of OVS "actions" of length "actions_len", + * and returns them in an array of action "attrs", of size "max_attrs". + * The parsed number of actions is returned in "num_attrs". If the number + * of actions exceeds "max_attrs", parsing is stopped and E2BIG is returned. + * Otherwise, returns success (0). + */ +static int +parse_nlattr_actions(struct nlattr *actions, size_t actions_len, + struct action_attr *attrs, int max_attrs, int *num_attrs) +{ + const struct nlattr *a; + unsigned int left; + int num_actions = 0; + int n_attrs = 0; + int rc = 0; + int type; + + *num_attrs = 0; + + NL_ATTR_FOR_EACH (a, left, actions, actions_len) { + type = nl_attr_type(a); + + if (num_actions >= max_attrs) { + *num_attrs = num_actions; + return E2BIG; + } + + attrs[num_actions].type = type; + attrs[num_actions].action = a; + num_actions++; + if (type == OVS_ACTION_ATTR_CLONE) { + rc = parse_nlattr_actions(nl_attr_get(a), nl_attr_get_size(a), + &attrs[num_actions], + (max_attrs - num_actions), &n_attrs); + num_actions += n_attrs; + if (rc == E2BIG) { + *num_attrs = num_actions; + return rc; + } + } + } + + *num_attrs = num_actions; + return 0; +} + +/* This function determines if the given flow should be partially offloaded + * on the egress device, when the in-port is not offload-capable like a + * vhost-user port. The function currently supports offloading of only + * tunnel encap action. + */ +static bool +should_partial_offload_egress(struct netdev *in_netdev, + struct dp_flow_offload_item *offload, + struct netdev **egress_netdev) +{ + const char *dpif_type_str = + dpif_normalize_type(offload->pmd->dp->class->type); + struct action_attr attrs[MAX_ACTION_ATTRS]; + odp_port_t out_port = ODPP_NONE; + struct netdev *out_netdev; + int num_attrs = 0; + int type; + int rc; + + /* Support egress partial-offload only when in-port is vhost-user. */ + if (!is_dpdk_vhost_netdev(in_netdev)) { + return false; + } + + rc = parse_nlattr_actions(offload->actions, offload->actions_len, attrs, + MAX_ACTION_ATTRS, &num_attrs); + if (rc == E2BIG) { + /* Action list too big; decline partial offload */ + return false; + } + + /* Number of attrs expected with tunnel encap action */ + if (num_attrs < MAX_ACTION_ATTRS) { + return false; + } + + /* Only support clone sub-actions for now, tnl-push specifically. */ + if (attrs[0].type != OVS_ACTION_ATTR_CLONE || + attrs[1].type != OVS_ACTION_ATTR_TUNNEL_PUSH || + attrs[2].type != OVS_ACTION_ATTR_OUTPUT) { + return false; + } + + /* Egress partial-offload needs an output action at the end. */ + out_port = nl_attr_get_odp_port(attrs[2].action); + if (out_port == ODPP_NONE) { + return false; + } + + /* Support egress partial-offload only when out-port is offload capable. */ + out_netdev = netdev_ports_get(out_port, dpif_type_str); + if (!out_netdev || !netdev_dpdk_flow_api_supported(out_netdev)) { + return false; + } + + /* Flow can be egress partial-offloaded. */ + *egress_netdev = out_netdev; + offload->flow->egress_offload_port = out_port; + return true; +} + +/* This function determines if the given flow actions can be partially + * offloaded. Partial action offload is attempted when the in-port for + * the flow is a vhost-user port (egress direction). + */ +static bool +dp_netdev_partial_offload_supported(struct netdev *in_netdev, + struct dp_flow_offload_item *offload, + struct netdev **egress_netdev) +{ + return should_partial_offload_egress(in_netdev, offload, egress_netdev); } static int @@ -2415,7 +2591,9 @@ dp_netdev_flow_offload_put(struct dp_flow_offload_item *offload) bool modification = offload->op == DP_NETDEV_FLOW_OFFLOAD_OP_MOD; struct offload_info info; struct netdev *port; - uint32_t mark; + struct netdev *egress_port = NULL; + bool alloc_mark = true; + uint32_t mark = INVALID_FLOW_MARK; int ret; if (flow->dead) { @@ -2427,7 +2605,20 @@ dp_netdev_flow_offload_put(struct dp_flow_offload_item *offload) return -1; } - if (dp_netdev_alloc_flow_mark(flow, modification, &mark)) { + info.attr_egress = 0; + info.partial_actions = 0; + + if (dp_netdev_partial_offload_supported(port, offload, &egress_port)) { + if (egress_port) { + netdev_close(port); + port = egress_port; + info.attr_egress = 1; + alloc_mark = false; + } + info.partial_actions = 1; + } + + if (alloc_mark && dp_netdev_alloc_flow_mark(flow, modification, &mark)) { /* flow already offloaded */ netdev_close(port); return 0; @@ -2448,17 +2639,21 @@ dp_netdev_flow_offload_put(struct dp_flow_offload_item *offload) goto err_free; } - if (!modification) { + if (info.partial_actions) { + flow->partial_actions_offloaded = true; + } else if (!modification) { megaflow_to_mark_associate(&flow->mega_ufid, mark); mark_to_flow_associate(mark, flow); } return 0; err_free: - if (!modification) { - netdev_offload_flow_mark_free(mark); - } else { - mark_to_flow_disassociate(pmd, flow); + if (mark != INVALID_FLOW_MARK) { + if (!modification) { + netdev_offload_flow_mark_free(mark); + } else { + mark_to_flow_disassociate(pmd, flow); + } } return -1; } @@ -2573,7 +2768,8 @@ dp_netdev_pmd_remove_flow(struct dp_netdev_pmd_thread *pmd, ovs_assert(cls != NULL); dpcls_remove(cls, &flow->cr); cmap_remove(&pmd->flow_table, node, dp_netdev_flow_hash(&flow->ufid)); - if (flow->mark != INVALID_FLOW_MARK) { + if (flow->mark != INVALID_FLOW_MARK || (flow->partial_actions_offloaded + && flow->egress_offload_port != ODPP_NONE)) { queue_netdev_flow_del(pmd, flow); } flow->dead = true; @@ -3325,6 +3521,8 @@ dp_netdev_flow_add(struct dp_netdev_pmd_thread *pmd, flow->dead = false; flow->batch = NULL; flow->mark = INVALID_FLOW_MARK; + flow->partial_actions_offloaded = false; + flow->egress_offload_port = ODPP_NONE; *CONST_CAST(unsigned *, &flow->pmd_id) = pmd->core_id; *CONST_CAST(struct flow *, &flow->flow) = match->flow; *CONST_CAST(ovs_u128 *, &flow->ufid) = *ufid; diff --git a/lib/netdev-offload-dpdk.c b/lib/netdev-offload-dpdk.c index 7be504688..44c5445c9 100644 --- a/lib/netdev-offload-dpdk.c +++ b/lib/netdev-offload-dpdk.c @@ -1698,7 +1698,8 @@ static int parse_clone_actions(struct netdev *netdev, struct flow_actions *actions, const struct nlattr *clone_actions, - const size_t clone_actions_len) + const size_t clone_actions_len, + struct offload_info *info) { const struct nlattr *ca; unsigned int cleft; @@ -1723,8 +1724,11 @@ parse_clone_actions(struct netdev *netdev, add_flow_action(actions, RTE_FLOW_ACTION_TYPE_RAW_ENCAP, raw_encap); } else if (clone_type == OVS_ACTION_ATTR_OUTPUT) { - if (add_output_action(netdev, actions, ca)) { - return -1; + /* add output action only if full-offload */ + if (!info->partial_actions) { + if (add_output_action(netdev, actions, ca)) { + return -1; + } } } else { VLOG_DBG_RL(&rl, @@ -1788,7 +1792,8 @@ parse_flow_actions(struct netdev *netdev, struct flow_actions *actions, struct nlattr *nl_actions, size_t nl_actions_len, - struct act_resources *act_resources) + struct act_resources *act_resources, + struct offload_info *info) { struct nlattr *nla; size_t left; @@ -1796,11 +1801,16 @@ parse_flow_actions(struct netdev *netdev, if (!strcmp(netdev_get_type(netdev), "vxlan")) { add_vxlan_decap_action(actions); } - add_count_action(actions); + if (!info->partial_actions) { + add_count_action(actions); + } NL_ATTR_FOR_EACH_UNSAFE (nla, left, nl_actions, nl_actions_len) { if (nl_attr_type(nla) == OVS_ACTION_ATTR_OUTPUT) { - if (add_output_action(netdev, actions, nla)) { - return -1; + /* add output action only if full-offload */ + if (!info->partial_actions) { + if (add_output_action(netdev, actions, nla)) { + return -1; + } } } else if (nl_attr_type(nla) == OVS_ACTION_ATTR_DROP) { free_flow_actions(actions); @@ -1821,7 +1831,7 @@ parse_flow_actions(struct netdev *netdev, size_t clone_actions_len = nl_attr_get_size(nla); if (parse_clone_actions(netdev, actions, clone_actions, - clone_actions_len)) { + clone_actions_len, info)) { return -1; } } else if (nl_attr_type(nla) == OVS_ACTION_ATTR_TUNNEL_POP) { @@ -1899,16 +1909,23 @@ netdev_offload_dpdk_actions(struct netdev *netdev, size_t actions_len, const ovs_u128 *ufid, struct act_resources *act_resources, - struct flows_handle *flows) + struct flows_handle *flows, + struct offload_info *info) { - const struct rte_flow_attr flow_attr = { .ingress = 1, .transfer = 1 }; + struct rte_flow_attr flow_attr = { .ingress = 1, .transfer = 1 }; struct flow_actions actions = { .actions = NULL, .cnt = 0 }; struct flow_item flow_item = { .devargs = NULL }; struct rte_flow_error error; int ret; + if (info->attr_egress) { + flow_attr.ingress = 0; + flow_attr.egress = 1; + flow_attr.transfer = 0; + } + ret = parse_flow_actions(netdev, &actions, nl_actions, actions_len, - act_resources); + act_resources, info); if (ret) { goto out; } @@ -1957,8 +1974,15 @@ netdev_offload_dpdk_add_flow(struct netdev *netdev, ret = netdev_offload_dpdk_actions(netdev, &patterns, nl_actions, actions_len, ufid, &act_resources, - &flows); - if (ret) { + &flows, info); + if (!ret) { + if (info->partial_actions && info->attr_egress) { + /* actions_offloaded should be set to false with partial actions, + * since it is still considered as partial-offload and not + * full-offload. */ + actions_offloaded = false; + } + } else if (!(info->partial_actions && info->attr_egress)) { /* If we failed to offload the rule actions fallback to MARK+RSS * actions. */ diff --git a/lib/netdev-offload.h b/lib/netdev-offload.h index d6dd98367..3c079cc9d 100644 --- a/lib/netdev-offload.h +++ b/lib/netdev-offload.h @@ -67,6 +67,8 @@ struct offload_info { bool recirc_id_shared_with_tc; /* Indicates whever tc chains will be in * sync with datapath recirc ids. */ + uint8_t attr_egress; /* Egress direction offload */ + uint8_t partial_actions; /* Partial action offload; no forward action */ /* * The flow mark id assigened to the flow. If any pkts hit the flow, From patchwork Mon May 18 19:27:30 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sriharsha Basavapatna X-Patchwork-Id: 1292762 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=openvswitch.org (client-ip=140.211.166.136; helo=silver.osuosl.org; envelope-from=ovs-dev-bounces@openvswitch.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=openvswitch.org Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=broadcom.com header.i=@broadcom.com header.a=rsa-sha256 header.s=google header.b=RMzSn0de; dkim-atps=neutral Received: from silver.osuosl.org (smtp3.osuosl.org [140.211.166.136]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 49QqQN5Jsbz9sT6 for ; Tue, 19 May 2020 05:51:24 +1000 (AEST) Received: from localhost (localhost [127.0.0.1]) by silver.osuosl.org (Postfix) with ESMTP id 3AE2C221D5; Mon, 18 May 2020 19:51:22 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from silver.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id a6tQMpT4GUq1; Mon, 18 May 2020 19:51:17 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by silver.osuosl.org (Postfix) with ESMTP id 757F822170; Mon, 18 May 2020 19:51:17 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 470E9C0888; Mon, 18 May 2020 19:51:17 +0000 (UTC) X-Original-To: dev@openvswitch.org Delivered-To: ovs-dev@lists.linuxfoundation.org Received: from silver.osuosl.org (smtp3.osuosl.org [140.211.166.136]) by lists.linuxfoundation.org (Postfix) with ESMTP id 257A4C07FF for ; Mon, 18 May 2020 19:51:16 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by silver.osuosl.org (Postfix) with ESMTP id 0372D221AB for ; Mon, 18 May 2020 19:51:16 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from silver.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id BwVLZ6cklYyn for ; Mon, 18 May 2020 19:51:11 +0000 (UTC) X-Greylist: from auto-whitelisted by SQLgrey-1.7.6 Received: from mail-wr1-f67.google.com (mail-wr1-f67.google.com [209.85.221.67]) by silver.osuosl.org (Postfix) with ESMTPS id 3410E22170 for ; Mon, 18 May 2020 19:51:11 +0000 (UTC) Received: by mail-wr1-f67.google.com with SMTP id 50so13212153wrc.11 for ; Mon, 18 May 2020 12:51:11 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=broadcom.com; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=BQNm64OzwiFMf2YxNRUFBiw5hsG8ym6vnPxqlGf76T8=; b=RMzSn0deNOz5dO37y8vMima8WYKWUhPWOdsj3lZ32lhuuib11FUiKYsy1EOX/nrsTx 3CyWG0+FWxCSxlVUZwiqoVOtU1St9JXsxyuzbJ2Ted0Ld4tH6YCjAwc9u9XWpckyTVbW eZIP2QVtdXPNRbk2cqUjHQrrCTGKkSjw3nGyM= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=BQNm64OzwiFMf2YxNRUFBiw5hsG8ym6vnPxqlGf76T8=; b=rQZApR4q8m55qNGkM8bYkaUR2VzmTxI95pmXnxelDYT9anALLrECcXXR4cI1hIveEZ 6a3hYzxOsSyHxM+VU18b6305N8+khnEVTTqRPmJPnyPedrd5F+Jwt8xWFgUl3bEK5+sS 9FLPYImwtT73uq0KZ0aWXyDIuk53sc6Jh0mzWcILFfY3iuVBzoWV6cDZ+ARQk4ZlFCo8 8WZfANyyly0DIzhUqITfWiCnfSqDbE2QozX0G349n/p7LkBrRXb+JayU/8pKLKbakcJj dvmI7eoGxkEyudJ8GFMqAyq9NJkJIVIm5ChlXM4I5Rj0kcIQ/K9AUiZGO2VTB1UUNNhI YjLw== X-Gm-Message-State: AOAM533ZwxKDSLm5rj4avRCkt2km1nRz5omTmydHhadV2B/vThVJ9271 0e4wFvCba5teAf4OgOBYBOVhLKy8UK3iTSPc9boFmvR39AvzAmV/t6rRpG/eQ/dq8xZ5aJbHcBC Zv8dQzyGYKqlOmP7SwJOdPu7/RlZvebrtb/jdZbUQf9GocszI5ffP29jDZhkjzWfkYZRJR2Ys38 G3z/vu X-Google-Smtp-Source: ABdhPJwtS2O1pQViTYaUkGSn2TEL2TYlpm+rxBcYkvSyc/nkVrvje7mPf3L+twDi0bYWDhskxL5bQQ== X-Received: by 2002:adf:f4c4:: with SMTP id h4mr21863910wrp.142.1589830075872; Mon, 18 May 2020 12:27:55 -0700 (PDT) Received: from dhcp-10-123-153-36.dhcp.broadcom.net ([192.19.234.250]) by smtp.gmail.com with ESMTPSA id z18sm590153wmk.46.2020.05.18.12.27.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 May 2020 12:27:55 -0700 (PDT) To: dev@openvswitch.org Date: Mon, 18 May 2020 15:27:30 -0400 Message-Id: <20200518192731.30804-5-sriharsha.basavapatna@broadcom.com> X-Mailer: git-send-email 2.25.0.rc2 In-Reply-To: <20200518192731.30804-1-sriharsha.basavapatna@broadcom.com> References: <20200518192731.30804-1-sriharsha.basavapatna@broadcom.com> MIME-Version: 1.0 Subject: [ovs-dev] [RFC v2 PATCH 4/5] dpif-netdev: Skip encap action during datapath execution X-BeenThere: ovs-dev@openvswitch.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Sriharsha Basavapatna via dev From: Sriharsha Basavapatna Reply-To: Sriharsha Basavapatna Errors-To: ovs-dev-bounces@openvswitch.org Sender: "dev" In this patch we check if action processing (apart from OUTPUT action), should be skipped for a given dp_netdev_flow. Specifically, we check if the action is TNL_PUSH and if it has been offloaded to HW, then we do not push the tunnel header in SW. The datapath only executes the OUTPUT action. The packet will be encapsulated in HW during transmit. Signed-off-by: Sriharsha Basavapatna --- lib/dpif-netdev.c | 247 +++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 224 insertions(+), 23 deletions(-) diff --git a/lib/dpif-netdev.c b/lib/dpif-netdev.c index 4315f237c..07d16ad61 100644 --- a/lib/dpif-netdev.c +++ b/lib/dpif-netdev.c @@ -112,6 +112,7 @@ COVERAGE_DEFINE(datapath_drop_recirc_error); COVERAGE_DEFINE(datapath_drop_invalid_port); COVERAGE_DEFINE(datapath_drop_invalid_tnl_port); COVERAGE_DEFINE(datapath_drop_rx_invalid_packet); +COVERAGE_DEFINE(datapath_skip_tunnel_push); /* Protects against changes to 'dp_netdevs'. */ static struct ovs_mutex dp_netdev_mutex = OVS_MUTEX_INITIALIZER; @@ -547,6 +548,7 @@ struct dp_netdev_flow { */ bool partial_actions_offloaded; odp_port_t egress_offload_port; + struct ovs_mutex partial_action_offload_mutex; /* Statistics. */ struct dp_netdev_flow_stats stats; @@ -801,7 +803,8 @@ static void dp_netdev_execute_actions(struct dp_netdev_pmd_thread *pmd, bool should_steal, const struct flow *flow, const struct nlattr *actions, - size_t actions_len); + size_t actions_len, + const struct dp_netdev_flow *dp_flow); static void dp_netdev_input(struct dp_netdev_pmd_thread *, struct dp_packet_batch *, odp_port_t port_no); static void dp_netdev_recirculate(struct dp_netdev_pmd_thread *, @@ -2361,17 +2364,159 @@ dp_netdev_append_flow_offload(struct dp_flow_offload_item *offload) ovs_mutex_unlock(&dp_flow_offload.mutex); } +/* + * Mapping structure to map ufid to a partial offload egress device. + * Synchronization: accessed only in the context of the offload thread. + */ +struct ufid_to_egdev_data { + const struct cmap_node node; /* link to cmap */ + ovs_u128 mega_ufid; /* mega-ufid being mapped */ + odp_port_t egress_port_num; /* Port number mapped to */ + struct dp_netdev_flow *flow; /* flow that maps to this ufid */ +}; + +/* + * A mapping from mega-ufid to partial-offload egress-device. + */ +static struct cmap ufid_to_egdev = CMAP_INITIALIZER; + +static uint32_t +ufid_to_egdev_refcnt(const ovs_u128 *mega_ufid) +{ + size_t hash = hash_bytes(mega_ufid, sizeof *mega_ufid, 0); + struct ufid_to_egdev_data *data; + uint32_t refcnt = 0; + + CMAP_FOR_EACH_WITH_HASH (data, node, hash, &ufid_to_egdev) { + if (ovs_u128_equals(*mega_ufid, data->mega_ufid)) { + refcnt++; + } + } + + return refcnt; +} + +/* Find egdev_data @(ufid, flow) */ +static struct ufid_to_egdev_data * +ufid_to_egdev_data_find(const ovs_u128 *ufid, + const struct dp_netdev_flow *flow) +{ + size_t hash = hash_bytes(ufid, sizeof *ufid, 0); + struct ufid_to_egdev_data *data; + + CMAP_FOR_EACH_WITH_HASH (data, node, hash, &ufid_to_egdev) { + if (data->flow == flow && ovs_u128_equals(*ufid, data->mega_ufid)) { + return data; + } + } + + return NULL; +} + +/* Map the given pair of mega-ufid and flow to the given port. Returns 0 + * when the mapping is created initially in the context of a flow. For + * subsequent calls, if it is a new flow with the same mega-ufid, creates + * a mapping entry but returns EEXIST (i.e, at least one other flow with + * the same ufid exists in the table). If it is an already mapped mega-ufid + * & flow pair, returns EEXIST. + */ static int -partial_offload_egress_flow_del(struct dp_netdev_pmd_thread *pmd, - struct dp_netdev_flow *flow) +map_ufid_to_egdev(const ovs_u128 *mega_ufid, + const struct dp_netdev_flow *flow, + odp_port_t egress_port_num) +{ + struct ufid_to_egdev_data *data; + size_t hash; + + data = ufid_to_egdev_data_find(mega_ufid, flow); + if (data) { + /* mapping already exists for the given pair */ + VLOG_DBG_RL("ufid_to_egdev mapping already exists for flow: %p\n", + flow); + return EEXIST; + } + + data = xzalloc(sizeof *data); + data->mega_ufid = *mega_ufid; + data->egress_port_num = egress_port_num; + data->flow = flow; + + hash = hash_bytes(mega_ufid, sizeof *mega_ufid, 0); + cmap_insert(&ufid_to_egdev, + CONST_CAST(struct cmap_node *, &data->node), hash); + + if (ufid_to_egdev_refcnt(mega_ufid) > 1) { + /* at least one mapping exists for the mega_ufid */ + VLOG_DBG_RL("At least one ufid_to_egdev mapping exists, flow: %p\n", + flow); + return EEXIST; + } + + /* first mapping created for the mega_ufid */ + VLOG_DBG_RL("Created the first ufid_to_egdev mapping; flow: %p\n", flow); + return 0; +} + +static uint32_t +unmap_ufid_to_egdev(const ovs_u128 *mega_ufid, + const struct dp_netdev_flow *flow) { - int ret; - struct netdev *port; - odp_port_t out_port = flow->egress_offload_port; + struct ufid_to_egdev_data *data; + uint32_t refcnt; + size_t hash; + + data = ufid_to_egdev_data_find(mega_ufid, flow); + ovs_assert(data); + + hash = hash_bytes(&data->mega_ufid, sizeof data->mega_ufid, 0); + cmap_remove(&ufid_to_egdev, + CONST_CAST(struct cmap_node *, &data->node), hash); + ovsrcu_postpone(free, data); + + refcnt = ufid_to_egdev_refcnt(mega_ufid); + VLOG_DBG_RL("Unmapped ufid_to_egdev: flow: %p, refcnt: %d\n", + flow, refcnt); + + return refcnt; +} + +static inline void +partial_action_offload_lock(struct dp_netdev_flow *flow) +{ + ovs_mutex_lock(&flow->partial_action_offload_mutex); +} + +static inline void +partial_action_offload_unlock(struct dp_netdev_flow *flow) +{ + ovs_mutex_unlock(&flow->partial_action_offload_mutex); +} + +static int +partial_offload_egress_flow_del(struct dp_flow_offload_item *offload) +{ + struct dp_netdev_pmd_thread *pmd = offload->pmd; + struct dp_netdev_flow *flow = offload->flow; const char *dpif_type_str = dpif_normalize_type(pmd->dp->class->type); + struct netdev *port; + uint32_t refcnt; + int ret; + + partial_action_offload_lock(offload->flow); + refcnt = unmap_ufid_to_egdev(&flow->mega_ufid, offload->flow); + if (refcnt) { + flow->egress_offload_port = NULL; + flow->partial_actions_offloaded = false; + partial_action_offload_unlock(flow); + return 0; + } - port = netdev_ports_get(out_port, dpif_type_str); + /* The egress dev is not referenced by any flow with the given ufid. + * We can now remove the partial-action egress-flow from hardware. + */ + port = netdev_ports_get(flow->egress_offload_port, dpif_type_str); if (!port) { + partial_action_offload_unlock(flow); return -1; } @@ -2382,15 +2527,27 @@ partial_offload_egress_flow_del(struct dp_netdev_pmd_thread *pmd, ovs_mutex_unlock(&pmd->dp->port_mutex); netdev_close(port); + if (ret) { + partial_action_offload_unlock(flow); + return ret; + } + + flow->egress_offload_port = NULL; + flow->partial_actions_offloaded = false; + + partial_action_offload_unlock(offload->flow); + + VLOG_DBG_RL("Deleted partial_offloaded egress flow: %p pmd: %p id: %d\n", + flow, pmd, offload->flow->pmd_id); return ret; } static int dp_netdev_flow_offload_del(struct dp_flow_offload_item *offload) { - if (offload->flow->partial_actions_offloaded && - offload->flow->egress_offload_port != ODPP_NONE) { - return partial_offload_egress_flow_del(offload->pmd, offload->flow); + if (unlikely(offload->flow->partial_actions_offloaded && + offload->flow->egress_offload_port != ODPP_NONE)) { + return partial_offload_egress_flow_del(offload); } else { return mark_to_flow_disassociate(offload->pmd, offload->flow); } @@ -2608,7 +2765,8 @@ dp_netdev_flow_offload_put(struct dp_flow_offload_item *offload) info.attr_egress = 0; info.partial_actions = 0; - if (dp_netdev_partial_offload_supported(port, offload, &egress_port)) { + if (unlikely(dp_netdev_partial_offload_supported(port, offload, + &egress_port))) { if (egress_port) { netdev_close(port); port = egress_port; @@ -2618,11 +2776,25 @@ dp_netdev_flow_offload_put(struct dp_flow_offload_item *offload) info.partial_actions = 1; } - if (alloc_mark && dp_netdev_alloc_flow_mark(flow, modification, &mark)) { - /* flow already offloaded */ + if (unlikely(info.partial_actions && egress_port)) { + partial_action_offload_lock(flow); + if (map_ufid_to_egdev(&flow->mega_ufid, flow, + flow->egress_offload_port) == EEXIST) { + /* Partial action already offloaded for the ufid+egdev */ + flow->partial_actions_offloaded = true; + partial_action_offload_unlock(flow); netdev_close(port); + VLOG_DBG_RL("Partial offload exists, flow: %p pmd: %p id: %d\n", + flow, offload->pmd, flow->pmd_id); return 0; + } + } else if (alloc_mark && + dp_netdev_alloc_flow_mark(flow, modification, &mark)) { + /* flow already offloaded */ + netdev_close(port); + return 0; } + info.flow_mark = mark; /* Taking a global 'port_mutex' to fulfill thread safety restrictions for @@ -2639,15 +2811,25 @@ dp_netdev_flow_offload_put(struct dp_flow_offload_item *offload) goto err_free; } - if (info.partial_actions) { + if (unlikely(info.partial_actions && egress_port)) { flow->partial_actions_offloaded = true; + VLOG_DBG_RL("Partial offloaded (egress) flow: %p pmd: %p id: %d\n", + flow, offload->pmd, flow->pmd_id); + partial_action_offload_unlock(flow); } else if (!modification) { megaflow_to_mark_associate(&flow->mega_ufid, mark); mark_to_flow_associate(mark, flow); } + return 0; err_free: + if (unlikely(info.partial_actions) && egress_port) { + VLOG_DBG_RL("Partial offload(egress) failed flow: %p pmd: %p id: %d\n", + flow, offload->pmd, flow->pmd_id); + unmap_ufid_to_egdev(&flow->mega_ufid, offload->flow); + partial_action_offload_unlock(flow); + } if (mark != INVALID_FLOW_MARK) { if (!modification) { netdev_offload_flow_mark_free(mark); @@ -3523,6 +3705,7 @@ dp_netdev_flow_add(struct dp_netdev_pmd_thread *pmd, flow->mark = INVALID_FLOW_MARK; flow->partial_actions_offloaded = false; flow->egress_offload_port = ODPP_NONE; + ovs_mutex_init(&flow->partial_action_offload_mutex); *CONST_CAST(unsigned *, &flow->pmd_id) = pmd->core_id; *CONST_CAST(struct flow *, &flow->flow) = match->flow; *CONST_CAST(ovs_u128 *, &flow->ufid) = *ufid; @@ -4026,7 +4209,7 @@ dpif_netdev_execute(struct dpif *dpif, struct dpif_execute *execute) dp_packet_batch_init_packet(&pp, execute->packet); pp.do_not_steal = true; dp_netdev_execute_actions(pmd, &pp, false, execute->flow, - execute->actions, execute->actions_len); + execute->actions, execute->actions_len, NULL); dp_netdev_pmd_flush_output_packets(pmd, true); if (pmd->core_id == NON_PMD_CORE_ID) { @@ -6654,7 +6837,7 @@ packet_batch_per_flow_execute(struct packet_batch_per_flow *batch, actions = dp_netdev_flow_get_actions(flow); dp_netdev_execute_actions(pmd, &batch->array, true, &flow->flow, - actions->actions, actions->size); + actions->actions, actions->size, flow); } static inline void @@ -6962,7 +7145,7 @@ handle_packet_upcall(struct dp_netdev_pmd_thread *pmd, * we'll send the packet up twice. */ dp_packet_batch_init_packet(&b, packet); dp_netdev_execute_actions(pmd, &b, true, &match.flow, - actions->data, actions->size); + actions->data, actions->size, NULL); add_actions = put_actions->size ? put_actions : actions; if (OVS_LIKELY(error != ENOSPC)) { @@ -7197,6 +7380,7 @@ dp_netdev_recirculate(struct dp_netdev_pmd_thread *pmd, struct dp_netdev_execute_aux { struct dp_netdev_pmd_thread *pmd; const struct flow *flow; + const void *dp_flow; /* for partial action offload */ }; static void @@ -7341,7 +7525,7 @@ dp_execute_userspace_action(struct dp_netdev_pmd_thread *pmd, if (!error || error == ENOSPC) { dp_packet_batch_init_packet(&b, packet); dp_netdev_execute_actions(pmd, &b, should_steal, flow, - actions->data, actions->size); + actions->data, actions->size, NULL); } else if (should_steal) { dp_packet_delete(packet); COVERAGE_INC(datapath_drop_userspace_action_error); @@ -7360,6 +7544,7 @@ dp_execute_cb(void *aux_, struct dp_packet_batch *packets_, int type = nl_attr_type(a); struct tx_port *p; uint32_t packet_count, packets_dropped; + struct dp_netdev_flow *dp_flow = aux->dp_flow; switch ((enum ovs_action_attr)type) { case OVS_ACTION_ATTR_OUTPUT: @@ -7417,9 +7602,24 @@ dp_execute_cb(void *aux_, struct dp_packet_batch *packets_, } dp_packet_batch_apply_cutlen(packets_); packet_count = dp_packet_batch_size(packets_); - if (push_tnl_action(pmd, a, packets_)) { - COVERAGE_ADD(datapath_drop_tunnel_push_error, - packet_count); + /* Execute tnl_push action in SW, only if it is not offloaded + * as a partial action in HW. Otherwise, HW pushes the tunnel + * header during output processing. */ + if (likely(!netdev_is_flow_api_enabled() || !dp_flow)) { + if (push_tnl_action(pmd, a, packets_)) { + COVERAGE_ADD(datapath_drop_tunnel_push_error, packet_count); + } + } else { /* netdev_flow_api_enabled && dp_flow */ + partial_action_offload_lock(dp_flow); + if (!dp_flow->partial_actions_offloaded) { + if (push_tnl_action(pmd, a, packets_)) { + COVERAGE_ADD(datapath_drop_tunnel_push_error, + packet_count); + } + } else { + COVERAGE_ADD(datapath_skip_tunnel_push, packet_count); + } + partial_action_offload_unlock(dp_flow); } return; @@ -7707,9 +7907,10 @@ static void dp_netdev_execute_actions(struct dp_netdev_pmd_thread *pmd, struct dp_packet_batch *packets, bool should_steal, const struct flow *flow, - const struct nlattr *actions, size_t actions_len) + const struct nlattr *actions, size_t actions_len, + const struct dp_netdev_flow *dp_flow) { - struct dp_netdev_execute_aux aux = { pmd, flow }; + struct dp_netdev_execute_aux aux = { pmd, flow, dp_flow }; odp_execute_actions(&aux, packets, should_steal, actions, actions_len, dp_execute_cb); From patchwork Mon May 18 19:27:31 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sriharsha Basavapatna X-Patchwork-Id: 1292744 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=openvswitch.org (client-ip=140.211.166.137; helo=fraxinus.osuosl.org; envelope-from=ovs-dev-bounces@openvswitch.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=openvswitch.org Authentication-Results: ozlabs.org; dkim=fail reason="signature verification failed" (1024-bit key; unprotected) header.d=broadcom.com header.i=@broadcom.com header.a=rsa-sha256 header.s=google header.b=BPm/U6h2; dkim-atps=neutral Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 49Qq3g2SbZz9sT6 for ; Tue, 19 May 2020 05:35:10 +1000 (AEST) Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id 9503886CB2; Mon, 18 May 2020 19:35:08 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 4sKLQaRC0uvQ; Mon, 18 May 2020 19:35:04 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by fraxinus.osuosl.org (Postfix) with ESMTP id BE21986C6D; Mon, 18 May 2020 19:35:04 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id 8B0B9C0888; Mon, 18 May 2020 19:35:04 +0000 (UTC) X-Original-To: dev@openvswitch.org Delivered-To: ovs-dev@lists.linuxfoundation.org Received: from fraxinus.osuosl.org (smtp4.osuosl.org [140.211.166.137]) by lists.linuxfoundation.org (Postfix) with ESMTP id DF778C07FF for ; Mon, 18 May 2020 19:35:02 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by fraxinus.osuosl.org (Postfix) with ESMTP id CE03886C72 for ; Mon, 18 May 2020 19:35:02 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from fraxinus.osuosl.org ([127.0.0.1]) by localhost (.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 6l9tL69AGEcB for ; Mon, 18 May 2020 19:34:58 +0000 (UTC) X-Greylist: delayed 00:07:00 by SQLgrey-1.7.6 Received: from mail-wr1-f68.google.com (mail-wr1-f68.google.com [209.85.221.68]) by fraxinus.osuosl.org (Postfix) with ESMTPS id 52FB286C6D for ; Mon, 18 May 2020 19:34:58 +0000 (UTC) Received: by mail-wr1-f68.google.com with SMTP id e16so13206215wra.7 for ; Mon, 18 May 2020 12:34:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=broadcom.com; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=3wbi76rZGas0BNCErVDcQMa+92hkvZSksSomE0tMch8=; b=BPm/U6h2/QbB0HKw4naIXmF2YSBEA1sMYlHL+i7kY8mBAOIw8I/smUSh7j/IJOH9Y0 SG9HRnlKpWjqyUM+PQjg64/bWyIi2hrnq03qBHGsfh8hpBXQjXNTk1a7COysMOVuAHyN InVDlKvfAFSzLg61XZ7BHMsvmromSU/jJnkpQ= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=3wbi76rZGas0BNCErVDcQMa+92hkvZSksSomE0tMch8=; b=pNZrsfPs9uPgcEOsnqpZlKLLQV6GjD086Fj0/Vmfrcy+Jys398UiKlHBK5Y1RusZp+ aQXEfNDAfBe8PIus9/ODuYpy4bV87V1vN/iRnMOSgOVX1NrpkxByHcYYGhbKpnVCscaP tNsU4wLdGqlG8e+ukmxeqfZoQMnP+GiSHLISGg1VJyvQ8/QGqctXzYdUPF0Pva+bZHcw /hdrc3valSIJEu+IgtNS8Joo70VoXUu9k/fG/3tLRgdfL9fKg23muVbfQtzhGBWMCCAh fr4kc8n1TabZr8DvOkeXh7cnbKnx8XKbKq7Hj30C5DX3Jxzcdf3//PHJtFijOtt3SCi5 Wwvg== X-Gm-Message-State: AOAM532P7tWh/VoAksuhPLlxWKVqXn49B6HwUHWKCKwZsdfDXS+AQ5EL XyDkDLdUH2iEVXItTea3Kq2IA2CbS6PIzszYR5lkXvm76qsrrY+NGKwsXU/wQb4fGGZK9N7qv3C dr2ismHARSXb1WBQ0Wqged5HHkMqanZlf21qzZ511n5sdN5/yZxUQHwDznrLuz48HvkYweaqm67 zm5smp X-Google-Smtp-Source: ABdhPJzECol1JfyluzIAQJhmVhFPFo3+ej73FQJqlVJZxoCfdunIpOXdMzRELdtyK+GRedMX1BMhNw== X-Received: by 2002:adf:97db:: with SMTP id t27mr18636432wrb.261.1589830078242; Mon, 18 May 2020 12:27:58 -0700 (PDT) Received: from dhcp-10-123-153-36.dhcp.broadcom.net ([192.19.234.250]) by smtp.gmail.com with ESMTPSA id z18sm590153wmk.46.2020.05.18.12.27.56 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 May 2020 12:27:57 -0700 (PDT) To: dev@openvswitch.org Date: Mon, 18 May 2020 15:27:31 -0400 Message-Id: <20200518192731.30804-6-sriharsha.basavapatna@broadcom.com> X-Mailer: git-send-email 2.25.0.rc2 In-Reply-To: <20200518192731.30804-1-sriharsha.basavapatna@broadcom.com> References: <20200518192731.30804-1-sriharsha.basavapatna@broadcom.com> MIME-Version: 1.0 Subject: [ovs-dev] [RFC v2 PATCH 5/5] dpif-netdev: Support flow_get() with partial-action-offload X-BeenThere: ovs-dev@openvswitch.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Sriharsha Basavapatna via dev From: Sriharsha Basavapatna Reply-To: Sriharsha Basavapatna Errors-To: ovs-dev-bounces@openvswitch.org Sender: "dev" For flows that offload partial actions in egress direction, provide the right netdev to fetch statistics. Signed-off-by: Sriharsha Basavapatna --- lib/dpif-netdev.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/lib/dpif-netdev.c b/lib/dpif-netdev.c index 07d16ad61..6b7075641 100644 --- a/lib/dpif-netdev.c +++ b/lib/dpif-netdev.c @@ -3420,8 +3420,14 @@ dpif_netdev_get_flow_offload_status(const struct dp_netdev *dp, return false; } - netdev = netdev_ports_get(netdev_flow->flow.in_port.odp_port, - dpif_normalize_type(dp->class->type)); + if (netdev_flow->partial_actions_offloaded && + netdev_flow->egress_offload_port != ODPP_NONE) { + netdev = netdev_ports_get(netdev_flow->egress_offload_port, + dpif_normalize_type(dp->class->type)); + } else { + netdev = netdev_ports_get(netdev_flow->flow.in_port.odp_port, + dpif_normalize_type(dp->class->type)); + } if (!netdev) { return false; }