?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'block-5.11-2021-01-10' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / tools / bpf / bpftool / gen.c
blob4033c46d83e7dce333cd303a6fc8f0ff98e139c3
1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2019 Facebook */
3
4 #ifndef _GNU_SOURCE
5 #define _GNU_SOURCE
6 #endif
7 #include <ctype.h>
8 #include <errno.h>
9 #include <fcntl.h>
10 #include <linux/err.h>
11 #include <stdbool.h>
12 #include <stdio.h>
13 #include <string.h>
14 #include <unistd.h>
15 #include <bpf/bpf.h>
16 #include <bpf/libbpf.h>
17 #include <sys/types.h>
18 #include <sys/stat.h>
19 #include <sys/mman.h>
20 #include <bpf/btf.h>
21
22 #include "json_writer.h"
23 #include "main.h"
24
25 #define MAX_OBJ_NAME_LEN 64
26
27 static void sanitize_identifier(char *name)
28 {
29 int i;
30
31 for (i = 0; name[i]; i++)
32 if (!isalnum(name[i]) && name[i] != '_')
33 name[i] = '_';
34 }
35
36 static bool str_has_suffix(const char *str, const char *suffix)
37 {
38 size_t i, n1 = strlen(str), n2 = strlen(suffix);
39
40 if (n1 < n2)
41 return false;
42
43 for (i = 0; i < n2; i++) {
44 if (str[n1 - i - 1] != suffix[n2 - i - 1])
45 return false;
46 }
47
48 return true;
49 }
50
51 static void get_obj_name(char *name, const char *file)
52 {
53 /* Using basename() GNU version which doesn't modify arg. */
54 strncpy(name, basename(file), MAX_OBJ_NAME_LEN - 1);
55 name[MAX_OBJ_NAME_LEN - 1] = '\0';
56 if (str_has_suffix(name, ".o"))
57 name[strlen(name) - 2] = '\0';
58 sanitize_identifier(name);
59 }
60
61 static void get_header_guard(char *guard, const char *obj_name)
62 {
63 int i;
64
65 sprintf(guard, "__%s_SKEL_H__", obj_name);
66 for (i = 0; guard[i]; i++)
67 guard[i] = toupper(guard[i]);
68 }
69
70 static const char *get_map_ident(const struct bpf_map *map)
71 {
72 const char *name = bpf_map__name(map);
73
74 if (!bpf_map__is_internal(map))
75 return name;
76
77 if (str_has_suffix(name, ".data"))
78 return "data";
79 else if (str_has_suffix(name, ".rodata"))
80 return "rodata";
81 else if (str_has_suffix(name, ".bss"))
82 return "bss";
83 else if (str_has_suffix(name, ".kconfig"))
84 return "kconfig";
85 else
86 return NULL;
87 }
88
89 static void codegen_btf_dump_printf(void *ctx, const char *fmt, va_list args)
90 {
91 vprintf(fmt, args);
92 }
93
94 static int codegen_datasec_def(struct bpf_object *obj,
95 struct btf *btf,
96 struct btf_dump *d,
97 const struct btf_type *sec,
98 const char *obj_name)
99 {
100 const char *sec_name = btf__name_by_offset(btf, sec->name_off);
101 const struct btf_var_secinfo *sec_var = btf_var_secinfos(sec);
102 int i, err, off = 0, pad_cnt = 0, vlen = btf_vlen(sec);
103 const char *sec_ident;
104 char var_ident[256];
105 bool strip_mods = false;
106
107 if (strcmp(sec_name, ".data") == 0) {
108 sec_ident = "data";
109 } else if (strcmp(sec_name, ".bss") == 0) {
110 sec_ident = "bss";
111 } else if (strcmp(sec_name, ".rodata") == 0) {
112 sec_ident = "rodata";
113 strip_mods = true;
114 } else if (strcmp(sec_name, ".kconfig") == 0) {
115 sec_ident = "kconfig";
116 } else {
117 return 0;
118 }
119
120 printf(" struct %s__%s {\n", obj_name, sec_ident);
121 for (i = 0; i < vlen; i++, sec_var++) {
122 const struct btf_type *var = btf__type_by_id(btf, sec_var->type);
123 const char *var_name = btf__name_by_offset(btf, var->name_off);
124 DECLARE_LIBBPF_OPTS(btf_dump_emit_type_decl_opts, opts,
125 .field_name = var_ident,
126 .indent_level = 2,
127 .strip_mods = strip_mods,
128 );
129 int need_off = sec_var->offset, align_off, align;
130 __u32 var_type_id = var->type;
131
132 if (off > need_off) {
133 p_err("Something is wrong for %s's variable #%d: need offset %d, already at %d.\n",
134 sec_name, i, need_off, off);
135 return -EINVAL;
136 }
137
138 align = btf__align_of(btf, var->type);
139 if (align <= 0) {
140 p_err("Failed to determine alignment of variable '%s': %d",
141 var_name, align);
142 return -EINVAL;
143 }
144 /* Assume 32-bit architectures when generating data section
145 * struct memory layout. Given bpftool can't know which target
146 * host architecture it's emitting skeleton for, we need to be
147 * conservative and assume 32-bit one to ensure enough padding
148 * bytes are generated for pointer and long types. This will
149 * still work correctly for 64-bit architectures, because in
150 * the worst case we'll generate unnecessary padding field,
151 * which on 64-bit architectures is not strictly necessary and
152 * would be handled by natural 8-byte alignment. But it still
153 * will be a correct memory layout, based on recorded offsets
154 * in BTF.
155 */
156 if (align > 4)
157 align = 4;
158
159 align_off = (off + align - 1) / align * align;
160 if (align_off != need_off) {
161 printf("\t\tchar __pad%d[%d];\n",
162 pad_cnt, need_off - off);
163 pad_cnt++;
164 }
165
166 /* sanitize variable name, e.g., for static vars inside
167 * a function, it's name is '<function name>.<variable name>',
168 * which we'll turn into a '<function name>_<variable name>'
169 */
170 var_ident[0] = '\0';
171 strncat(var_ident, var_name, sizeof(var_ident) - 1);
172 sanitize_identifier(var_ident);
173
174 printf("\t\t");
175 err = btf_dump__emit_type_decl(d, var_type_id, &opts);
176 if (err)
177 return err;
178 printf(";\n");
179
180 off = sec_var->offset + sec_var->size;
181 }
182 printf(" } *%s;\n", sec_ident);
183 return 0;
184 }
185
186 static int codegen_datasecs(struct bpf_object *obj, const char *obj_name)
187 {
188 struct btf *btf = bpf_object__btf(obj);
189 int n = btf__get_nr_types(btf);
190 struct btf_dump *d;
191 int i, err = 0;
192
193 d = btf_dump__new(btf, NULL, NULL, codegen_btf_dump_printf);
194 if (IS_ERR(d))
195 return PTR_ERR(d);
196
197 for (i = 1; i <= n; i++) {
198 const struct btf_type *t = btf__type_by_id(btf, i);
199
200 if (!btf_is_datasec(t))
201 continue;
202
203 err = codegen_datasec_def(obj, btf, d, t, obj_name);
204 if (err)
205 goto out;
206 }
207 out:
208 btf_dump__free(d);
209 return err;
210 }
211
212 static void codegen(const char *template, ...)
213 {
214 const char *src, *end;
215 int skip_tabs = 0, n;
216 char *s, *dst;
217 va_list args;
218 char c;
219
220 n = strlen(template);
221 s = malloc(n + 1);
222 if (!s)
223 exit(-1);
224 src = template;
225 dst = s;
226
227 /* find out "baseline" indentation to skip */
228 while ((c = *src++)) {
229 if (c == '\t') {
230 skip_tabs++;
231 } else if (c == '\n') {
232 break;
233 } else {
234 p_err("unrecognized character at pos %td in template '%s'",
235 src - template - 1, template);
236 free(s);
237 exit(-1);
238 }
239 }
240
241 while (*src) {
242 /* skip baseline indentation tabs */
243 for (n = skip_tabs; n > 0; n--, src++) {
244 if (*src != '\t') {
245 p_err("not enough tabs at pos %td in template '%s'",
246 src - template - 1, template);
247 free(s);
248 exit(-1);
249 }
250 }
251 /* trim trailing whitespace */
252 end = strchrnul(src, '\n');
253 for (n = end - src; n > 0 && isspace(src[n - 1]); n--)
254 ;
255 memcpy(dst, src, n);
256 dst += n;
257 if (*end)
258 *dst++ = '\n';
259 src = *end ? end + 1 : end;
260 }
261 *dst++ = '\0';
262
263 /* print out using adjusted template */
264 va_start(args, template);
265 n = vprintf(s, args);
266 va_end(args);
267
268 free(s);
269 }
270
271 static int do_skeleton(int argc, char **argv)
272 {
273 char header_guard[MAX_OBJ_NAME_LEN + sizeof("__SKEL_H__")];
274 size_t i, map_cnt = 0, prog_cnt = 0, file_sz, mmap_sz;
275 DECLARE_LIBBPF_OPTS(bpf_object_open_opts, opts);
276 char obj_name[MAX_OBJ_NAME_LEN], *obj_data;
277 struct bpf_object *obj = NULL;
278 const char *file, *ident;
279 struct bpf_program *prog;
280 int fd, len, err = -1;
281 struct bpf_map *map;
282 struct btf *btf;
283 struct stat st;
284
285 if (!REQ_ARGS(1)) {
286 usage();
287 return -1;
288 }
289 file = GET_ARG();
290
291 if (argc) {
292 p_err("extra unknown arguments");
293 return -1;
294 }
295
296 if (stat(file, &st)) {
297 p_err("failed to stat() %s: %s", file, strerror(errno));
298 return -1;
299 }
300 file_sz = st.st_size;
301 mmap_sz = roundup(file_sz, sysconf(_SC_PAGE_SIZE));
302 fd = open(file, O_RDONLY);
303 if (fd < 0) {
304 p_err("failed to open() %s: %s", file, strerror(errno));
305 return -1;
306 }
307 obj_data = mmap(NULL, mmap_sz, PROT_READ, MAP_PRIVATE, fd, 0);
308 if (obj_data == MAP_FAILED) {
309 obj_data = NULL;
310 p_err("failed to mmap() %s: %s", file, strerror(errno));
311 goto out;
312 }
313 get_obj_name(obj_name, file);
314 opts.object_name = obj_name;
315 obj = bpf_object__open_mem(obj_data, file_sz, &opts);
316 if (IS_ERR(obj)) {
317 char err_buf[256];
318
319 libbpf_strerror(PTR_ERR(obj), err_buf, sizeof(err_buf));
320 p_err("failed to open BPF object file: %s", err_buf);
321 obj = NULL;
322 goto out;
323 }
324
325 bpf_object__for_each_map(map, obj) {
326 ident = get_map_ident(map);
327 if (!ident) {
328 p_err("ignoring unrecognized internal map '%s'...",
329 bpf_map__name(map));
330 continue;
331 }
332 map_cnt++;
333 }
334 bpf_object__for_each_program(prog, obj) {
335 prog_cnt++;
336 }
337
338 get_header_guard(header_guard, obj_name);
339 codegen("\
340 \n\
341 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */ \n\
342 \n\
343 /* THIS FILE IS AUTOGENERATED! */ \n\
344 #ifndef %2$s \n\
345 #define %2$s \n\
346 \n\
347 #include <stdlib.h> \n\
348 #include <bpf/libbpf.h> \n\
349 \n\
350 struct %1$s { \n\
351 struct bpf_object_skeleton *skeleton; \n\
352 struct bpf_object *obj; \n\
353 ",
354 obj_name, header_guard
355 );
356
357 if (map_cnt) {
358 printf("\tstruct {\n");
359 bpf_object__for_each_map(map, obj) {
360 ident = get_map_ident(map);
361 if (!ident)
362 continue;
363 printf("\t\tstruct bpf_map *%s;\n", ident);
364 }
365 printf("\t} maps;\n");
366 }
367
368 if (prog_cnt) {
369 printf("\tstruct {\n");
370 bpf_object__for_each_program(prog, obj) {
371 printf("\t\tstruct bpf_program *%s;\n",
372 bpf_program__name(prog));
373 }
374 printf("\t} progs;\n");
375 printf("\tstruct {\n");
376 bpf_object__for_each_program(prog, obj) {
377 printf("\t\tstruct bpf_link *%s;\n",
378 bpf_program__name(prog));
379 }
380 printf("\t} links;\n");
381 }
382
383 btf = bpf_object__btf(obj);
384 if (btf) {
385 err = codegen_datasecs(obj, obj_name);
386 if (err)
387 goto out;
388 }
389
390 codegen("\
391 \n\
392 }; \n\
393 \n\
394 static void \n\
395 %1$s__destroy(struct %1$s *obj) \n\
396 { \n\
397 if (!obj) \n\
398 return; \n\
399 if (obj->skeleton) \n\
400 bpf_object__destroy_skeleton(obj->skeleton);\n\
401 free(obj); \n\
402 } \n\
403 \n\
404 static inline int \n\
405 %1$s__create_skeleton(struct %1$s *obj); \n\
406 \n\
407 static inline struct %1$s * \n\
408 %1$s__open_opts(const struct bpf_object_open_opts *opts) \n\
409 { \n\
410 struct %1$s *obj; \n\
411 \n\
412 obj = (struct %1$s *)calloc(1, sizeof(*obj)); \n\
413 if (!obj) \n\
414 return NULL; \n\
415 if (%1$s__create_skeleton(obj)) \n\
416 goto err; \n\
417 if (bpf_object__open_skeleton(obj->skeleton, opts)) \n\
418 goto err; \n\
419 \n\
420 return obj; \n\
421 err: \n\
422 %1$s__destroy(obj); \n\
423 return NULL; \n\
424 } \n\
425 \n\
426 static inline struct %1$s * \n\
427 %1$s__open(void) \n\
428 { \n\
429 return %1$s__open_opts(NULL); \n\
430 } \n\
431 \n\
432 static inline int \n\
433 %1$s__load(struct %1$s *obj) \n\
434 { \n\
435 return bpf_object__load_skeleton(obj->skeleton); \n\
436 } \n\
437 \n\
438 static inline struct %1$s * \n\
439 %1$s__open_and_load(void) \n\
440 { \n\
441 struct %1$s *obj; \n\
442 \n\
443 obj = %1$s__open(); \n\
444 if (!obj) \n\
445 return NULL; \n\
446 if (%1$s__load(obj)) { \n\
447 %1$s__destroy(obj); \n\
448 return NULL; \n\
449 } \n\
450 return obj; \n\
451 } \n\
452 \n\
453 static inline int \n\
454 %1$s__attach(struct %1$s *obj) \n\
455 { \n\
456 return bpf_object__attach_skeleton(obj->skeleton); \n\
457 } \n\
458 \n\
459 static inline void \n\
460 %1$s__detach(struct %1$s *obj) \n\
461 { \n\
462 return bpf_object__detach_skeleton(obj->skeleton); \n\
463 } \n\
464 ",
465 obj_name
466 );
467
468 codegen("\
469 \n\
470 \n\
471 static inline int \n\
472 %1$s__create_skeleton(struct %1$s *obj) \n\
473 { \n\
474 struct bpf_object_skeleton *s; \n\
475 \n\
476 s = (struct bpf_object_skeleton *)calloc(1, sizeof(*s));\n\
477 if (!s) \n\
478 return -1; \n\
479 obj->skeleton = s; \n\
480 \n\
481 s->sz = sizeof(*s); \n\
482 s->name = \"%1$s\"; \n\
483 s->obj = &obj->obj; \n\
484 ",
485 obj_name
486 );
487 if (map_cnt) {
488 codegen("\
489 \n\
490 \n\
491 /* maps */ \n\
492 s->map_cnt = %zu; \n\
493 s->map_skel_sz = sizeof(*s->maps); \n\
494 s->maps = (struct bpf_map_skeleton *)calloc(s->map_cnt, s->map_skel_sz);\n\
495 if (!s->maps) \n\
496 goto err; \n\
497 ",
498 map_cnt
499 );
500 i = 0;
501 bpf_object__for_each_map(map, obj) {
502 ident = get_map_ident(map);
503
504 if (!ident)
505 continue;
506
507 codegen("\
508 \n\
509 \n\
510 s->maps[%zu].name = \"%s\"; \n\
511 s->maps[%zu].map = &obj->maps.%s; \n\
512 ",
513 i, bpf_map__name(map), i, ident);
514 /* memory-mapped internal maps */
515 if (bpf_map__is_internal(map) &&
516 (bpf_map__def(map)->map_flags & BPF_F_MMAPABLE)) {
517 printf("\ts->maps[%zu].mmaped = (void **)&obj->%s;\n",
518 i, ident);
519 }
520 i++;
521 }
522 }
523 if (prog_cnt) {
524 codegen("\
525 \n\
526 \n\
527 /* programs */ \n\
528 s->prog_cnt = %zu; \n\
529 s->prog_skel_sz = sizeof(*s->progs); \n\
530 s->progs = (struct bpf_prog_skeleton *)calloc(s->prog_cnt, s->prog_skel_sz);\n\
531 if (!s->progs) \n\
532 goto err; \n\
533 ",
534 prog_cnt
535 );
536 i = 0;
537 bpf_object__for_each_program(prog, obj) {
538 codegen("\
539 \n\
540 \n\
541 s->progs[%1$zu].name = \"%2$s\"; \n\
542 s->progs[%1$zu].prog = &obj->progs.%2$s;\n\
543 s->progs[%1$zu].link = &obj->links.%2$s;\n\
544 ",
545 i, bpf_program__name(prog));
546 i++;
547 }
548 }
549 codegen("\
550 \n\
551 \n\
552 s->data_sz = %d; \n\
553 s->data = (void *)\"\\ \n\
554 ",
555 file_sz);
556
557 /* embed contents of BPF object file */
558 for (i = 0, len = 0; i < file_sz; i++) {
559 int w = obj_data[i] ? 4 : 2;
560
561 len += w;
562 if (len > 78) {
563 printf("\\\n");
564 len = w;
565 }
566 if (!obj_data[i])
567 printf("\\0");
568 else
569 printf("\\x%02x", (unsigned char)obj_data[i]);
570 }
571
572 codegen("\
573 \n\
574 \"; \n\
575 \n\
576 return 0; \n\
577 err: \n\
578 bpf_object__destroy_skeleton(s); \n\
579 return -1; \n\
580 } \n\
581 \n\
582 #endif /* %s */ \n\
583 ",
584 header_guard);
585 err = 0;
586 out:
587 bpf_object__close(obj);
588 if (obj_data)
589 munmap(obj_data, mmap_sz);
590 close(fd);
591 return err;
592 }
593
594 static int do_help(int argc, char **argv)
595 {
596 if (json_output) {
597 jsonw_null(json_wtr);
598 return 0;
599 }
600
601 fprintf(stderr,
602 "Usage: %1$s %2$s skeleton FILE\n"
603 " %1$s %2$s help\n"
604 "\n"
605 " " HELP_SPEC_OPTIONS "\n"
606 "",
607 bin_name, "gen");
608
609 return 0;
610 }
611
612 static const struct cmd cmds[] = {
613 { "skeleton", do_skeleton },
614 { "help", do_help },
615 { 0 }
616 };
617
618 int do_gen(int argc, char **argv)
619 {
620 return cmd_select(cmds, argc, argv, do_help);
621 }
Linux with added FPC-III support