From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR01-HE1-obe.outbound.protection.outlook.com (mail-he1eur01on0078.outbound.protection.outlook.com [104.47.0.78]) by dpdk.org (Postfix) with ESMTP id AE6351B2CF for ; Thu, 18 Jan 2018 14:38:40 +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=PNArWucFr9y9OdR/D3FtrwbSO6Rt9PYvDSZHJBsPJbk=; b=xkeL/JD9AFYJvUfpEnp6adXrWvADj+nuRXQs98GpKi4ESNPpU4pyOQ+3RRgjKuBTHwYf6+RcoGmqHB2YWAgjOm73HIp/PbUDhB7lifF/R724mCICZi+3uDvmtdDw03YssRhM5yRgw+bI6ZfVB0mi9M/qdBaUUuX19hFIgRk0dUI= Received: from mellanox.com (37.142.13.130) by VI1PR0502MB3886.eurprd05.prod.outlook.com (2603:10a6:803:c::11) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256) id 15.20.407.7; Thu, 18 Jan 2018 13:38:35 +0000 From: Ophir Munk To: dev@dpdk.org, Pascal Mazon Cc: Thomas Monjalon , Olga Shern , Ophir Munk Date: Thu, 18 Jan 2018 13:38:09 +0000 Message-Id: <1516282691-29698-5-git-send-email-ophirmu@mellanox.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1516282691-29698-1-git-send-email-ophirmu@mellanox.com> References: <1515692751-25257-1-git-send-email-ophirmu@mellanox.com> <1516282691-29698-1-git-send-email-ophirmu@mellanox.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [37.142.13.130] X-ClientProxiedBy: VI1PR0802CA0042.eurprd08.prod.outlook.com (2603:10a6:800:a9::28) To VI1PR0502MB3886.eurprd05.prod.outlook.com (2603:10a6:803:c::11) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-MS-Office365-Filtering-Correlation-Id: cfd3dfe6-90fa-42fd-81f1-08d55e78c667 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(7020095)(4652020)(48565401081)(5600026)(4604075)(2017052603307)(7153060)(7193020); SRVR:VI1PR0502MB3886; X-Microsoft-Exchange-Diagnostics: 1; VI1PR0502MB3886; 3:qUUPfrFi2ncaPBj4gmBp1JTDXEh1tnSNtLv9V3ATz0Yjbro6Awf799vSyqOnoAQjgILwHSLeP31aZrF1vEvVI6Q5Y2Y8pYe7zaeG4RzAMLMQJ+bos+2RYEoU6DpsC9QW2PyKgN6822Aicy668oSWxHUGqjC+VabRTloIPtIzblFbIlxYVuwjz30xn6hIUeFXjMvkHNNtNZpKyrHFdkFe+KTXUM+Tj+x/kht7chLfj8SxOr15x55og5w5PcowPkno; 25:F5gGv+SCoaDugfyWVAyWnjR2B9E5+1t7+WL3Dyl9+8trYExlN5C2r0llaife+T66VEFxk/u2Mqr1plbUWUKvKkV25fFe3fXkzvOx5WOo9tdcU1mOu4BQWDCOowtwrXUX5oy2NLgFHeRPR4vbQ1dJbtEzOJBtOZ/V2KfcUy8FTwpfEvbV025AxNDtIW2vdzZVgDALkg01fk4isgfL3Z8BZ1IsScJfAflKPjjknYWW8LOi44QVLRpnXyIM7Cey6p7T7UaLbCtzvnJSNqfpIggIQXRDP01Fm+vcRPR11/Qa/Rd1qxSeLwhZjhKjOYTcbRNllVw91tl6X1zYukULtqbzeA==; 31:IRmyCjwslacYj1bLw5R2YQMSZhzw/8lYjOaND7tILkrgeQG/IikzzekSzNMyxqedVAMJvB6OQQknG8zfFB1EfJHt6Btf3JZiIqkfEU+1DO+ib/oKNcDEe8TpxvW6tvCbIhFiNxBBXPPmaEcC3n1tgF6X4rtymgih3S/OIpQ3gF04w9JySrkSRr26hy5f2e82lb0IZbQFlQTmU5flFKBCAEz3lnAbQpG5e77TFQTqCcY= X-MS-TrafficTypeDiagnostic: VI1PR0502MB3886: Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=ophirmu@mellanox.com; X-LD-Processed: a652971c-7d2e-4d9b-a6a4-d149256f461b,ExtAddr X-Microsoft-Exchange-Diagnostics: 1; VI1PR0502MB3886; 20:1Irb2jfrn0Vtq+OnjnkTlcpqNGOIkTAKosXxTbDJoB/LlinZ4k3zisk17a4Mak8yvLP7vqGbPlr+MGBUA7J7sqXfgC9dRqDFsBKahxPwezw2D9UG5Gb1xTtVf/l4RnYF9kka3VX6SgXrlL0SYTYbexe5cPg0Wc5KuxobLI7XCvWIt5I4OJjtXEO0Pc7XVKb85v5Vpz5j/DekiOHjAFuPqzbYXbns/0P/SSsSe70qKafFGyD0BBf/N2v7IWpNtmF/PZsgnnXJkuqcR5+07Dneeu0LnBs4uLyUNOF42ZfBWivYzssaSXz72jy2qR+I6rKJcYHeoXF4mj2WScJaml5PWR89A2bJuDrJXAHIZvb105gxRut6Eyn1l8witEjdDCgZnDq1bTpEZnRDQTtMrP4UMzlfCARYUaq3uOPxH+mItf0Bb600bjLNCUGQkxPEB6S3qv/sUbMj+6mX4OJ2ny/F0xatUE0SX8K4lEr6cReu/YPC8HpXLCgCySuafifItn1+; 4:dG1C7dwRLWHjgfM0Us0J4c1mrIaP/t53D/94o8txrE/bGxREk5y1afpm2S199ZXb2PBV5MftubIAjHxlQqV581pC5XJsE/qavCbl8C6y2wjSKeDRVyyCWH6w9cWFSObL6sxQnF7cdggINurCvgzS6ytjfpFITUiUKWIAdC4wK8HPYG6aw//06watG/kKwysYGFzVrQ1nlwwMr5CQD7JLRDsPmUwz2Jx2J1w5e40Xsb5OYhtdHm9kvuRhW6tTclqoA6mUMYI1AWxUwowlSQIMgw== X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(6040470)(2401047)(5005006)(8121501046)(3231023)(2400062)(944501161)(3002001)(10201501046)(93006095)(93001095)(6055026)(6041268)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123560045)(20161123564045)(20161123562045)(20161123558120)(6072148)(201708071742011); SRVR:VI1PR0502MB3886; BCL:0; PCL:0; RULEID:(100000803101)(100110400095); SRVR:VI1PR0502MB3886; X-Forefront-PRVS: 05568D1FF7 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(346002)(39380400002)(376002)(396003)(366004)(39860400002)(189003)(199004)(48376002)(33026002)(305945005)(6116002)(478600001)(3846002)(106356001)(66066001)(50466002)(7736002)(8676002)(81166006)(21086003)(8936002)(97736004)(16526018)(4720700003)(68736007)(6666003)(51416003)(7696005)(52116002)(81156014)(4326008)(36756003)(50226002)(26005)(69596002)(105586002)(53936002)(5660300001)(25786009)(59450400001)(386003)(316002)(47776003)(76176011)(2906002)(55016002)(2950100002)(54906003)(86362001)(16586007)(107886003)(6916009); DIR:OUT; SFP:1101; SCL:1; SRVR:VI1PR0502MB3886; 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; VI1PR0502MB3886; 23:FCslpggfspvf8i5sFeOQoO2bStt0rj3Y9Bj8em/?= =?us-ascii?Q?JRrldtSd+2fqkvocFH6ZzJKeTvspiGbFIUCoyrgVarv8JnXL7hA5Y4aCk+m0?= =?us-ascii?Q?evNk6YiztK/GOA18OezLxm/495k1oD+5MZ85H53vgPH8DP5/tUnMTOxokqA6?= =?us-ascii?Q?8ab/Jzk4lDWm3eCwMSndb0fZ9IS1/W7aUS9PLyfnfAg3P5WEG46HmV3hWnnt?= =?us-ascii?Q?njbZmaYIfiA63ssAZFIx36LWrr4HtX1UAZHo02xfexwsHN7rfjjbn38Ss4JA?= =?us-ascii?Q?obxSoJcNZJFe6k15QjZxEQnaF21FZvJfyVS9UFZ1u4U7uc+BWGPS1eKwTIYW?= =?us-ascii?Q?avDtWw0xM/1uNa1HIUSpvyyw+pSRw5wD6c8NtovSDXxOSQSThIWph6w8xpeX?= =?us-ascii?Q?4xFWme015WwjHsfNvGbHmcYH8c6WBm780SfXrSwkqVMRinmYLQs40nrn2IjS?= =?us-ascii?Q?DaHmUL5zDnyiAVhWsv2Uv4QtPHhBiV5zBru213DHA2sYQSViNvi31GLnNlI/?= =?us-ascii?Q?o3CiAV7KiG28qT9QP+2EMZn2ECmcGJoaXGgtm914fbgrFq4e/hKF+/Jlej9e?= =?us-ascii?Q?4hNCkKPJpVARbsV3yq+Yj6+PasvlogUU+/HuKOwVgqCm8p9OakQJIdl0+7O1?= =?us-ascii?Q?QsZ3XLuo4ks5vdZMMiSNW54FulniY6bTT5HLvgzG208xlxZOdgUtvMRGWMdC?= =?us-ascii?Q?yVV4ZTjRcSUiYWUg56TwRcKtPTgwxOUwb3VjY+kx0nRu7ffRLkp4UtNf7MDV?= =?us-ascii?Q?z4SxofhLDBPQ2OJQ/0fJjhrbNXHoRkG9kXjGHriQZYVaMMzvo8Wk5+S0ZWF2?= =?us-ascii?Q?5M3CcT+Hh7sH/gdmMfZaRESqpK10qTxV4JLh5ng1b/fC6+FWQUKxsRkM4Y11?= =?us-ascii?Q?KFdSXNuHXF6tvkgvwkPHyZAZ57wLTTwVTqW4qKPIbDAFZ1tX2keLkqeKi5g3?= =?us-ascii?Q?polndtUxbL4UO8mYfNeOCDXx5FIT9xyUxvHICTLMtiKp9AjN0fLms8v9sKjO?= =?us-ascii?Q?xBvOSbz1FYoUpoTRIrYOa6vBsLA3ecN8AKE2EdilqooE/npC1704EyNh6R8O?= =?us-ascii?Q?iH7V5uAU7YHvff4lb2s3gZhXES1jsmVFaEOo9N1wtHZLWDUi9/EBMwAAXFLf?= =?us-ascii?Q?/RzF6pXIg3t/dl0XFWZypkj7mjBNgwJR3siQaxtnoE7dJ3IkQOZHmotzPxH9?= =?us-ascii?Q?8ifXfy/WjsmdMcwEz0O8YHOzzvXCOqy+4xnmWnA+5kZhSt2myBoWKJbejIQ?= =?us-ascii?Q?=3D=3D?= X-Microsoft-Exchange-Diagnostics: 1; VI1PR0502MB3886; 6:3W2rQ0qEwctaeki6jlfsk2snnFexjjuCJyumnmtmL43M5MC6VnCpdUquH6tRUEJGi91y5cuBR649PLLK3yuBz9TlIJaiYAaO7UGMumc1Ao5Yld6lQ3bedU7h840ABgrIADTafk/f1noZwrwlgw+7ZN40I47l2c5vkiTLfqxk8b1y9SSt6NhBNYUJtHJId1CR4p5dlSqT3ZVrSKly3WjAXz5+vDG437UcUuFVQdO+PocyxKdAaJQIWnGeWoNEVkZpGBvyhHbcdnBdEO0+/tImdIzlM/rvGod6L/ph/aRIWHAAeXvbddfe7XU5UCHrOtthyfei3qdGrDV2qTaFWYdzpXxqOvj8tvzMhUHS7cVtI10=; 5:xIfP0ejgvulamEbC7DffH3yq5Fp+02HCKXilVWNARjUhdI2t9jduNV0YPlTLeH9iWz96XoZkcc4l+B3LRngsMKCD760kZXwMxfwzr5LqKmWakbXH4ROIdn4ws9ZgxGHn5oxU1NkPsQjFicqWb0b6aD12pn81bXTV41FqsEbor10=; 24:ZnP0BT8madvfifgWG/WZflT88jA/5Ln1cLNJc3Kn8I0DnlhJWOf7YViVC45aKkEHZFfLpCCXArQ87ohlvtxvWNi3LFDcaBa4gxJPMU/5QX8=; 7:CDM6LdL/jmt7fnvTBTDB933CNH9iA3GSnoZTMOSZaj8qTsCqCjhZUE4ndgbn01AEex287VoB5Pd6aCBo+cB8hN3K3haFJsqYz2he7xadw+vC5M7ZwTCX0i7tt5VWgelB+1UVqhnpTZ0wZ7hvro2+XGizlQj1Or1no9ztlEntl/0mThsFHjylJXCDuKFWn+nXFyrmTaR1w63dZfsXKGpEZ33m/THt7ep+UvKtgy3ztlR4aSqf762CfJV0oTm5WImB SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: Mellanox.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 18 Jan 2018 13:38:35.4770 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: cfd3dfe6-90fa-42fd-81f1-08d55e78c667 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: a652971c-7d2e-4d9b-a6a4-d149256f461b X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI1PR0502MB3886 Subject: [dpdk-dev] [PATCH v5 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: Thu, 18 Jan 2018 13:38:41 -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 --- 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