devtools: test pkg-config file
[dpdk.git] / lib / librte_bpf / bpf_load_elf.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2018 Intel Corporation
3  */
4
5 #include <stdarg.h>
6 #include <stdio.h>
7 #include <string.h>
8 #include <errno.h>
9 #include <stdint.h>
10 #include <unistd.h>
11 #include <inttypes.h>
12
13 #include <sys/types.h>
14 #include <sys/stat.h>
15 #include <sys/queue.h>
16 #include <fcntl.h>
17
18 #include <libelf.h>
19
20 #include <rte_common.h>
21 #include <rte_log.h>
22 #include <rte_debug.h>
23 #include <rte_memory.h>
24 #include <rte_eal.h>
25 #include <rte_byteorder.h>
26 #include <rte_errno.h>
27
28 #include "bpf_impl.h"
29
30 /* To overcome compatibility issue */
31 #ifndef EM_BPF
32 #define EM_BPF  247
33 #endif
34
35 static uint32_t
36 bpf_find_xsym(const char *sn, enum rte_bpf_xtype type,
37         const struct rte_bpf_xsym fp[], uint32_t fn)
38 {
39         uint32_t i;
40
41         if (sn == NULL || fp == NULL)
42                 return UINT32_MAX;
43
44         for (i = 0; i != fn; i++) {
45                 if (fp[i].type == type && strcmp(sn, fp[i].name) == 0)
46                         break;
47         }
48
49         return (i != fn) ? i : UINT32_MAX;
50 }
51
52 /*
53  * update BPF code at offset *ofs* with a proper address(index) for external
54  * symbol *sn*
55  */
56 static int
57 resolve_xsym(const char *sn, size_t ofs, struct ebpf_insn *ins, size_t ins_sz,
58         const struct rte_bpf_prm *prm)
59 {
60         uint32_t idx, fidx;
61         enum rte_bpf_xtype type;
62
63         if (ofs % sizeof(ins[0]) != 0 || ofs >= ins_sz)
64                 return -EINVAL;
65
66         idx = ofs / sizeof(ins[0]);
67         if (ins[idx].code == (BPF_JMP | EBPF_CALL))
68                 type = RTE_BPF_XTYPE_FUNC;
69         else if (ins[idx].code == (BPF_LD | BPF_IMM | EBPF_DW) &&
70                         ofs < ins_sz - sizeof(ins[idx]))
71                 type = RTE_BPF_XTYPE_VAR;
72         else
73                 return -EINVAL;
74
75         fidx = bpf_find_xsym(sn, type, prm->xsym, prm->nb_xsym);
76         if (fidx == UINT32_MAX)
77                 return -ENOENT;
78
79         /* for function we just need an index in our xsym table */
80         if (type == RTE_BPF_XTYPE_FUNC) {
81
82                 /* we don't support multiple functions per BPF module,
83                  * so treat EBPF_PSEUDO_CALL to extrernal function
84                  * as an ordinary EBPF_CALL.
85                  */
86                 if (ins[idx].src_reg == EBPF_PSEUDO_CALL) {
87                         RTE_BPF_LOG(INFO, "%s(%u): "
88                                 "EBPF_PSEUDO_CALL to external function: %s\n",
89                                 __func__, idx, sn);
90                         ins[idx].src_reg = EBPF_REG_0;
91                 }
92                 ins[idx].imm = fidx;
93         /* for variable we need to store its absolute address */
94         } else {
95                 ins[idx].imm = (uintptr_t)prm->xsym[fidx].var.val;
96                 ins[idx + 1].imm =
97                         (uint64_t)(uintptr_t)prm->xsym[fidx].var.val >> 32;
98         }
99
100         return 0;
101 }
102
103 static int
104 check_elf_header(const Elf64_Ehdr *eh)
105 {
106         const char *err;
107
108         err = NULL;
109
110 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
111         if (eh->e_ident[EI_DATA] != ELFDATA2LSB)
112 #else
113         if (eh->e_ident[EI_DATA] != ELFDATA2MSB)
114 #endif
115                 err = "not native byte order";
116         else if (eh->e_ident[EI_OSABI] != ELFOSABI_NONE)
117                 err = "unexpected OS ABI";
118         else if (eh->e_type != ET_REL)
119                 err = "unexpected ELF type";
120         else if (eh->e_machine != EM_NONE && eh->e_machine != EM_BPF)
121                 err = "unexpected machine type";
122
123         if (err != NULL) {
124                 RTE_BPF_LOG(ERR, "%s(): %s\n", __func__, err);
125                 return -EINVAL;
126         }
127
128         return 0;
129 }
130
131 /*
132  * helper function, find executable section by name.
133  */
134 static int
135 find_elf_code(Elf *elf, const char *section, Elf_Data **psd, size_t *pidx)
136 {
137         Elf_Scn *sc;
138         const Elf64_Ehdr *eh;
139         const Elf64_Shdr *sh;
140         Elf_Data *sd;
141         const char *sn;
142         int32_t rc;
143
144         eh = elf64_getehdr(elf);
145         if (eh == NULL) {
146                 rc = elf_errno();
147                 RTE_BPF_LOG(ERR, "%s(%p, %s) error code: %d(%s)\n",
148                         __func__, elf, section, rc, elf_errmsg(rc));
149                 return -EINVAL;
150         }
151
152         if (check_elf_header(eh) != 0)
153                 return -EINVAL;
154
155         /* find given section by name */
156         for (sc = elf_nextscn(elf, NULL); sc != NULL;
157                         sc = elf_nextscn(elf, sc)) {
158                 sh = elf64_getshdr(sc);
159                 sn = elf_strptr(elf, eh->e_shstrndx, sh->sh_name);
160                 if (sn != NULL && strcmp(section, sn) == 0 &&
161                                 sh->sh_type == SHT_PROGBITS &&
162                                 sh->sh_flags == (SHF_ALLOC | SHF_EXECINSTR))
163                         break;
164         }
165
166         sd = elf_getdata(sc, NULL);
167         if (sd == NULL || sd->d_size == 0 ||
168                         sd->d_size % sizeof(struct ebpf_insn) != 0) {
169                 rc = elf_errno();
170                 RTE_BPF_LOG(ERR, "%s(%p, %s) error code: %d(%s)\n",
171                         __func__, elf, section, rc, elf_errmsg(rc));
172                 return -EINVAL;
173         }
174
175         *psd = sd;
176         *pidx = elf_ndxscn(sc);
177         return 0;
178 }
179
180 /*
181  * helper function to process data from relocation table.
182  */
183 static int
184 process_reloc(Elf *elf, size_t sym_idx, Elf64_Rel *re, size_t re_sz,
185         struct ebpf_insn *ins, size_t ins_sz, const struct rte_bpf_prm *prm)
186 {
187         int32_t rc;
188         uint32_t i, n;
189         size_t ofs, sym;
190         const char *sn;
191         const Elf64_Ehdr *eh;
192         Elf_Scn *sc;
193         const Elf_Data *sd;
194         Elf64_Sym *sm;
195
196         eh = elf64_getehdr(elf);
197
198         /* get symtable by section index */
199         sc = elf_getscn(elf, sym_idx);
200         sd = elf_getdata(sc, NULL);
201         if (sd == NULL)
202                 return -EINVAL;
203         sm = sd->d_buf;
204
205         n = re_sz / sizeof(re[0]);
206         for (i = 0; i != n; i++) {
207
208                 ofs = re[i].r_offset;
209
210                 /* retrieve index in the symtable */
211                 sym = ELF64_R_SYM(re[i].r_info);
212                 if (sym * sizeof(sm[0]) >= sd->d_size)
213                         return -EINVAL;
214
215                 sn = elf_strptr(elf, eh->e_shstrndx, sm[sym].st_name);
216
217                 rc = resolve_xsym(sn, ofs, ins, ins_sz, prm);
218                 if (rc != 0) {
219                         RTE_BPF_LOG(ERR,
220                                 "resolve_xsym(%s, %zu) error code: %d\n",
221                                 sn, ofs, rc);
222                         return rc;
223                 }
224         }
225
226         return 0;
227 }
228
229 /*
230  * helper function, find relocation information (if any)
231  * and update bpf code.
232  */
233 static int
234 elf_reloc_code(Elf *elf, Elf_Data *ed, size_t sidx,
235         const struct rte_bpf_prm *prm)
236 {
237         Elf64_Rel *re;
238         Elf_Scn *sc;
239         const Elf64_Shdr *sh;
240         const Elf_Data *sd;
241         int32_t rc;
242
243         rc = 0;
244
245         /* walk through all sections */
246         for (sc = elf_nextscn(elf, NULL); sc != NULL && rc == 0;
247                         sc = elf_nextscn(elf, sc)) {
248
249                 sh = elf64_getshdr(sc);
250
251                 /* relocation data for our code section */
252                 if (sh->sh_type == SHT_REL && sh->sh_info == sidx) {
253                         sd = elf_getdata(sc, NULL);
254                         if (sd == NULL || sd->d_size == 0 ||
255                                         sd->d_size % sizeof(re[0]) != 0)
256                                 return -EINVAL;
257                         rc = process_reloc(elf, sh->sh_link,
258                                 sd->d_buf, sd->d_size, ed->d_buf, ed->d_size,
259                                 prm);
260                 }
261         }
262
263         return rc;
264 }
265
266 static struct rte_bpf *
267 bpf_load_elf(const struct rte_bpf_prm *prm, int32_t fd, const char *section)
268 {
269         Elf *elf;
270         Elf_Data *sd;
271         size_t sidx;
272         int32_t rc;
273         struct rte_bpf *bpf;
274         struct rte_bpf_prm np;
275
276         elf_version(EV_CURRENT);
277         elf = elf_begin(fd, ELF_C_READ, NULL);
278
279         rc = find_elf_code(elf, section, &sd, &sidx);
280         if (rc == 0)
281                 rc = elf_reloc_code(elf, sd, sidx, prm);
282
283         if (rc == 0) {
284                 np = prm[0];
285                 np.ins = sd->d_buf;
286                 np.nb_ins = sd->d_size / sizeof(struct ebpf_insn);
287                 bpf = rte_bpf_load(&np);
288         } else {
289                 bpf = NULL;
290                 rte_errno = -rc;
291         }
292
293         elf_end(elf);
294         return bpf;
295 }
296
297 struct rte_bpf *
298 rte_bpf_elf_load(const struct rte_bpf_prm *prm, const char *fname,
299         const char *sname)
300 {
301         int32_t fd, rc;
302         struct rte_bpf *bpf;
303
304         if (prm == NULL || fname == NULL || sname == NULL) {
305                 rte_errno = EINVAL;
306                 return NULL;
307         }
308
309         fd = open(fname, O_RDONLY);
310         if (fd < 0) {
311                 rc = errno;
312                 RTE_BPF_LOG(ERR, "%s(%s) error code: %d(%s)\n",
313                         __func__, fname, rc, strerror(rc));
314                 rte_errno = EINVAL;
315                 return NULL;
316         }
317
318         bpf = bpf_load_elf(prm, fd, sname);
319         close(fd);
320
321         if (bpf == NULL) {
322                 RTE_BPF_LOG(ERR,
323                         "%s(fname=\"%s\", sname=\"%s\") failed, "
324                         "error code: %d\n",
325                         __func__, fname, sname, rte_errno);
326                 return NULL;
327         }
328
329         RTE_BPF_LOG(INFO, "%s(fname=\"%s\", sname=\"%s\") "
330                 "successfully creates %p(jit={.func=%p,.sz=%zu});\n",
331                 __func__, fname, sname, bpf, bpf->jit.func, bpf->jit.sz);
332         return bpf;
333 }