]>
Commit | Line | Data |
---|---|---|
11fdf7f2 TL |
1 | /* SPDX-License-Identifier: BSD-3-Clause |
2 | * Copyright(c) 2018 Intel Corporation | |
3 | */ | |
4 | ||
5 | #ifndef _RTE_BPF_H_ | |
6 | #define _RTE_BPF_H_ | |
7 | ||
8 | /** | |
9 | * @file rte_bpf.h | |
10 | * @b EXPERIMENTAL: this API may change without prior notice | |
11 | * | |
12 | * RTE BPF support. | |
13 | * librte_bpf provides a framework to load and execute eBPF bytecode | |
14 | * inside user-space dpdk based applications. | |
15 | * It supports basic set of features from eBPF spec | |
16 | * (https://www.kernel.org/doc/Documentation/networking/filter.txt). | |
17 | */ | |
18 | ||
19 | #include <rte_common.h> | |
20 | #include <rte_mbuf.h> | |
21 | #include <bpf_def.h> | |
22 | ||
23 | #ifdef __cplusplus | |
24 | extern "C" { | |
25 | #endif | |
26 | ||
27 | /** | |
28 | * Possible types for function/BPF program arguments. | |
29 | */ | |
30 | enum rte_bpf_arg_type { | |
31 | RTE_BPF_ARG_UNDEF, /**< undefined */ | |
32 | RTE_BPF_ARG_RAW, /**< scalar value */ | |
33 | RTE_BPF_ARG_PTR = 0x10, /**< pointer to data buffer */ | |
34 | RTE_BPF_ARG_PTR_MBUF, /**< pointer to rte_mbuf */ | |
35 | RTE_BPF_ARG_PTR_STACK, | |
36 | }; | |
37 | ||
38 | /** | |
39 | * function argument information | |
40 | */ | |
41 | struct rte_bpf_arg { | |
42 | enum rte_bpf_arg_type type; | |
43 | /** | |
44 | * for ptr type - max size of data buffer it points to | |
45 | * for raw type - the size (in bytes) of the value | |
46 | */ | |
47 | size_t size; | |
48 | size_t buf_size; | |
49 | /**< for mbuf ptr type, max size of rte_mbuf data buffer */ | |
50 | }; | |
51 | ||
52 | /** | |
53 | * determine is argument a pointer | |
54 | */ | |
55 | #define RTE_BPF_ARG_PTR_TYPE(x) ((x) & RTE_BPF_ARG_PTR) | |
56 | ||
57 | /** | |
58 | * Possible types for external symbols. | |
59 | */ | |
60 | enum rte_bpf_xtype { | |
61 | RTE_BPF_XTYPE_FUNC, /**< function */ | |
62 | RTE_BPF_XTYPE_VAR, /**< variable */ | |
63 | RTE_BPF_XTYPE_NUM | |
64 | }; | |
65 | ||
66 | /** | |
67 | * Definition for external symbols available in the BPF program. | |
68 | */ | |
69 | struct rte_bpf_xsym { | |
70 | const char *name; /**< name */ | |
71 | enum rte_bpf_xtype type; /**< type */ | |
72 | union { | |
73 | struct { | |
74 | uint64_t (*val)(uint64_t, uint64_t, uint64_t, | |
75 | uint64_t, uint64_t); | |
76 | uint32_t nb_args; | |
77 | struct rte_bpf_arg args[EBPF_FUNC_MAX_ARGS]; | |
78 | /**< Function arguments descriptions. */ | |
79 | struct rte_bpf_arg ret; /**< function return value. */ | |
80 | } func; | |
81 | struct { | |
82 | void *val; /**< actual memory location */ | |
83 | struct rte_bpf_arg desc; /**< type, size, etc. */ | |
84 | } var; /**< external variable */ | |
85 | }; | |
86 | }; | |
87 | ||
88 | /** | |
89 | * Input parameters for loading eBPF code. | |
90 | */ | |
91 | struct rte_bpf_prm { | |
92 | const struct ebpf_insn *ins; /**< array of eBPF instructions */ | |
93 | uint32_t nb_ins; /**< number of instructions in ins */ | |
94 | const struct rte_bpf_xsym *xsym; | |
95 | /**< array of external symbols that eBPF code is allowed to reference */ | |
96 | uint32_t nb_xsym; /**< number of elements in xsym */ | |
97 | struct rte_bpf_arg prog_arg; /**< eBPF program input arg description */ | |
98 | }; | |
99 | ||
100 | /** | |
101 | * Information about compiled into native ISA eBPF code. | |
102 | */ | |
103 | struct rte_bpf_jit { | |
104 | uint64_t (*func)(void *); /**< JIT-ed native code */ | |
105 | size_t sz; /**< size of JIT-ed code */ | |
106 | }; | |
107 | ||
108 | struct rte_bpf; | |
109 | ||
110 | /** | |
111 | * De-allocate all memory used by this eBPF execution context. | |
112 | * | |
113 | * @param bpf | |
114 | * BPF handle to destroy. | |
115 | */ | |
116 | void __rte_experimental | |
117 | rte_bpf_destroy(struct rte_bpf *bpf); | |
118 | ||
119 | /** | |
120 | * Create a new eBPF execution context and load given BPF code into it. | |
121 | * | |
122 | * @param prm | |
9f95a23c | 123 | * Parameters used to create and initialise the BPF execution context. |
11fdf7f2 TL |
124 | * @return |
125 | * BPF handle that is used in future BPF operations, | |
126 | * or NULL on error, with error code set in rte_errno. | |
127 | * Possible rte_errno errors include: | |
128 | * - EINVAL - invalid parameter passed to function | |
129 | * - ENOMEM - can't reserve enough memory | |
130 | */ | |
131 | struct rte_bpf * __rte_experimental | |
132 | rte_bpf_load(const struct rte_bpf_prm *prm); | |
133 | ||
134 | /** | |
135 | * Create a new eBPF execution context and load BPF code from given ELF | |
136 | * file into it. | |
137 | * | |
138 | * @param prm | |
9f95a23c | 139 | * Parameters used to create and initialise the BPF execution context. |
11fdf7f2 TL |
140 | * @param fname |
141 | * Pathname for a ELF file. | |
142 | * @param sname | |
143 | * Name of the executable section within the file to load. | |
144 | * @return | |
145 | * BPF handle that is used in future BPF operations, | |
146 | * or NULL on error, with error code set in rte_errno. | |
147 | * Possible rte_errno errors include: | |
148 | * - EINVAL - invalid parameter passed to function | |
149 | * - ENOMEM - can't reserve enough memory | |
150 | */ | |
151 | struct rte_bpf * __rte_experimental | |
152 | rte_bpf_elf_load(const struct rte_bpf_prm *prm, const char *fname, | |
153 | const char *sname); | |
154 | /** | |
155 | * Execute given BPF bytecode. | |
156 | * | |
157 | * @param bpf | |
158 | * handle for the BPF code to execute. | |
159 | * @param ctx | |
160 | * pointer to input context. | |
161 | * @return | |
162 | * BPF execution return value. | |
163 | */ | |
164 | uint64_t __rte_experimental | |
165 | rte_bpf_exec(const struct rte_bpf *bpf, void *ctx); | |
166 | ||
167 | /** | |
168 | * Execute given BPF bytecode over a set of input contexts. | |
169 | * | |
170 | * @param bpf | |
171 | * handle for the BPF code to execute. | |
172 | * @param ctx | |
173 | * array of pointers to the input contexts. | |
174 | * @param rc | |
175 | * array of return values (one per input). | |
176 | * @param num | |
177 | * number of elements in ctx[] (and rc[]). | |
178 | * @return | |
179 | * number of successfully processed inputs. | |
180 | */ | |
181 | uint32_t __rte_experimental | |
182 | rte_bpf_exec_burst(const struct rte_bpf *bpf, void *ctx[], uint64_t rc[], | |
183 | uint32_t num); | |
184 | ||
185 | /** | |
9f95a23c | 186 | * Provide information about natively compiled code for given BPF handle. |
11fdf7f2 TL |
187 | * |
188 | * @param bpf | |
189 | * handle for the BPF code. | |
190 | * @param jit | |
191 | * pointer to the rte_bpf_jit structure to be filled with related data. | |
192 | * @return | |
193 | * - -EINVAL if the parameters are invalid. | |
194 | * - Zero if operation completed successfully. | |
195 | */ | |
196 | int __rte_experimental | |
197 | rte_bpf_get_jit(const struct rte_bpf *bpf, struct rte_bpf_jit *jit); | |
198 | ||
199 | #ifdef __cplusplus | |
200 | } | |
201 | #endif | |
202 | ||
203 | #endif /* _RTE_BPF_H_ */ |