From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR03-DB5-obe.outbound.protection.outlook.com (mail-eopbgr40084.outbound.protection.outlook.com [40.107.4.84]) by dpdk.org (Postfix) with ESMTP id E201FA48C for ; Sat, 20 Jan 2018 22:11:53 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=Mellanox.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=e+yT/5aEL5gQ5vBJdE34HuF3tcticc2Utvde4xyPlFU=; b=w2xdYaVBrDu6kpmQlRNV9TkHBHGKVF9SuwzNNMdDkkpOsn5PSKr/QU/xA2LZytz8NvRBsCgrknZVrTyIlPq3hj73CcK9fgi8S+BMmRPOsz/mZqagIW1svN5V1AkTAh+VxBaBqiRFOUJ1ztk9jhcNwboUXOhuXNIJRduLAIMF/Nw= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=ophirmu@mellanox.com; Received: from mellanox.com (37.142.13.130) by AM0PR0502MB3875.eurprd05.prod.outlook.com (2603:10a6:208:20::17) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256) id 15.20.407.7; Sat, 20 Jan 2018 21:11:52 +0000 From: Ophir Munk To: dev@dpdk.org, Pascal Mazon Cc: Thomas Monjalon , Olga Shern , Ophir Munk Date: Sat, 20 Jan 2018 21:11:35 +0000 Message-Id: <1516482697-8348-5-git-send-email-ophirmu@mellanox.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1516482697-8348-1-git-send-email-ophirmu@mellanox.com> References: <1516282691-29698-1-git-send-email-ophirmu@mellanox.com> <1516482697-8348-1-git-send-email-ophirmu@mellanox.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [37.142.13.130] X-ClientProxiedBy: VI1PR08CA0212.eurprd08.prod.outlook.com (2603:10a6:802:15::21) To AM0PR0502MB3875.eurprd05.prod.outlook.com (2603:10a6:208:20::17) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-MS-Office365-Filtering-Correlation-Id: 71c285e8-f694-45c4-9173-08d5604a6dd8 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(7020095)(4652020)(48565401081)(5600026)(4604075)(2017052603307)(7153060)(7193020); SRVR:AM0PR0502MB3875; X-Microsoft-Exchange-Diagnostics: 1; AM0PR0502MB3875; 3:XxakJuQpuhu2CrF1iv6VnFbvj6hbyVz3tkewtbg6aPNcRYVQfGVcUtXflyjwG02kqNRjKRTlQ31VQ6pcLUxjKNHZSc9bPzu1GO5Xh4M4cCjqX0yDgPrEQxKuUFSPI4ocS84pvXZfx4frfyk3KdiccQg7iKJ3EQwjpXPTjMepSFG1QfFmCjmf89w/GreQ8VMtdzbh/XPjoeVXsih925447DzsPN0T7mTZPR/M1DlIFXzglCzznLT8pUzwXU9NKAbS; 25:vnOT+4CM/zS3Lautoqeu6NtQ63dejpUHHTAtTqhsQsnTK/YHRt6PwKlxQOvXJ9B1s88q7nzF09QKXNptoVZiO4+FiuZbYkthGPFN5NxHl+vXAHfc7Ceo7xl4IF7LHuxFudHkSiPjMW/CoDw4OGF8At8WxdVe8MWTKTpCaBkB8hyCnBOymZUGyrp7Yxai/dyeaDzTrdEOHHAQ2Gi4r/VR1JbwhMczzT1O47GuvvqywMhg9s8Khi8QWjSoUkTwNl2l6RftIEvCR3JzyzZ0D12C4gPWQ91JB7Lb71xqFX+igR7cRMX/gxQBOyBdx0YgvrbYhFE9FZqHiGOajCAFQyB3Kw==; 31:hQgLETAKnI/NNXQRd5JhWM/husdSk2HQCF9NfvNrLOSYS7BSeTeDEYvYDOhwlMiJG5gcM6ynQA7MExWlGnVTvpIuXuErexmCt5kyC8kxeV0pJuEINQh/B65CSkeSwcL8tiufuCKmjFL+Cx24sKS3noC5IAn5Ai09mxyXVBO+vvoMUkp/ZcnaG18ERb1eAgKhJGQd3W8JI3gYNpiFGxQ7gTadN2yHT5OsTWp9j93L27w= X-MS-TrafficTypeDiagnostic: AM0PR0502MB3875: X-LD-Processed: a652971c-7d2e-4d9b-a6a4-d149256f461b,ExtAddr X-Microsoft-Exchange-Diagnostics: 1; AM0PR0502MB3875; 20:SxgYz/I2bFuEXUAJIz/nMGVySH43VRjT+WW/MS/LHni5hopLz2s0mUNYZj5KZimI4KWDLGZ55b0hv8ogTEHEDArWz61cKDKA9ScDSdriEkUszrd+wXJ5nwYW0NNfywtDGNCN7LNRi2xdE4HYPRrNzCoDCVPOjPmyMsLmyOO17t6wtd4pV5EPDRS9xaSS00pCw0AzialFpgj22+X7ykAMOpUubCH2RTe8d3cSqIzIj1UtfrGR8mWD6nywH3fFHTJTPGHRZNS+vRZMDJ8eLRQVLOj0CPJkC6ggyU+lWtPpWaHjvRXQnCMrIesnOFhnHWjTEhcj/D0OJnRwus3Oc6FCA80sq0Oc3LSaLPo2a+jwiawYdp9Rq+pIZ5R0+433qEXfnzEWb1Us/+IOem2S+IEJ7NcLSuz9Mw+UjTrT8T8bp1W9+y42LquiCO/UjwtS1nw7SlEw2WqQdAEIRkkGaOmYavD9nlIL8TsD0XFCmL22sdVeFHjX50ygvA/UYsB194n3; 4:tjQRI4YHsiX9baJuQOmmlc3KYHr7hSJY1QisQ9VfvjuXxY8SSpOckt4EVqryf6cs3BdTD9SrJZ4CIwViEczpW6P6WP3LYZZWziqaFWUABaN4h/bYk4TaTh6sahdNqioL5hh1NMJuGkxWxK2VBvRtT38yeRmKGhaobn1yUWTOFlAFzsWTx1lFGJ7BS8lES+mKuH5ttG2yfrqJFporjCYllwn7jcqVIKkkgAWvi6vFsyg8+OE6sBA6wiW+Ti0XdX5cxdR5K/F+PQijzemGADeYag== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(6040501)(2401047)(8121501046)(5005006)(3231023)(2400081)(944501161)(93006095)(93001095)(10201501046)(3002001)(6055026)(6041288)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123560045)(20161123564045)(20161123558120)(20161123562045)(6072148)(201708071742011); SRVR:AM0PR0502MB3875; BCL:0; PCL:0; RULEID:(100000803101)(100110400095); SRVR:AM0PR0502MB3875; X-Forefront-PRVS: 0558D3C5AC X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(39860400002)(366004)(396003)(346002)(39380400002)(376002)(189003)(199004)(25786009)(4326008)(478600001)(7696005)(66066001)(47776003)(107886003)(76176011)(52116002)(51416003)(97736004)(2906002)(21086003)(26005)(316002)(54906003)(86362001)(16586007)(16526018)(8676002)(81166006)(81156014)(59450400001)(5660300001)(50226002)(3846002)(36756003)(69596002)(7736002)(305945005)(386003)(6116002)(6666003)(105586002)(6916009)(4720700003)(50466002)(53936002)(33026002)(68736007)(2950100002)(106356001)(8936002)(48376002)(55016002); DIR:OUT; SFP:1101; SCL:1; SRVR:AM0PR0502MB3875; H:mellanox.com; FPR:; SPF:None; PTR:InfoNoRecords; MX:1; A:1; LANG:en; Received-SPF: None (protection.outlook.com: mellanox.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; AM0PR0502MB3875; 23:ie1wGGtimU7ySC3yzkOslFlRm1yLi9mWiMwesyk?= =?us-ascii?Q?gGR1veXheE/7GV4bBc9HZMXeNkvC3LLx3HFvkQ+gcYPpKY1vyWocQB+CQFzX?= =?us-ascii?Q?SlZoc4dd/mzXeNISMdk/QcX046ltLcgOq0HIeGTrcX7s/OZgeHUoS+W0hK7R?= =?us-ascii?Q?rGmplOZ8clZrxnQWlIPH/6MVJTDSAIAQ0wIuNIOOX3/+0iR6cY57URf4Twzw?= =?us-ascii?Q?iA4w5Nd+2PI8Gps5aYwflIY96bV0eZ9g+kJjaP4ERAMEpx1DbmajKEfQ7OPU?= =?us-ascii?Q?XvXfZgdV/+x1jggiCHt6W2yIo66s7sx/5g0WRQYo4T81zYY9ZtT6CMCzEPtE?= =?us-ascii?Q?zw+BuzYxeT21HXddjS0puuqYAaoCzIaxfMrPJeQZPUfyrml3bfFQUL8vgmaO?= =?us-ascii?Q?ZkRoVzm4/OREVzXDCs/zi1pvdte+NQxR6AlTqFubXT9L0Eu4xe8oA1thILmA?= =?us-ascii?Q?RkNB9o6RTKoRp+bzBE6lmdsa+z/cvvHKSwPhm4WbfTS4099Js7Kswm2PXAhG?= =?us-ascii?Q?kMTC+mGurQRY4PkEIWwDKOKXwoB/kENHVnY/QoEn5pVaWDEDM16xcQvTu4Ih?= =?us-ascii?Q?GXhG2pedDOmHpFqlU+JgmRY/1l53fafGpInTSCNXrebo0bQZ9wKJejfq48Eu?= =?us-ascii?Q?pEqBVgsKg0FM8V7FyynWrrOxPCszyPUL9OBwaXTbUPVe6Qu42/urIm9xFxUm?= =?us-ascii?Q?VptyCgdDi10gp/hawmKyhGQ6c3eKCzNNr+252lTIR/7h47+2s/NRexUXkbjD?= =?us-ascii?Q?9cd26macZX5+ZPe8GsN9WD+vn/Ku0JkPhkLXPQHdVZigcBtRkhkrBz0S6Fc0?= =?us-ascii?Q?JOYML0HJcPDrHDRBYtNyfOjjF7z3iKqwN12alIdJQfxaZrUPIX6h5jlXB2Sd?= =?us-ascii?Q?0vFRyKaBQkfl5Tl8vBEaDMW9+GQjoELEaWC/SsxiI+iuc3puVKhVdFRCd1aK?= =?us-ascii?Q?iyKtMbMqAmVS7zEnj2SErKaphs4y2xGBu5kzT0jUoEH3pqw2Pt3z2Hn760Mz?= =?us-ascii?Q?5qK3xfVHdJWCHftWCBKbQ5WWtKtnqeF7Fuvre/nkSB3a7ikiJm9mcccsjcaH?= =?us-ascii?Q?DP/KUMLIfGS1uA+OV9WRJzil6dioRW0qegp0xIi0LV+9lv3ryQSmz/MQdzSu?= =?us-ascii?Q?GlLr2bm4BErXKDTGG3wKBEs3GihXQhR69QLXr03sUrRr9ngUrTe7lwrIb+bk?= =?us-ascii?Q?/wuGZECP7SUvFlmZPAkNuorz/DphcjBngszgtTNphllVcruaOKCQLvBG0bA?= =?us-ascii?Q?=3D=3D?= X-Microsoft-Exchange-Diagnostics: 1; AM0PR0502MB3875; 6:QGtQ5u93bP0Qr+defOC/vbPK67wrp35F6PFiLg09EAj/QriET8jDV+es60XnK8g0D3I700tjTEfOgCWG3eCCREdB9Te7PL7YqT/OSOfmy/J/6LqbB3BqsQlvCUjUpV16IJGqYcgAdLFQw2B4ZAE7bEdpro06TOjm9nBq6LXwpD3rqUPvFDOU4GGnTUOnhoYnHdd6BNPntYOoJVfQso7gjFLsjpaUhUAfMikenrQQYvadM16rP/ZrzlOvEdCsgEmvYYOMdZ88RoEZAMmoPut3FvamSOeeCrqD6+5cvFoWG0D2rTTb3tYxdKQT94K7IgC64GfTuxZwpn6C35iFP+Eg3w8jOCFNRSKD/5XtdU/2pq8=; 5:Tt3tIEq1qanb3BRVz1AtTxd7GtDFqd70ph5HCesRkNJoGUlSebQyYivPCXyhLEBlfoGwBY6VzhiLnGRK2jT//fXuPzVKyCQNBxDDSUOUQgyu0yzPlj7yqt5Ro/XprLiMiZLBX3ydEs/LCpuQEpjYVbd+GClE7ObPOxEhz6CuUF8=; 24:6CCIfwBPMSBpgL70TRI/osUrj72K1HbvKZ/pzjoQZOL+bjrzLv8+Iks9g6ThcDqwMAbu9euEW8grIFOZbMKXq/5cAT9XLiQSwfSwWnl47UE=; 7:BI+XhEStRn6logRvlaBUU3uF+z4qd/3yR0m7WI4zY9lOyhtDNkw4JDY0KTM/Es693oHfqARPHPf8G2cAT0GBvnxO7Q+UQXlF5Uy9N2oB3lqXDDVnM/8kAJgfLuyCOw/rQZqCZACEWnc+691NEKXoNBtdpt6p0N6ETb8/fTY/o3gVCzZlMwEpdsoY8D4o6MfRSiR86VvaV1zFpwwz+yiRCGkt2ELpktZvnJjX4bZs0vK5E/M8uJdEzHNTX26ro6ym SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: Mellanox.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 20 Jan 2018 21:11:52.0017 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 71c285e8-f694-45c4-9173-08d5604a6dd8 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: a652971c-7d2e-4d9b-a6a4-d149256f461b X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM0PR0502MB3875 Subject: [dpdk-dev] [PATCH v6 4/6] net/tap: add eBPF 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: , X-List-Received-Date: Sat, 20 Jan 2018 21:11:54 -0000 This commit include BPF API to be used by TAP. tap_flow_bpf_cls_q() - download to kernel BPF program that classifies packets to their matching queues tap_flow_bpf_calc_l3_l4_hash() - download to kernel BPF program that calculates per packet layer 3 and layer 4 RSS hash tap_flow_bpf_rss_map_create() - create BPF RSS map for storing RSS parameters per RSS rule tap_flow_bpf_update_rss_elem() - update BPF map entry with RSS rule parameters Signed-off-by: Ophir Munk Acked-by: Pascal Mazon --- drivers/net/tap/Makefile | 6 ++ drivers/net/tap/tap_bpf.h | 112 +++++++++++++++++++++++++ drivers/net/tap/tap_bpf_api.c | 190 ++++++++++++++++++++++++++++++++++++++++++ drivers/net/tap/tap_flow.h | 6 ++ 4 files changed, 314 insertions(+) create mode 100644 drivers/net/tap/tap_bpf.h create mode 100644 drivers/net/tap/tap_bpf_api.c diff --git a/drivers/net/tap/Makefile b/drivers/net/tap/Makefile index fbf84e1..fad8a94 100644 --- a/drivers/net/tap/Makefile +++ b/drivers/net/tap/Makefile @@ -35,6 +35,7 @@ SRCS-$(CONFIG_RTE_LIBRTE_PMD_TAP) += rte_eth_tap.c SRCS-$(CONFIG_RTE_LIBRTE_PMD_TAP) += tap_flow.c SRCS-$(CONFIG_RTE_LIBRTE_PMD_TAP) += tap_netlink.c SRCS-$(CONFIG_RTE_LIBRTE_PMD_TAP) += tap_tcmsgs.c +SRCS-$(CONFIG_RTE_LIBRTE_PMD_TAP) += tap_bpf_api.c include $(RTE_SDK)/mk/rte.lib.mk @@ -61,6 +62,11 @@ tap_autoconf.h.new: $(RTE_SDK)/buildtools/auto-config-h.sh linux/pkt_cls.h \ enum TCA_FLOWER_KEY_VLAN_PRIO \ $(AUTOCONF_OUTPUT) + $Q sh -- '$<' '$@' \ + HAVE_BPF_PROG_LOAD \ + linux/bpf.h \ + enum BPF_PROG_LOAD \ + $(AUTOCONF_OUTPUT) # Create tap_autoconf.h or update it in case it differs from the new one. diff --git a/drivers/net/tap/tap_bpf.h b/drivers/net/tap/tap_bpf.h new file mode 100644 index 0000000..30eefb3 --- /dev/null +++ b/drivers/net/tap/tap_bpf.h @@ -0,0 +1,112 @@ +/* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 + * Copyright 2017 Mellanox Technologies, Ltd. + */ + +#ifndef __TAP_BPF_H__ +#define __TAP_BPF_H__ + +#include + +#ifdef HAVE_BPF_PROG_LOAD +#include +#else +/* BPF_MAP_UPDATE_ELEM command flags */ +#define BPF_ANY 0 /* create a new element or update an existing */ + +/* BPF architecture instruction struct */ +struct bpf_insn { + __u8 code; + __u8 dst_reg:4; + __u8 src_reg:4; + __s16 off; + __s32 imm; /* immediate value */ +}; + +/* BPF program types */ +enum bpf_prog_type { + BPF_PROG_TYPE_UNSPEC, + BPF_PROG_TYPE_SOCKET_FILTER, + BPF_PROG_TYPE_KPROBE, + BPF_PROG_TYPE_SCHED_CLS, + BPF_PROG_TYPE_SCHED_ACT, +}; + +/* BPF commands types */ +enum bpf_cmd { + BPF_MAP_CREATE, + BPF_MAP_LOOKUP_ELEM, + BPF_MAP_UPDATE_ELEM, + BPF_MAP_DELETE_ELEM, + BPF_MAP_GET_NEXT_KEY, + BPF_PROG_LOAD, +}; + +/* BPF maps types */ +enum bpf_map_type { + BPF_MAP_TYPE_UNSPEC, + BPF_MAP_TYPE_HASH, +}; + +/* union of anonymous structs used with TAP BPF commands */ +union bpf_attr { + /* BPF_MAP_CREATE command */ + struct { + __u32 map_type; + __u32 key_size; + __u32 value_size; + __u32 max_entries; + __u32 map_flags; + __u32 inner_map_fd; + }; + + /* BPF_MAP_UPDATE_ELEM, BPF_MAP_DELETE_ELEM commands */ + struct { + __u32 map_fd; + __aligned_u64 key; + union { + __aligned_u64 value; + __aligned_u64 next_key; + }; + __u64 flags; + }; + + /* BPF_PROG_LOAD command */ + struct { + __u32 prog_type; + __u32 insn_cnt; + __aligned_u64 insns; + __aligned_u64 license; + __u32 log_level; + __u32 log_size; + __aligned_u64 log_buf; + __u32 kern_version; + __u32 prog_flags; + }; +} __attribute__((aligned(8))); +#endif + +#ifndef __NR_bpf +# if defined(__i386__) +# define __NR_bpf 357 +# elif defined(__x86_64__) +# define __NR_bpf 321 +# elif defined(__aarch64__) +# define __NR_bpf 280 +# elif defined(__sparc__) +# define __NR_bpf 349 +# elif defined(__s390__) +# define __NR_bpf 351 +# else +# error __NR_bpf not defined +# endif +#endif + +enum { + BPF_MAP_ID_KEY, + BPF_MAP_ID_SIMPLE, +}; + +static int bpf_load(enum bpf_prog_type type, const struct bpf_insn *insns, + size_t insns_cnt, const char *license); + +#endif /* __TAP_BPF_H__ */ diff --git a/drivers/net/tap/tap_bpf_api.c b/drivers/net/tap/tap_bpf_api.c new file mode 100644 index 0000000..109a681 --- /dev/null +++ b/drivers/net/tap/tap_bpf_api.c @@ -0,0 +1,190 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2017 Mellanox Technologies, Ltd. + */ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +/** + * Load BPF program (section cls_q) into the kernel and return a bpf fd + * + * @param queue_idx + * Queue index matching packet cb + * + * @return + * -1 if the BPF program couldn't be loaded. An fd (int) otherwise. + */ +int tap_flow_bpf_cls_q(__u32 queue_idx) +{ + cls_q_insns[1].imm = queue_idx; + + return bpf_load(BPF_PROG_TYPE_SCHED_CLS, + (struct bpf_insn *)cls_q_insns, + RTE_DIM(cls_q_insns), + "Dual BSD/GPL"); +} + +/** + * Load BPF program (section l3_l4) into the kernel and return a bpf fd. + * + * @param[in] key_idx + * RSS MAP key index + * + * @param[in] map_fd + * BPF RSS map file descriptor + * + * @return + * -1 if the BPF program couldn't be loaded. An fd (int) otherwise. + */ +int tap_flow_bpf_calc_l3_l4_hash(__u32 key_idx, int map_fd) +{ + l3_l4_hash_insns[4].imm = key_idx; + l3_l4_hash_insns[9].imm = map_fd; + + return bpf_load(BPF_PROG_TYPE_SCHED_ACT, + (struct bpf_insn *)l3_l4_hash_insns, + RTE_DIM(l3_l4_hash_insns), + "Dual BSD/GPL"); +} + +/** + * Helper function to convert a pointer to unsigned 64 bits + * + * @param[in] ptr + * pointer to address + * + * @return + * 64 bit unsigned long type of pointer address + */ +static inline __u64 ptr_to_u64(const void *ptr) +{ + return (__u64)(unsigned long)ptr; +} + +/** + * Call BPF system call + * + * @param[in] cmd + * BPF command for program loading, map creation, map entry update, etc + * + * @param[in] attr + * System call attributes relevant to system call command + * + * @param[in] size + * size of attr parameter + * + * @return + * -1 if BPF system call failed, 0 otherwise + */ +static inline int sys_bpf(enum bpf_cmd cmd, union bpf_attr *attr, + unsigned int size) +{ + return syscall(__NR_bpf, cmd, attr, size); +} + +/** + * Load BPF instructions to kernel + * + * @param[in] type + * BPF program type: classifieir or action + * + * @param[in] insns + * Array of BPF instructions (equivalent to BPF instructions) + * + * @param[in] insns_cnt + * Number of BPF instructions (size of array) + * + * @param[in] lincense + * License string that must be acknowledged by the kernel + * + * @return + * -1 if the BPF program couldn't be loaded, fd (file descriptor) otherwise + */ +static int bpf_load(enum bpf_prog_type type, + const struct bpf_insn *insns, + size_t insns_cnt, + const char *license) +{ + union bpf_attr attr = {}; + + bzero(&attr, sizeof(attr)); + attr.prog_type = type; + attr.insn_cnt = (__u32)insns_cnt; + attr.insns = ptr_to_u64(insns); + attr.license = ptr_to_u64(license); + attr.log_buf = ptr_to_u64(NULL); + attr.log_level = 0; + attr.kern_version = 0; + + return sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr)); +} + +/** + * Create BPF map for RSS rules + * + * @param[in] key_size + * map RSS key size + * + * @param[in] value_size + * Map RSS value size + * + * @param[in] max_entries + * Map max number of RSS entries (limit on max RSS rules) + * + * @return + * -1 if BPF map couldn't be created, map fd otherwise + */ +int tap_flow_bpf_rss_map_create(unsigned int key_size, + unsigned int value_size, + unsigned int max_entries) +{ + union bpf_attr attr = {}; + + bzero(&attr, sizeof(attr)); + attr.map_type = BPF_MAP_TYPE_HASH; + attr.key_size = key_size; + attr.value_size = value_size; + attr.max_entries = max_entries; + + return sys_bpf(BPF_MAP_CREATE, &attr, sizeof(attr)); +} + +/** + * Update RSS entry in BPF map + * + * @param[in] fd + * RSS map fd + * + * @param[in] key + * Pointer to RSS key whose entry is updated + * + * @param[in] value + * Pointer to RSS new updated value + * + * @return + * -1 if RSS entry failed to be updated, 0 otherwise + */ +int tap_flow_bpf_update_rss_elem(int fd, void *key, void *value) +{ + union bpf_attr attr = {}; + + bzero(&attr, sizeof(attr)); + + attr.map_type = BPF_MAP_TYPE_HASH; + attr.map_fd = fd; + attr.key = ptr_to_u64(key); + attr.value = ptr_to_u64(value); + attr.flags = BPF_ANY; + + return sys_bpf(BPF_MAP_UPDATE_ELEM, &attr, sizeof(attr)); +} diff --git a/drivers/net/tap/tap_flow.h b/drivers/net/tap/tap_flow.h index 9e332b0..894c959 100644 --- a/drivers/net/tap/tap_flow.h +++ b/drivers/net/tap/tap_flow.h @@ -80,4 +80,10 @@ int tap_flow_implicit_destroy(struct pmd_internals *pmd, int tap_flow_implicit_flush(struct pmd_internals *pmd, struct rte_flow_error *error); +int tap_flow_bpf_cls_q(__u32 queue_idx); +int tap_flow_bpf_calc_l3_l4_hash(__u32 key_idx, int map_fd); +int tap_flow_bpf_rss_map_create(unsigned int key_size, unsigned int value_size, + unsigned int max_entries); +int tap_flow_bpf_update_rss_elem(int fd, void *key, void *value); + #endif /* _TAP_FLOW_H_ */ -- 2.7.4