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