1 // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
2 #include <bpf/bpf.h>
3 #include <bpf/libbpf.h>
4 #include <test_progs.h>
5
6 #ifdef HAVE_LLVM_SUPPORT
7
8 #include <llvm-c/Core.h>
9 #include <llvm-c/Disassembler.h>
10 #include <llvm-c/Target.h>
11 #include <llvm-c/TargetMachine.h>
12
13 /* The intent is to use get_jited_program_text() for small test
14 * programs written in BPF assembly, thus assume that 32 local labels
15 * would be sufficient.
16 */
17 #define MAX_LOCAL_LABELS 32
18
19 /* Local labels are encoded as 'L42', this requires 4 bytes of storage:
20 * 3 characters + zero byte
21 */
22 #define LOCAL_LABEL_LEN 4
23
24 static bool llvm_initialized;
25
26 struct local_labels {
27 bool print_phase;
28 __u32 prog_len;
29 __u32 cnt;
30 __u32 pcs[MAX_LOCAL_LABELS];
31 char names[MAX_LOCAL_LABELS][LOCAL_LABEL_LEN];
32 };
33
34 static const char *lookup_symbol(void *data, uint64_t ref_value, uint64_t *ref_type,
35 uint64_t ref_pc, const char **ref_name)
36 {
37 struct local_labels *labels = data;
38 uint64_t type = *ref_type;
39 int i;
40
41 *ref_type = LLVMDisassembler_ReferenceType_InOut_None;
42 *ref_name = NULL;
43 if (type != LLVMDisassembler_ReferenceType_In_Branch)
44 return NULL;
45 /* Depending on labels->print_phase either discover local labels or
46 * return a name assigned with local jump target:
47 * - if print_phase is true and ref_value is in labels->pcs,
48 * return corresponding labels->name.
49 * - if print_phase is false, save program-local jump targets
50 * in labels->pcs;
51 */
52 if (labels->print_phase) {
53 for (i = 0; i < labels->cnt; ++i)
54 if (labels->pcs[i] == ref_value)
55 return labels->names[i];
56 } else {
57 if (labels->cnt < MAX_LOCAL_LABELS && ref_value < labels->prog_len)
58 labels->pcs[labels->cnt++] = ref_value;
59 }
60 return NULL;
61 }
62
63 static int disasm_insn(LLVMDisasmContextRef ctx, uint8_t *image, __u32 len, __u32 pc,
64 char *buf, __u32 buf_sz)
65 {
66 int i, cnt;
67
68 cnt = LLVMDisasmInstruction(ctx, image + pc, len - pc, pc,
69 buf, buf_sz);
70 if (cnt > 0)
71 return cnt;
72 PRINT_FAIL("Can't disasm instruction at offset %d:", pc);
73 for (i = 0; i < 16 && pc + i < len; ++i)
74 printf(" %02x", image[pc + i]);
75 printf("\n");
76 return -EINVAL;
77 }
78
79 static int cmp_u32(const void *_a, const void *_b)
80 {
81 __u32 a = *(__u32 *)_a;
82 __u32 b = *(__u32 *)_b;
83
84 if (a < b)
85 return -1;
86 if (a > b)
87 return 1;
88 return 0;
89 }
90
91 static int disasm_one_func(FILE *text_out, uint8_t *image, __u32 len)
92 {
93 char *label, *colon, *triple = NULL;
94 LLVMDisasmContextRef ctx = NULL;
95 struct local_labels labels = {};
96 __u32 *label_pc, pc;
97 int i, cnt, err = 0;
98 char buf[64];
99
100 triple = LLVMGetDefaultTargetTriple();
101 ctx = LLVMCreateDisasm(triple, &labels, 0, NULL, lookup_symbol);
102 if (!ASSERT_OK_PTR(ctx, "LLVMCreateDisasm")) {
103 err = -EINVAL;
104 goto out;
105 }
106
107 cnt = LLVMSetDisasmOptions(ctx, LLVMDisassembler_Option_PrintImmHex);
108 if (!ASSERT_EQ(cnt, 1, "LLVMSetDisasmOptions")) {
109 err = -EINVAL;
110 goto out;
111 }
112
113 /* discover labels */
114 labels.prog_len = len;
115 pc = 0;
116 while (pc < len) {
117 cnt = disasm_insn(ctx, image, len, pc, buf, 1);
118 if (cnt < 0) {
119 err = cnt;
120 goto out;
121 }
122 pc += cnt;
123 }
124 qsort(labels.pcs, labels.cnt, sizeof(*labels.pcs), cmp_u32);
125 for (i = 0; i < labels.cnt; ++i)
126 /* gcc is unable to infer upper bound for labels.cnt and assumes
127 * it to be U32_MAX. U32_MAX takes 10 decimal digits.
128 * snprintf below prints into labels.names[*],
129 * which has space only for two digits and a letter.
130 * To avoid truncation warning use (i % MAX_LOCAL_LABELS),
131 * which informs gcc about printed value upper bound.
132 */
133 snprintf(labels.names[i], sizeof(labels.names[i]), "L%d", i % MAX_LOCAL_LABELS);
134
135 /* now print with labels */
136 labels.print_phase = true;
137 pc = 0;
138 while (pc < len) {
139 cnt = disasm_insn(ctx, image, len, pc, buf, sizeof(buf));
140 if (cnt < 0) {
141 err = cnt;
142 goto out;
143 }
144 label_pc = bsearch(&pc, labels.pcs, labels.cnt, sizeof(*labels.pcs), cmp_u32);
145 label = "";
146 colon = "";
147 if (label_pc) {
148 label = labels.names[label_pc - labels.pcs];
149 colon = ":";
150 }
151 fprintf(text_out, "%x:\t", pc);
152 for (i = 0; i < cnt; ++i)
153 fprintf(text_out, "%02x ", image[pc + i]);
154 for (i = cnt * 3; i < 12 * 3; ++i)
155 fputc(' ', text_out);
156 fprintf(text_out, "%s%s%s\n", label, colon, buf);
157 pc += cnt;
158 }
159
160 out:
161 if (triple)
162 LLVMDisposeMessage(triple);
163 if (ctx)
164 LLVMDisasmDispose(ctx);
165 return err;
166 }
167
168 int get_jited_program_text(int fd, char *text, size_t text_sz)
169 {
170 struct bpf_prog_info info = {};
171 __u32 info_len = sizeof(info);
172 __u32 jited_funcs, len, pc;
173 __u32 *func_lens = NULL;
174 FILE *text_out = NULL;
175 uint8_t *image = NULL;
176 int i, err = 0;
177
178 if (!llvm_initialized) {
179 LLVMInitializeAllTargetInfos();
180 LLVMInitializeAllTargetMCs();
181 LLVMInitializeAllDisassemblers();
182 llvm_initialized = 1;
183 }
184
185 text_out = fmemopen(text, text_sz, "w");
186 if (!ASSERT_OK_PTR(text_out, "open_memstream")) {
187 err = -errno;
188 goto out;
189 }
190
191 /* first call is to find out jited program len */
192 err = bpf_prog_get_info_by_fd(fd, &info, &info_len);
193 if (!ASSERT_OK(err, "bpf_prog_get_info_by_fd #1"))
194 goto out;
195
196 len = info.jited_prog_len;
197 image = malloc(len);
198 if (!ASSERT_OK_PTR(image, "malloc(info.jited_prog_len)")) {
199 err = -ENOMEM;
200 goto out;
201 }
202
203 jited_funcs = info.nr_jited_func_lens;
204 func_lens = malloc(jited_funcs * sizeof(__u32));
205 if (!ASSERT_OK_PTR(func_lens, "malloc(info.nr_jited_func_lens)")) {
206 err = -ENOMEM;
207 goto out;
208 }
209
210 memset(&info, 0, sizeof(info));
211 info.jited_prog_insns = (__u64)image;
212 info.jited_prog_len = len;
213 info.jited_func_lens = (__u64)func_lens;
214 info.nr_jited_func_lens = jited_funcs;
215 err = bpf_prog_get_info_by_fd(fd, &info, &info_len);
216 if (!ASSERT_OK(err, "bpf_prog_get_info_by_fd #2"))
217 goto out;
218
219 for (pc = 0, i = 0; i < jited_funcs; ++i) {
220 fprintf(text_out, "func #%d:\n", i);
221 disasm_one_func(text_out, image + pc, func_lens[i]);
222 fprintf(text_out, "\n");
223 pc += func_lens[i];
224 }
225
226 out:
227 if (text_out)
228 fclose(text_out);
229 if (image)
230 free(image);
231 if (func_lens)
232 free(func_lens);
233 return err;
234 }
235
236 #else /* HAVE_LLVM_SUPPORT */
237
238 int get_jited_program_text(int fd, char *text, size_t text_sz)
239 {
240 if (env.verbosity >= VERBOSE_VERY)
241 printf("compiled w/o llvm development libraries, can't dis-assembly binary code");
242 return -EOPNOTSUPP;
243 }
244
245 #endif /* HAVE_LLVM_SUPPORT */
246
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.