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 <getopt.h>
28
29 #include <unistd.h>
30 #include <fcntl.h>
31 #include <string.h>
32 #include <signal.h>
33 #include <errno.h>
34 #include <inttypes.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <sys/wait.h>
38 #include <sys/mman.h>
39
40 #include "util/macros.h"
41
42 #include "common/gen_decoder.h"
43 #include "intel_aub.h"
44 #include "gen_disasm.h"
45
46 /* Below is the only command missing from intel_aub.h in libdrm
47 * So, reuse intel_aub.h from libdrm and #define the
48 * AUB_MI_BATCH_BUFFER_END as below
49 */
50 #define AUB_MI_BATCH_BUFFER_END (0x0500 << 16)
51
52 #define CSI "\e["
53 #define BLUE_HEADER CSI "0;44m"
54 #define GREEN_HEADER CSI "1;42m"
55 #define NORMAL CSI "0m"
56
57 /* options */
58
59 static bool option_full_decode = true;
60 static bool option_print_offsets = true;
61 static enum { COLOR_AUTO, COLOR_ALWAYS, COLOR_NEVER } option_color;
62
63 /* state */
64
65 uint16_t pci_id = 0;
66 char *input_file = NULL, *xml_path = NULL;
67 struct gen_device_info devinfo;
68 struct gen_batch_decode_ctx batch_ctx;
69
70 uint64_t gtt_size, gtt_end;
71 void *gtt;
72 uint64_t general_state_base;
73 uint64_t surface_state_base;
74 uint64_t dynamic_state_base;
75 uint64_t instruction_base;
76 uint64_t instruction_bound;
77
78 FILE *outfile;
79
80 static inline uint32_t
field(uint32_t value,int start,int end)81 field(uint32_t value, int start, int end)
82 {
83 uint32_t mask;
84
85 mask = ~0U >> (31 - end + start);
86
87 return (value >> start) & mask;
88 }
89
90 struct brw_instruction;
91
92 static inline int
valid_offset(uint32_t offset)93 valid_offset(uint32_t offset)
94 {
95 return offset < gtt_end;
96 }
97
98 #define GEN_ENGINE_RENDER 1
99 #define GEN_ENGINE_BLITTER 2
100
101 static void
handle_trace_block(uint32_t * p)102 handle_trace_block(uint32_t *p)
103 {
104 int operation = p[1] & AUB_TRACE_OPERATION_MASK;
105 int type = p[1] & AUB_TRACE_TYPE_MASK;
106 int address_space = p[1] & AUB_TRACE_ADDRESS_SPACE_MASK;
107 uint64_t offset = p[3];
108 uint32_t size = p[4];
109 int header_length = p[0] & 0xffff;
110 uint32_t *data = p + header_length + 2;
111 int engine = GEN_ENGINE_RENDER;
112
113 if (devinfo.gen >= 8)
114 offset += (uint64_t) p[5] << 32;
115
116 switch (operation) {
117 case AUB_TRACE_OP_DATA_WRITE:
118 if (address_space != AUB_TRACE_MEMTYPE_GTT)
119 break;
120 if (gtt_size < offset + size) {
121 fprintf(stderr, "overflow gtt space: %s\n", strerror(errno));
122 exit(EXIT_FAILURE);
123 }
124 memcpy((char *) gtt + offset, data, size);
125 if (gtt_end < offset + size)
126 gtt_end = offset + size;
127 break;
128 case AUB_TRACE_OP_COMMAND_WRITE:
129 switch (type) {
130 case AUB_TRACE_TYPE_RING_PRB0:
131 engine = GEN_ENGINE_RENDER;
132 break;
133 case AUB_TRACE_TYPE_RING_PRB2:
134 engine = GEN_ENGINE_BLITTER;
135 break;
136 default:
137 fprintf(outfile, "command write to unknown ring %d\n", type);
138 break;
139 }
140
141 (void)engine; /* TODO */
142 gen_print_batch(&batch_ctx, data, size, 0);
143
144 gtt_end = 0;
145 break;
146 }
147 }
148
149 static struct gen_batch_decode_bo
get_gen_batch_bo(void * user_data,uint64_t address)150 get_gen_batch_bo(void *user_data, uint64_t address)
151 {
152 if (address > gtt_end)
153 return (struct gen_batch_decode_bo) { .map = NULL };
154
155 /* We really only have one giant address range */
156 return (struct gen_batch_decode_bo) {
157 .addr = 0,
158 .map = gtt,
159 .size = gtt_size
160 };
161 }
162
163 static void
aubinator_init(uint16_t aub_pci_id,const char * app_name)164 aubinator_init(uint16_t aub_pci_id, const char *app_name)
165 {
166 if (!gen_get_device_info(pci_id, &devinfo)) {
167 fprintf(stderr, "can't find device information: pci_id=0x%x\n", pci_id);
168 exit(EXIT_FAILURE);
169 }
170
171 enum gen_batch_decode_flags batch_flags = 0;
172 if (option_color == COLOR_ALWAYS)
173 batch_flags |= GEN_BATCH_DECODE_IN_COLOR;
174 if (option_full_decode)
175 batch_flags |= GEN_BATCH_DECODE_FULL;
176 if (option_print_offsets)
177 batch_flags |= GEN_BATCH_DECODE_OFFSETS;
178 batch_flags |= GEN_BATCH_DECODE_FLOATS;
179
180 gen_batch_decode_ctx_init(&batch_ctx, &devinfo, outfile, batch_flags,
181 xml_path, get_gen_batch_bo, NULL);
182
183 char *color = GREEN_HEADER, *reset_color = NORMAL;
184 if (option_color == COLOR_NEVER)
185 color = reset_color = "";
186
187 fprintf(outfile, "%sAubinator: Intel AUB file decoder.%-80s%s\n",
188 color, "", reset_color);
189
190 if (input_file)
191 fprintf(outfile, "File name: %s\n", input_file);
192
193 if (aub_pci_id)
194 fprintf(outfile, "PCI ID: 0x%x\n", aub_pci_id);
195
196 fprintf(outfile, "Application name: %s\n", app_name);
197
198 fprintf(outfile, "Decoding as: %s\n", gen_get_device_name(pci_id));
199
200 /* Throw in a new line before the first batch */
201 fprintf(outfile, "\n");
202 }
203
204 static void
handle_trace_header(uint32_t * p)205 handle_trace_header(uint32_t *p)
206 {
207 /* The intel_aubdump tool from IGT is kind enough to put a PCI-ID= tag in
208 * the AUB header comment. If the user hasn't specified a hardware
209 * generation, try to use the one from the AUB file.
210 */
211 uint32_t *end = p + (p[0] & 0xffff) + 2;
212 int aub_pci_id = 0;
213 if (end > &p[12] && p[12] > 0)
214 sscanf((char *)&p[13], "PCI-ID=%i", &aub_pci_id);
215
216 if (pci_id == 0)
217 pci_id = aub_pci_id;
218
219 char app_name[33];
220 strncpy(app_name, (char *)&p[2], 32);
221 app_name[32] = 0;
222
223 aubinator_init(aub_pci_id, app_name);
224 }
225
226 static void
handle_memtrace_version(uint32_t * p)227 handle_memtrace_version(uint32_t *p)
228 {
229 int header_length = p[0] & 0xffff;
230 char app_name[64];
231 int app_name_len = MIN2(4 * (header_length + 1 - 5), ARRAY_SIZE(app_name) - 1);
232 int pci_id_len = 0;
233 int aub_pci_id = 0;
234
235 strncpy(app_name, (char *)&p[5], app_name_len);
236 app_name[app_name_len] = 0;
237 sscanf(app_name, "PCI-ID=%i %n", &aub_pci_id, &pci_id_len);
238 if (pci_id == 0)
239 pci_id = aub_pci_id;
240 aubinator_init(aub_pci_id, app_name + pci_id_len);
241 }
242
243 static void
handle_memtrace_reg_write(uint32_t * p)244 handle_memtrace_reg_write(uint32_t *p)
245 {
246 uint32_t offset = p[1];
247 uint32_t value = p[5];
248 int engine;
249 static int render_elsp_writes = 0;
250 static int blitter_elsp_writes = 0;
251
252 if (offset == 0x2230) {
253 render_elsp_writes++;
254 engine = GEN_ENGINE_RENDER;
255 } else if (offset == 0x22230) {
256 blitter_elsp_writes++;
257 engine = GEN_ENGINE_BLITTER;
258 } else {
259 return;
260 }
261
262 if (render_elsp_writes > 3)
263 render_elsp_writes = 0;
264 else if (blitter_elsp_writes > 3)
265 blitter_elsp_writes = 0;
266 else
267 return;
268
269 uint8_t *pphwsp = (uint8_t*)gtt + (value & 0xfffff000);
270 const uint32_t pphwsp_size = 4096;
271 uint32_t *context = (uint32_t*)(pphwsp + pphwsp_size);
272 uint32_t ring_buffer_head = context[5];
273 uint32_t ring_buffer_tail = context[7];
274 uint32_t ring_buffer_start = context[9];
275 uint32_t *commands = (uint32_t*)((uint8_t*)gtt + ring_buffer_start + ring_buffer_head);
276 (void)engine; /* TODO */
277 gen_print_batch(&batch_ctx, commands, ring_buffer_tail - ring_buffer_head, 0);
278 }
279
280 static void
handle_memtrace_mem_write(uint32_t * p)281 handle_memtrace_mem_write(uint32_t *p)
282 {
283 uint64_t address = *(uint64_t*)&p[1];
284 uint32_t address_space = p[3] >> 28;
285 uint32_t size = p[4];
286 uint32_t *data = p + 5;
287
288 if (address_space != 1)
289 return;
290
291 if (gtt_size < address + size) {
292 fprintf(stderr, "overflow gtt space: %s\n", strerror(errno));
293 exit(EXIT_FAILURE);
294 }
295
296 memcpy((char *) gtt + address, data, size);
297 if (gtt_end < address + size)
298 gtt_end = address + size;
299 }
300
301 struct aub_file {
302 FILE *stream;
303
304 uint32_t *map, *end, *cursor;
305 uint32_t *mem_end;
306 };
307
308 static struct aub_file *
aub_file_open(const char * filename)309 aub_file_open(const char *filename)
310 {
311 struct aub_file *file;
312 struct stat sb;
313 int fd;
314
315 file = calloc(1, sizeof *file);
316 fd = open(filename, O_RDONLY);
317 if (fd == -1) {
318 fprintf(stderr, "open %s failed: %s\n", filename, strerror(errno));
319 exit(EXIT_FAILURE);
320 }
321
322 if (fstat(fd, &sb) == -1) {
323 fprintf(stderr, "stat failed: %s\n", strerror(errno));
324 exit(EXIT_FAILURE);
325 }
326
327 file->map = mmap(NULL, sb.st_size,
328 PROT_READ, MAP_SHARED, fd, 0);
329 if (file->map == MAP_FAILED) {
330 fprintf(stderr, "mmap failed: %s\n", strerror(errno));
331 exit(EXIT_FAILURE);
332 }
333
334 close(fd);
335
336 file->cursor = file->map;
337 file->end = file->map + sb.st_size / 4;
338
339 return file;
340 }
341
342 static struct aub_file *
aub_file_stdin(void)343 aub_file_stdin(void)
344 {
345 struct aub_file *file;
346
347 file = calloc(1, sizeof *file);
348 file->stream = stdin;
349
350 return file;
351 }
352
353 #define TYPE(dw) (((dw) >> 29) & 7)
354 #define OPCODE(dw) (((dw) >> 23) & 0x3f)
355 #define SUBOPCODE(dw) (((dw) >> 16) & 0x7f)
356
357 #define MAKE_HEADER(type, opcode, subopcode) \
358 (((type) << 29) | ((opcode) << 23) | ((subopcode) << 16))
359
360 #define TYPE_AUB 0x7
361
362 /* Classic AUB opcodes */
363 #define OPCODE_AUB 0x01
364 #define SUBOPCODE_HEADER 0x05
365 #define SUBOPCODE_BLOCK 0x41
366 #define SUBOPCODE_BMP 0x1e
367
368 /* Newer version AUB opcode */
369 #define OPCODE_NEW_AUB 0x2e
370 #define SUBOPCODE_REG_POLL 0x02
371 #define SUBOPCODE_REG_WRITE 0x03
372 #define SUBOPCODE_MEM_POLL 0x05
373 #define SUBOPCODE_MEM_WRITE 0x06
374 #define SUBOPCODE_VERSION 0x0e
375
376 #define MAKE_GEN(major, minor) ( ((major) << 8) | (minor) )
377
378 enum {
379 AUB_ITEM_DECODE_OK,
380 AUB_ITEM_DECODE_FAILED,
381 AUB_ITEM_DECODE_NEED_MORE_DATA,
382 };
383
384 static int
aub_file_decode_batch(struct aub_file * file)385 aub_file_decode_batch(struct aub_file *file)
386 {
387 uint32_t *p, h, *new_cursor;
388 int header_length, bias;
389
390 if (file->end - file->cursor < 1)
391 return AUB_ITEM_DECODE_NEED_MORE_DATA;
392
393 p = file->cursor;
394 h = *p;
395 header_length = h & 0xffff;
396
397 switch (OPCODE(h)) {
398 case OPCODE_AUB:
399 bias = 2;
400 break;
401 case OPCODE_NEW_AUB:
402 bias = 1;
403 break;
404 default:
405 fprintf(outfile, "unknown opcode %d at %td/%td\n",
406 OPCODE(h), file->cursor - file->map,
407 file->end - file->map);
408 return AUB_ITEM_DECODE_FAILED;
409 }
410
411 new_cursor = p + header_length + bias;
412 if ((h & 0xffff0000) == MAKE_HEADER(TYPE_AUB, OPCODE_AUB, SUBOPCODE_BLOCK)) {
413 if (file->end - file->cursor < 4)
414 return AUB_ITEM_DECODE_NEED_MORE_DATA;
415 new_cursor += p[4] / 4;
416 }
417
418 if (new_cursor > file->end)
419 return AUB_ITEM_DECODE_NEED_MORE_DATA;
420
421 switch (h & 0xffff0000) {
422 case MAKE_HEADER(TYPE_AUB, OPCODE_AUB, SUBOPCODE_HEADER):
423 handle_trace_header(p);
424 break;
425 case MAKE_HEADER(TYPE_AUB, OPCODE_AUB, SUBOPCODE_BLOCK):
426 handle_trace_block(p);
427 break;
428 case MAKE_HEADER(TYPE_AUB, OPCODE_AUB, SUBOPCODE_BMP):
429 break;
430 case MAKE_HEADER(TYPE_AUB, OPCODE_NEW_AUB, SUBOPCODE_VERSION):
431 handle_memtrace_version(p);
432 break;
433 case MAKE_HEADER(TYPE_AUB, OPCODE_NEW_AUB, SUBOPCODE_REG_WRITE):
434 handle_memtrace_reg_write(p);
435 break;
436 case MAKE_HEADER(TYPE_AUB, OPCODE_NEW_AUB, SUBOPCODE_MEM_WRITE):
437 handle_memtrace_mem_write(p);
438 break;
439 case MAKE_HEADER(TYPE_AUB, OPCODE_NEW_AUB, SUBOPCODE_MEM_POLL):
440 fprintf(outfile, "memory poll block (dwords %d):\n", h & 0xffff);
441 break;
442 case MAKE_HEADER(TYPE_AUB, OPCODE_NEW_AUB, SUBOPCODE_REG_POLL):
443 break;
444 default:
445 fprintf(outfile, "unknown block type=0x%x, opcode=0x%x, "
446 "subopcode=0x%x (%08x)\n", TYPE(h), OPCODE(h), SUBOPCODE(h), h);
447 break;
448 }
449 file->cursor = new_cursor;
450
451 return AUB_ITEM_DECODE_OK;
452 }
453
454 static int
aub_file_more_stuff(struct aub_file * file)455 aub_file_more_stuff(struct aub_file *file)
456 {
457 return file->cursor < file->end || (file->stream && !feof(file->stream));
458 }
459
460 #define AUB_READ_BUFFER_SIZE (4096)
461 #define MAX(a, b) ((a) < (b) ? (b) : (a))
462
463 static void
aub_file_data_grow(struct aub_file * file)464 aub_file_data_grow(struct aub_file *file)
465 {
466 size_t old_size = (file->mem_end - file->map) * 4;
467 size_t new_size = MAX(old_size * 2, AUB_READ_BUFFER_SIZE);
468 uint32_t *new_start = realloc(file->map, new_size);
469
470 file->cursor = new_start + (file->cursor - file->map);
471 file->end = new_start + (file->end - file->map);
472 file->map = new_start;
473 file->mem_end = file->map + (new_size / 4);
474 }
475
476 static bool
aub_file_data_load(struct aub_file * file)477 aub_file_data_load(struct aub_file *file)
478 {
479 size_t r;
480
481 if (file->stream == NULL)
482 return false;
483
484 /* First remove any consumed data */
485 if (file->cursor > file->map) {
486 memmove(file->map, file->cursor,
487 (file->end - file->cursor) * 4);
488 file->end -= file->cursor - file->map;
489 file->cursor = file->map;
490 }
491
492 /* Then load some new data in */
493 if ((file->mem_end - file->end) < (AUB_READ_BUFFER_SIZE / 4))
494 aub_file_data_grow(file);
495
496 r = fread(file->end, 1, (file->mem_end - file->end) * 4, file->stream);
497 file->end += r / 4;
498
499 return r != 0;
500 }
501
502 static void
setup_pager(void)503 setup_pager(void)
504 {
505 int fds[2];
506 pid_t pid;
507
508 if (!isatty(1))
509 return;
510
511 if (pipe(fds) == -1)
512 return;
513
514 pid = fork();
515 if (pid == -1)
516 return;
517
518 if (pid == 0) {
519 close(fds[1]);
520 dup2(fds[0], 0);
521 execlp("less", "less", "-FRSi", NULL);
522 }
523
524 close(fds[0]);
525 dup2(fds[1], 1);
526 close(fds[1]);
527 }
528
529 static void
print_help(const char * progname,FILE * file)530 print_help(const char *progname, FILE *file)
531 {
532 fprintf(file,
533 "Usage: %s [OPTION]... [FILE]\n"
534 "Decode aub file contents from either FILE or the standard input.\n\n"
535 "A valid --gen option must be provided.\n\n"
536 " --help display this help and exit\n"
537 " --gen=platform decode for given platform (ivb, byt, hsw, bdw, chv, skl, kbl, bxt or cnl)\n"
538 " --headers decode only command headers\n"
539 " --color[=WHEN] colorize the output; WHEN can be 'auto' (default\n"
540 " if omitted), 'always', or 'never'\n"
541 " --no-pager don't launch pager\n"
542 " --no-offsets don't print instruction offsets\n"
543 " --xml=DIR load hardware xml description from directory DIR\n",
544 progname);
545 }
546
main(int argc,char * argv[])547 int main(int argc, char *argv[])
548 {
549 struct aub_file *file;
550 int c, i;
551 bool help = false, pager = true;
552 const struct {
553 const char *name;
554 int pci_id;
555 } gens[] = {
556 { "ilk", 0x0046 }, /* Intel(R) Ironlake Mobile */
557 { "snb", 0x0126 }, /* Intel(R) Sandybridge Mobile GT2 */
558 { "ivb", 0x0166 }, /* Intel(R) Ivybridge Mobile GT2 */
559 { "hsw", 0x0416 }, /* Intel(R) Haswell Mobile GT2 */
560 { "byt", 0x0155 }, /* Intel(R) Bay Trail */
561 { "bdw", 0x1616 }, /* Intel(R) HD Graphics 5500 (Broadwell GT2) */
562 { "chv", 0x22B3 }, /* Intel(R) HD Graphics (Cherryview) */
563 { "skl", 0x1912 }, /* Intel(R) HD Graphics 530 (Skylake GT2) */
564 { "kbl", 0x591D }, /* Intel(R) Kabylake GT2 */
565 { "bxt", 0x0A84 }, /* Intel(R) HD Graphics (Broxton) */
566 { "cnl", 0x5A52 }, /* Intel(R) HD Graphics (Cannonlake) */
567 };
568 const struct option aubinator_opts[] = {
569 { "help", no_argument, (int *) &help, true },
570 { "no-pager", no_argument, (int *) &pager, false },
571 { "no-offsets", no_argument, (int *) &option_print_offsets, false },
572 { "gen", required_argument, NULL, 'g' },
573 { "headers", no_argument, (int *) &option_full_decode, false },
574 { "color", required_argument, NULL, 'c' },
575 { "xml", required_argument, NULL, 'x' },
576 { NULL, 0, NULL, 0 }
577 };
578
579 outfile = stdout;
580
581 i = 0;
582 while ((c = getopt_long(argc, argv, "", aubinator_opts, &i)) != -1) {
583 switch (c) {
584 case 'g':
585 for (i = 0; i < ARRAY_SIZE(gens); i++) {
586 if (!strcmp(optarg, gens[i].name)) {
587 pci_id = gens[i].pci_id;
588 break;
589 }
590 }
591 if (i == ARRAY_SIZE(gens)) {
592 fprintf(stderr, "can't parse gen: '%s', expected ivb, byt, hsw, "
593 "bdw, chv, skl, kbl or bxt\n", optarg);
594 exit(EXIT_FAILURE);
595 }
596 break;
597 case 'c':
598 if (optarg == NULL || strcmp(optarg, "always") == 0)
599 option_color = COLOR_ALWAYS;
600 else if (strcmp(optarg, "never") == 0)
601 option_color = COLOR_NEVER;
602 else if (strcmp(optarg, "auto") == 0)
603 option_color = COLOR_AUTO;
604 else {
605 fprintf(stderr, "invalid value for --color: %s", optarg);
606 exit(EXIT_FAILURE);
607 }
608 break;
609 case 'x':
610 xml_path = strdup(optarg);
611 break;
612 default:
613 break;
614 }
615 }
616
617 if (help || argc == 1) {
618 print_help(argv[0], stderr);
619 exit(0);
620 }
621
622 if (optind < argc)
623 input_file = argv[optind];
624
625 /* Do this before we redirect stdout to pager. */
626 if (option_color == COLOR_AUTO)
627 option_color = isatty(1) ? COLOR_ALWAYS : COLOR_NEVER;
628
629 if (isatty(1) && pager)
630 setup_pager();
631
632 if (input_file == NULL)
633 file = aub_file_stdin();
634 else
635 file = aub_file_open(input_file);
636
637 /* mmap a terabyte for our gtt space. */
638 gtt_size = 1ull << 40;
639 gtt = mmap(NULL, gtt_size, PROT_READ | PROT_WRITE,
640 MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
641 if (gtt == MAP_FAILED) {
642 fprintf(stderr, "failed to alloc gtt space: %s\n", strerror(errno));
643 exit(EXIT_FAILURE);
644 }
645
646 while (aub_file_more_stuff(file)) {
647 switch (aub_file_decode_batch(file)) {
648 case AUB_ITEM_DECODE_OK:
649 break;
650 case AUB_ITEM_DECODE_NEED_MORE_DATA:
651 if (!file->stream) {
652 file->cursor = file->end;
653 break;
654 }
655 if (aub_file_more_stuff(file) && !aub_file_data_load(file)) {
656 fprintf(stderr, "failed to load data from stdin\n");
657 exit(EXIT_FAILURE);
658 }
659 break;
660 default:
661 fprintf(stderr, "failed to parse aubdump data\n");
662 exit(EXIT_FAILURE);
663 }
664 }
665
666
667 fflush(stdout);
668 /* close the stdout which is opened to write the output */
669 close(1);
670 free(xml_path);
671
672 wait(NULL);
673
674 return EXIT_SUCCESS;
675 }
676