1 /*
2 * Copyright © 2016 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <stdint.h>
27 #include <stdbool.h>
28 #include <getopt.h>
29
30 #include <unistd.h>
31 #include <fcntl.h>
32 #include <string.h>
33 #include <signal.h>
34 #include <errno.h>
35 #include <inttypes.h>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <sys/wait.h>
39 #include <sys/mman.h>
40
41 #include "util/macros.h"
42
43 #include "aub_read.h"
44 #include "aub_mem.h"
45
46 #define CSI "\e["
47 #define BLUE_HEADER CSI "0;44m"
48 #define GREEN_HEADER CSI "1;42m"
49 #define NORMAL CSI "0m"
50
51 /* options */
52
53 static int option_full_decode = true;
54 static int option_print_offsets = true;
55 static int max_vbo_lines = -1;
56 static enum { COLOR_AUTO, COLOR_ALWAYS, COLOR_NEVER } option_color;
57
58 /* state */
59
60 uint16_t pci_id = 0;
61 char *input_file = NULL, *xml_path = NULL;
62 struct gen_device_info devinfo;
63 struct gen_batch_decode_ctx batch_ctx;
64 struct aub_mem mem;
65
66 FILE *outfile;
67
68 struct brw_instruction;
69
70 static void
aubinator_error(void * user_data,const void * aub_data,const char * msg)71 aubinator_error(void *user_data, const void *aub_data, const char *msg)
72 {
73 fprintf(stderr, "%s", msg);
74 }
75
76 static void
aubinator_init(void * user_data,int aub_pci_id,const char * app_name)77 aubinator_init(void *user_data, int aub_pci_id, const char *app_name)
78 {
79 pci_id = aub_pci_id;
80
81 if (!gen_get_device_info_from_pci_id(pci_id, &devinfo)) {
82 fprintf(stderr, "can't find device information: pci_id=0x%x\n", pci_id);
83 exit(EXIT_FAILURE);
84 }
85
86 enum gen_batch_decode_flags batch_flags = 0;
87 if (option_color == COLOR_ALWAYS)
88 batch_flags |= GEN_BATCH_DECODE_IN_COLOR;
89 if (option_full_decode)
90 batch_flags |= GEN_BATCH_DECODE_FULL;
91 if (option_print_offsets)
92 batch_flags |= GEN_BATCH_DECODE_OFFSETS;
93 batch_flags |= GEN_BATCH_DECODE_FLOATS;
94
95 gen_batch_decode_ctx_init(&batch_ctx, &devinfo, outfile, batch_flags,
96 xml_path, NULL, NULL, NULL);
97
98 /* Check for valid spec instance, if wrong xml_path is passed then spec
99 * instance is not initialized properly
100 */
101 if (!batch_ctx.spec) {
102 fprintf(stderr, "Failed to initialize gen_batch_decode_ctx "
103 "spec instance\n");
104 free(xml_path);
105 gen_batch_decode_ctx_finish(&batch_ctx);
106 exit(EXIT_FAILURE);
107 }
108
109 batch_ctx.max_vbo_decoded_lines = max_vbo_lines;
110
111 char *color = GREEN_HEADER, *reset_color = NORMAL;
112 if (option_color == COLOR_NEVER)
113 color = reset_color = "";
114
115 fprintf(outfile, "%sAubinator: Intel AUB file decoder.%-80s%s\n",
116 color, "", reset_color);
117
118 if (input_file)
119 fprintf(outfile, "File name: %s\n", input_file);
120
121 if (aub_pci_id)
122 fprintf(outfile, "PCI ID: 0x%x\n", aub_pci_id);
123
124 fprintf(outfile, "Application name: %s\n", app_name);
125
126 fprintf(outfile, "Decoding as: %s\n", gen_get_device_name(pci_id));
127
128 /* Throw in a new line before the first batch */
129 fprintf(outfile, "\n");
130 }
131
132 static struct gen_batch_decode_bo
get_bo(void * user_data,bool ppgtt,uint64_t addr)133 get_bo(void *user_data, bool ppgtt, uint64_t addr)
134 {
135 if (ppgtt)
136 return aub_mem_get_ppgtt_bo(user_data, addr);
137 else
138 return aub_mem_get_ggtt_bo(user_data, addr);
139 }
140
141 static void
handle_execlist_write(void * user_data,enum drm_i915_gem_engine_class engine,uint64_t context_descriptor)142 handle_execlist_write(void *user_data, enum drm_i915_gem_engine_class engine, uint64_t context_descriptor)
143 {
144 const uint32_t pphwsp_size = 4096;
145 uint32_t pphwsp_addr = context_descriptor & 0xfffff000;
146 struct gen_batch_decode_bo pphwsp_bo = aub_mem_get_ggtt_bo(&mem, pphwsp_addr);
147 uint32_t *context = (uint32_t *)((uint8_t *)pphwsp_bo.map +
148 (pphwsp_addr - pphwsp_bo.addr) +
149 pphwsp_size);
150
151 uint32_t ring_buffer_head = context[5];
152 uint32_t ring_buffer_tail = context[7];
153 uint32_t ring_buffer_start = context[9];
154 uint32_t ring_buffer_length = (context[11] & 0x1ff000) + 4096;
155
156 mem.pml4 = (uint64_t)context[49] << 32 | context[51];
157 batch_ctx.user_data = &mem;
158
159 struct gen_batch_decode_bo ring_bo = aub_mem_get_ggtt_bo(&mem,
160 ring_buffer_start);
161 assert(ring_bo.size > 0);
162 void *commands = (uint8_t *)ring_bo.map + (ring_buffer_start - ring_bo.addr) + ring_buffer_head;
163
164 batch_ctx.get_bo = get_bo;
165
166 batch_ctx.engine = engine;
167 gen_print_batch(&batch_ctx, commands,
168 MIN2(ring_buffer_tail - ring_buffer_head, ring_buffer_length),
169 ring_bo.addr + ring_buffer_head, true);
170 aub_mem_clear_bo_maps(&mem);
171 }
172
173 static struct gen_batch_decode_bo
get_legacy_bo(void * user_data,bool ppgtt,uint64_t addr)174 get_legacy_bo(void *user_data, bool ppgtt, uint64_t addr)
175 {
176 return aub_mem_get_ggtt_bo(user_data, addr);
177 }
178
179 static void
handle_ring_write(void * user_data,enum drm_i915_gem_engine_class engine,const void * data,uint32_t data_len)180 handle_ring_write(void *user_data, enum drm_i915_gem_engine_class engine,
181 const void *data, uint32_t data_len)
182 {
183 batch_ctx.user_data = &mem;
184 batch_ctx.get_bo = get_legacy_bo;
185
186 batch_ctx.engine = engine;
187 gen_print_batch(&batch_ctx, data, data_len, 0, false);
188
189 aub_mem_clear_bo_maps(&mem);
190 }
191
192 struct aub_file {
193 FILE *stream;
194
195 void *map, *end, *cursor;
196 };
197
198 static struct aub_file *
aub_file_open(const char * filename)199 aub_file_open(const char *filename)
200 {
201 struct aub_file *file;
202 struct stat sb;
203 int fd;
204
205 file = calloc(1, sizeof *file);
206 if (file == NULL)
207 return NULL;
208
209 fd = open(filename, O_RDONLY);
210 if (fd == -1) {
211 fprintf(stderr, "open %s failed: %s\n", filename, strerror(errno));
212 free(file);
213 exit(EXIT_FAILURE);
214 }
215
216 if (fstat(fd, &sb) == -1) {
217 fprintf(stderr, "stat failed: %s\n", strerror(errno));
218 free(file);
219 exit(EXIT_FAILURE);
220 }
221
222 file->map = mmap(NULL, sb.st_size,
223 PROT_READ, MAP_SHARED, fd, 0);
224 if (file->map == MAP_FAILED) {
225 fprintf(stderr, "mmap failed: %s\n", strerror(errno));
226 free(file);
227 exit(EXIT_FAILURE);
228 }
229
230 close(fd);
231
232 file->cursor = file->map;
233 file->end = file->map + sb.st_size;
234
235 return file;
236 }
237
238 static int
aub_file_more_stuff(struct aub_file * file)239 aub_file_more_stuff(struct aub_file *file)
240 {
241 return file->cursor < file->end || (file->stream && !feof(file->stream));
242 }
243
244 static void
setup_pager(void)245 setup_pager(void)
246 {
247 int fds[2];
248 pid_t pid;
249
250 if (!isatty(1))
251 return;
252
253 if (pipe(fds) == -1)
254 return;
255
256 pid = fork();
257 if (pid == -1)
258 return;
259
260 if (pid == 0) {
261 close(fds[1]);
262 dup2(fds[0], 0);
263 execlp("less", "less", "-FRSi", NULL);
264 }
265
266 close(fds[0]);
267 dup2(fds[1], 1);
268 close(fds[1]);
269 }
270
271 static void
print_help(const char * progname,FILE * file)272 print_help(const char *progname, FILE *file)
273 {
274 fprintf(file,
275 "Usage: %s [OPTION]... FILE\n"
276 "Decode aub file contents from FILE.\n\n"
277 " --help display this help and exit\n"
278 " --gen=platform decode for given platform (3 letter platform name)\n"
279 " --headers decode only command headers\n"
280 " --color[=WHEN] colorize the output; WHEN can be 'auto' (default\n"
281 " if omitted), 'always', or 'never'\n"
282 " --max-vbo-lines=N limit the number of decoded VBO lines\n"
283 " --no-pager don't launch pager\n"
284 " --no-offsets don't print instruction offsets\n"
285 " --xml=DIR load hardware xml description from directory DIR\n",
286 progname);
287 }
288
main(int argc,char * argv[])289 int main(int argc, char *argv[])
290 {
291 struct aub_file *file;
292 int c, i;
293 bool help = false, pager = true;
294 const struct option aubinator_opts[] = {
295 { "help", no_argument, (int *) &help, true },
296 { "no-pager", no_argument, (int *) &pager, false },
297 { "no-offsets", no_argument, (int *) &option_print_offsets, false },
298 { "gen", required_argument, NULL, 'g' },
299 { "headers", no_argument, (int *) &option_full_decode, false },
300 { "color", required_argument, NULL, 'c' },
301 { "xml", required_argument, NULL, 'x' },
302 { "max-vbo-lines", required_argument, NULL, 'v' },
303 { NULL, 0, NULL, 0 }
304 };
305
306 outfile = stdout;
307
308 i = 0;
309 while ((c = getopt_long(argc, argv, "", aubinator_opts, &i)) != -1) {
310 switch (c) {
311 case 'g': {
312 const int id = gen_device_name_to_pci_device_id(optarg);
313 if (id < 0) {
314 fprintf(stderr, "can't parse gen: '%s', expected brw, g4x, ilk, "
315 "snb, ivb, hsw, byt, bdw, chv, skl, bxt, kbl, "
316 "aml, glk, cfl, whl, cnl, icl", optarg);
317 exit(EXIT_FAILURE);
318 } else {
319 pci_id = id;
320 }
321 break;
322 }
323 case 'c':
324 if (optarg == NULL || strcmp(optarg, "always") == 0)
325 option_color = COLOR_ALWAYS;
326 else if (strcmp(optarg, "never") == 0)
327 option_color = COLOR_NEVER;
328 else if (strcmp(optarg, "auto") == 0)
329 option_color = COLOR_AUTO;
330 else {
331 fprintf(stderr, "invalid value for --color: %s", optarg);
332 exit(EXIT_FAILURE);
333 }
334 break;
335 case 'x':
336 xml_path = strdup(optarg);
337 break;
338 case 'v':
339 max_vbo_lines = atoi(optarg);
340 break;
341 default:
342 break;
343 }
344 }
345
346 if (optind < argc)
347 input_file = argv[optind];
348
349 if (help || !input_file) {
350 print_help(argv[0], stderr);
351 exit(0);
352 }
353
354 /* Do this before we redirect stdout to pager. */
355 if (option_color == COLOR_AUTO)
356 option_color = isatty(1) ? COLOR_ALWAYS : COLOR_NEVER;
357
358 if (isatty(1) && pager)
359 setup_pager();
360
361 if (!aub_mem_init(&mem)) {
362 fprintf(stderr, "Unable to create GTT\n");
363 exit(EXIT_FAILURE);
364 }
365
366 file = aub_file_open(input_file);
367 if (!file) {
368 fprintf(stderr, "Unable to allocate buffer to open aub file\n");
369 free(xml_path);
370 exit(EXIT_FAILURE);
371 }
372
373 struct aub_read aub_read = {
374 .user_data = &mem,
375 .error = aubinator_error,
376 .info = aubinator_init,
377
378 .local_write = aub_mem_local_write,
379 .phys_write = aub_mem_phys_write,
380 .ggtt_write = aub_mem_ggtt_write,
381 .ggtt_entry_write = aub_mem_ggtt_entry_write,
382
383 .execlist_write = handle_execlist_write,
384 .ring_write = handle_ring_write,
385 };
386 int consumed;
387 while (aub_file_more_stuff(file) &&
388 (consumed = aub_read_command(&aub_read, file->cursor,
389 file->end - file->cursor)) > 0) {
390 file->cursor += consumed;
391 }
392
393 aub_mem_fini(&mem);
394
395 fflush(stdout);
396 /* close the stdout which is opened to write the output */
397 close(1);
398 free(file);
399 free(xml_path);
400
401 wait(NULL);
402 gen_batch_decode_ctx_finish(&batch_ctx);
403
404 return EXIT_SUCCESS;
405 }
406