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