2 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
3 * Copyright (C) 2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License, version 2 only,
7 * as published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include <sys/types.h>
39 #include <lttng/lttng.h>
40 #include <common/common.h>
42 #define DEFAULT_VIEWER "babeltrace"
44 #define COPY_BUFLEN 4096
45 #define RB_CRASH_DUMP_ABI_LEN 32
47 #define RB_CRASH_DUMP_ABI_MAGIC_LEN 16
50 * The 128-bit magic number is xor'd in the process data so it does not
51 * cause a false positive when searching for buffers by scanning memory.
52 * The actual magic number is:
53 * 0x17, 0x7B, 0xF1, 0x77, 0xBF, 0x17, 0x7B, 0xF1,
54 * 0x77, 0xBF, 0x17, 0x7B, 0xF1, 0x77, 0xBF, 0x17,
56 #define RB_CRASH_DUMP_ABI_MAGIC_XOR \
58 0x17 ^ 0xFF, 0x7B ^ 0xFF, 0xF1 ^ 0xFF, 0x77 ^ 0xFF, \
59 0xBF ^ 0xFF, 0x17 ^ 0xFF, 0x7B ^ 0xFF, 0xF1 ^ 0xFF, \
60 0x77 ^ 0xFF, 0xBF ^ 0xFF, 0x17 ^ 0xFF, 0x7B ^ 0xFF, \
61 0xF1 ^ 0xFF, 0x77 ^ 0xFF, 0xBF ^ 0xFF, 0x17 ^ 0xFF, \
65 * Non-static to ensure the compiler does not optimize away the xor.
67 uint8_t lttng_crash_expected_magic_xor
[] = RB_CRASH_DUMP_ABI_MAGIC_XOR
;
69 #define RB_CRASH_ENDIAN 0x1234
70 #define RB_CRASH_ENDIAN_REVERSE 0x3412
72 enum lttng_crash_type
{
73 LTTNG_CRASH_TYPE_UST
= 0,
74 LTTNG_CRASH_TYPE_KERNEL
= 1,
77 /* LTTng ring buffer defines (copied) */
79 #define HALF_ULONG_BITS(wl) (((wl) * CHAR_BIT) >> 1)
81 #define SB_ID_OFFSET_SHIFT(wl) (HALF_ULONG_BITS(wl) + 1)
82 #define SB_ID_OFFSET_COUNT(wl) (1UL << SB_ID_OFFSET_SHIFT(wl))
83 #define SB_ID_OFFSET_MASK(wl) (~(SB_ID_OFFSET_COUNT(wl) - 1))
85 * Lowest bit of top word half belongs to noref. Used only for overwrite mode.
87 #define SB_ID_NOREF_SHIFT(wl) (SB_ID_OFFSET_SHIFT(wl) - 1)
88 #define SB_ID_NOREF_COUNT(wl) (1UL << SB_ID_NOREF_SHIFT(wl))
89 #define SB_ID_NOREF_MASK(wl) SB_ID_NOREF_COUNT(wl)
91 * In overwrite mode: lowest half of word is used for index.
92 * Limit of 2^16 subbuffers per buffer on 32-bit, 2^32 on 64-bit.
93 * In producer-consumer mode: whole word used for index.
95 #define SB_ID_INDEX_SHIFT(wl) 0
96 #define SB_ID_INDEX_COUNT(wl) (1UL << SB_ID_INDEX_SHIFT(wl))
97 #define SB_ID_INDEX_MASK(wl) (SB_ID_NOREF_COUNT(wl) - 1)
100 RING_BUFFER_OVERWRITE
= 0, /* Overwrite when buffer full */
101 RING_BUFFER_DISCARD
= 1, /* Discard when buffer full */
104 struct crash_abi_unknown
{
105 uint8_t magic
[RB_CRASH_DUMP_ABI_MAGIC_LEN
];
106 uint64_t mmap_length
; /* Overall length of crash record */
108 * { 0x12, 0x34 }: big endian
109 * { 0x34, 0x12 }: little endian
111 uint16_t major
; /* Major number. */
112 uint16_t minor
; /* Minor number. */
113 uint8_t word_size
; /* Word size (bytes). */
114 uint8_t layout_type
; /* enum lttng_crash_layout */
115 } __attribute__((packed
));
117 struct crash_abi_0_0
{
118 struct crash_abi_unknown parent
;
121 uint32_t prod_offset
;
122 uint32_t consumed_offset
;
123 uint32_t commit_hot_array
;
124 uint32_t commit_hot_seq
;
125 uint32_t buf_wsb_array
;
128 uint32_t sb_array_shmp_offset
;
129 uint32_t sb_backend_p_offset
;
130 uint32_t content_size
;
131 uint32_t packet_size
;
132 } __attribute__((packed
)) offset
;
135 uint8_t consumed_offset
;
136 uint8_t commit_hot_seq
;
138 uint8_t sb_array_shmp_offset
;
139 uint8_t sb_backend_p_offset
;
140 uint8_t content_size
;
142 } __attribute__((packed
)) length
;
144 uint32_t commit_hot_array
;
145 uint32_t buf_wsb_array
;
147 } __attribute__((packed
)) stride
;
149 uint64_t buf_size
; /* Size of the buffer */
150 uint64_t subbuf_size
; /* Sub-buffer size */
151 uint64_t num_subbuf
; /* Number of sub-buffers for writer */
152 uint32_t mode
; /* Buffer mode: 0: overwrite, 1: discard */
153 } __attribute__((packed
));
155 struct lttng_crash_layout
{
157 int prod_offset
, consumed_offset
,
158 commit_hot_array
, commit_hot_seq
,
159 buf_wsb_array
, buf_wsb_id
,
160 sb_array
, sb_array_shmp_offset
,
161 sb_backend_p_offset
, content_size
,
165 int prod_offset
, consumed_offset
,
166 commit_hot_seq
, buf_wsb_id
,
167 sb_array_shmp_offset
, sb_backend_p_offset
,
168 content_size
, packet_size
;
171 int commit_hot_array
, buf_wsb_array
, sb_array
;
174 int reverse_byte_order
;
177 uint64_t mmap_length
; /* Length of crash record */
178 uint64_t buf_size
; /* Size of the buffer */
179 uint64_t subbuf_size
; /* Sub-buffer size */
180 uint64_t num_subbuf
; /* Number of sub-buffers for writer */
181 uint32_t mode
; /* Buffer mode: 0: overwrite, 1: discard */
185 static char *progname
,
186 *opt_viewer_path
= DEFAULT_VIEWER
,
189 static char *input_path
;
191 int lttng_opt_quiet
, lttng_opt_verbose
, lttng_opt_mi
;
197 /* Getopt options. No first level command. */
198 static struct option long_options
[] = {
199 { "version", 0, NULL
, 'V' },
200 { "help", 0, NULL
, 'h' },
201 { "verbose", 0, NULL
, 'v' },
202 { "viewer", 1, NULL
, 'e' },
203 { "extract", 1, NULL
, 'x' },
204 { "list-options", 0, NULL
, OPT_DUMP_OPTIONS
},
205 { NULL
, 0, NULL
, 0 },
208 static void usage(FILE *ofp
)
210 fprintf(ofp
, "LTTng Crash Trace Viewer " VERSION
" - " VERSION_NAME
"%s\n\n",
211 GIT_VERSION
[0] == '\0' ? "" : " - " GIT_VERSION
);
212 fprintf(ofp
, "usage: lttng-crash [OPTIONS] FILE\n");
214 fprintf(ofp
, "Options:\n");
215 fprintf(ofp
, " -V, --version Show version.\n");
216 fprintf(ofp
, " -h, --help Show this help.\n");
217 fprintf(ofp
, " --list-options Simple listing of lttng-crash options.\n");
218 fprintf(ofp
, " -v, --verbose Increase verbosity.\n");
219 fprintf(ofp
, " -e, --viewer Specify viewer and/or options to use. This will\n"
220 " completely override the default viewers so please\n"
221 " make sure to specify the full command. The trace\n"
222 " directory paths appended at the end to the\n"
224 fprintf(ofp
, " -x, --extract PATH Extract trace(s) to specified path. Don't view\n"
227 fprintf(ofp
, "Please see the lttng-crash(1) man page for full documentation.\n");
228 fprintf(ofp
, "See http://lttng.org for updates, bug reports and news.\n");
231 static void version(FILE *ofp
)
233 fprintf(ofp
, "%s (LTTng Crash Trace Viewer) " VERSION
" - " VERSION_NAME
236 GIT_VERSION
[0] == '\0' ? "" : " - " GIT_VERSION
);
242 * List options line by line. This is mostly for bash auto completion and to
243 * avoid difficult parsing.
245 static void list_options(FILE *ofp
)
248 struct option
*option
= NULL
;
250 option
= &long_options
[i
];
251 while (option
->name
!= NULL
) {
252 fprintf(ofp
, "--%s\n", option
->name
);
254 if (isprint(option
->val
)) {
255 fprintf(ofp
, "-%c\n", option
->val
);
259 option
= &long_options
[i
];
264 * Parse command line arguments.
266 * Return 0 if OK, else -1
268 static int parse_args(int argc
, char **argv
)
277 while ((opt
= getopt_long(argc
, argv
, "+Vhvex:", long_options
, NULL
)) != -1) {
288 /* There is only 3 possible level of verbosity. (-vvv) */
289 if (lttng_opt_verbose
< 3) {
290 lttng_opt_verbose
+= 1;
294 opt_viewer_path
= strdup(optarg
);
297 opt_output_path
= strdup(optarg
);
299 case OPT_DUMP_OPTIONS
:
300 list_options(stdout
);
309 /* No leftovers, or more than one input path, print usage and quit */
310 if ((argc
- optind
) == 0 || (argc
- optind
) > 1) {
315 input_path
= argv
[optind
];
324 int copy_file(const char *file_dest
, const char *file_src
)
326 int fd_src
= -1, fd_dest
= -1;
327 ssize_t readlen
, writelen
;
328 char buf
[COPY_BUFLEN
];
331 DBG("Copy metadata file '%s' into '%s'", file_src
, file_dest
);
333 fd_src
= open(file_src
, O_RDONLY
);
335 PERROR("Error opening %s for reading", file_src
);
339 fd_dest
= open(file_dest
, O_RDWR
| O_CREAT
| O_EXCL
,
340 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
);
342 PERROR("Error opening %s for writing", file_dest
);
348 readlen
= lttng_read(fd_src
, buf
, COPY_BUFLEN
);
350 PERROR("Error reading input file");
357 writelen
= lttng_write(fd_dest
, buf
, readlen
);
358 if (writelen
< readlen
) {
359 PERROR("Error writing to output file");
368 if (close(fd_src
) < 0) {
369 PERROR("Error closing %s", file_src
);
374 if (close(fd_dest
) < 0) {
375 PERROR("Error closing %s", file_dest
);
382 uint64_t _crash_get_field(const struct lttng_crash_layout
*layout
,
383 const char *ptr
, size_t size
)
386 case 1: return *(uint8_t *) ptr
;
387 case 2: if (layout
->reverse_byte_order
) {
388 return __bswap_16(*(uint16_t *) ptr
);
390 return *(uint16_t *) ptr
;
393 case 4: if (layout
->reverse_byte_order
) {
394 return __bswap_32(*(uint32_t *) ptr
);
396 return *(uint32_t *) ptr
;
399 case 8: if (layout
->reverse_byte_order
) {
400 return __bswap_64(*(uint64_t *) ptr
);
402 return *(uint64_t *) ptr
;
411 #define crash_get_field(layout, map, name) \
412 _crash_get_field(layout, (map) + (layout)->offset.name, \
415 #define crash_get_array_field(layout, map, array_name, idx, field_name) \
416 _crash_get_field(layout, \
417 (map) + (layout)->offset.array_name \
418 + (idx * (layout)->stride.array_name) \
419 + (layout)->offset.field_name, \
420 (layout)->length.field_name)
422 #define crash_get_hdr_raw_field(layout, hdr, name) ((hdr)->name)
424 #define crash_get_hdr_field(layout, hdr, name) \
425 _crash_get_field(layout, (const char *) &(hdr)->name, \
428 #define crash_get_layout(layout, hdr, name) \
430 (layout)->name = crash_get_hdr_field(layout, hdr, \
432 DBG("layout.%s = %" PRIu64, #name, \
433 (uint64_t) (layout)->name); \
437 int get_crash_layout_0_0(struct lttng_crash_layout
*layout
,
440 const struct crash_abi_0_0
*abi
= (const struct crash_abi_0_0
*) map
;
442 crash_get_layout(layout
, abi
, offset
.prod_offset
);
443 crash_get_layout(layout
, abi
, offset
.consumed_offset
);
444 crash_get_layout(layout
, abi
, offset
.commit_hot_array
);
445 crash_get_layout(layout
, abi
, offset
.commit_hot_seq
);
446 crash_get_layout(layout
, abi
, offset
.buf_wsb_array
);
447 crash_get_layout(layout
, abi
, offset
.buf_wsb_id
);
448 crash_get_layout(layout
, abi
, offset
.sb_array
);
449 crash_get_layout(layout
, abi
, offset
.sb_array_shmp_offset
);
450 crash_get_layout(layout
, abi
, offset
.sb_backend_p_offset
);
451 crash_get_layout(layout
, abi
, offset
.content_size
);
452 crash_get_layout(layout
, abi
, offset
.packet_size
);
454 crash_get_layout(layout
, abi
, length
.prod_offset
);
455 crash_get_layout(layout
, abi
, length
.consumed_offset
);
456 crash_get_layout(layout
, abi
, length
.commit_hot_seq
);
457 crash_get_layout(layout
, abi
, length
.buf_wsb_id
);
458 crash_get_layout(layout
, abi
, length
.sb_array_shmp_offset
);
459 crash_get_layout(layout
, abi
, length
.sb_backend_p_offset
);
460 crash_get_layout(layout
, abi
, length
.content_size
);
461 crash_get_layout(layout
, abi
, length
.packet_size
);
463 crash_get_layout(layout
, abi
, stride
.commit_hot_array
);
464 crash_get_layout(layout
, abi
, stride
.buf_wsb_array
);
465 crash_get_layout(layout
, abi
, stride
.sb_array
);
467 crash_get_layout(layout
, abi
, buf_size
);
468 crash_get_layout(layout
, abi
, subbuf_size
);
469 crash_get_layout(layout
, abi
, num_subbuf
);
470 crash_get_layout(layout
, abi
, mode
);
476 void print_dbg_magic(const uint8_t *magic
)
478 DBG("magic: 0x%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X",
479 magic
[0], magic
[1], magic
[2], magic
[3],
480 magic
[4], magic
[5], magic
[6], magic
[7],
481 magic
[8], magic
[9], magic
[10], magic
[11],
482 magic
[12], magic
[13], magic
[14], magic
[15]);
486 int check_magic(const uint8_t *magic
)
490 for (i
= 0; i
< RB_CRASH_DUMP_ABI_MAGIC_LEN
; i
++) {
491 if ((magic
[i
] ^ 0xFF) != lttng_crash_expected_magic_xor
[i
]) {
499 int get_crash_layout(struct lttng_crash_layout
*layout
, int fd
)
502 int ret
= 0, unmapret
;
503 const uint8_t *magic
;
504 uint64_t mmap_length
;
505 uint16_t major
, minor
;
507 const struct crash_abi_unknown
*abi
;
509 enum lttng_crash_type layout_type
;
511 map
= mmap(NULL
, RB_CRASH_DUMP_ABI_LEN
, PROT_READ
, MAP_PRIVATE
,
513 if (map
== MAP_FAILED
) {
514 PERROR("Mapping file");
517 abi
= (const struct crash_abi_unknown
*) map
;
518 magic
= crash_get_hdr_raw_field(layout
, abi
, magic
);
519 print_dbg_magic(magic
);
520 if (check_magic(magic
)) {
521 DBG("Unknown magic number");
522 ret
= 1; /* positive return value, skip */
525 endian
= crash_get_hdr_field(layout
, abi
, endian
);
527 case RB_CRASH_ENDIAN
:
529 case RB_CRASH_ENDIAN_REVERSE
:
530 layout
->reverse_byte_order
= 1;
533 DBG("Unknown endianness value: 0x%X", (unsigned int) endian
);
534 ret
= 1; /* positive return value, skip */
537 layout_type
= (enum lttng_crash_type
) crash_get_hdr_field(layout
, abi
, layout_type
);
538 switch (layout_type
) {
539 case LTTNG_CRASH_TYPE_UST
:
541 case LTTNG_CRASH_TYPE_KERNEL
:
542 ERR("lttng-modules buffer layout support not implemented");
543 ret
= 1; /* positive return value, skip */
546 ERR("Unknown layout type %u", (unsigned int) layout_type
);
547 ret
= 1; /* positive return value, skip */
550 mmap_length
= crash_get_hdr_field(layout
, abi
, mmap_length
);
551 DBG("mmap_length: %" PRIu64
, mmap_length
);
552 layout
->mmap_length
= mmap_length
;
553 major
= crash_get_hdr_field(layout
, abi
, major
);
554 DBG("major: %u", major
);
555 minor
= crash_get_hdr_field(layout
, abi
, minor
);
556 DBG("minor: %u", minor
);
557 word_size
= crash_get_hdr_field(layout
, abi
, word_size
);
558 DBG("word_size: %u", word_size
);
563 ret
= get_crash_layout_0_0(layout
, map
);
569 ERR("Unsupported crash ABI %u.%u\n", major
, minor
);
574 ERR("Unsupported crash ABI %u.%u\n", major
, minor
);
578 layout
->word_size
= word_size
;
580 unmapret
= munmap(map
, RB_CRASH_DUMP_ABI_LEN
);
587 /* buf_trunc mask selects only the buffer number. */
589 uint64_t buf_trunc(uint64_t offset
, uint64_t buf_size
)
591 return offset
& ~(buf_size
- 1);
594 /* subbuf_trunc mask selects the subbuffer number. */
596 uint64_t subbuf_trunc(uint64_t offset
, uint64_t subbuf_size
)
598 return offset
& ~(subbuf_size
- 1);
601 /* buf_offset mask selects only the offset within the current buffer. */
603 uint64_t buf_offset(uint64_t offset
, uint64_t buf_size
)
605 return offset
& (buf_size
- 1);
608 /* subbuf_offset mask selects the offset within the current subbuffer. */
610 uint64_t subbuf_offset(uint64_t offset
, uint64_t subbuf_size
)
612 return offset
& (subbuf_size
- 1);
615 /* subbuf_index returns the index of the current subbuffer within the buffer. */
617 uint64_t subbuf_index(uint64_t offset
, uint64_t buf_size
, uint64_t subbuf_size
)
619 return buf_offset(offset
, buf_size
) / subbuf_size
;
623 uint64_t subbuffer_id_get_index(uint32_t mode
, uint64_t id
,
626 if (mode
== RING_BUFFER_OVERWRITE
)
627 return id
& SB_ID_INDEX_MASK(wl
);
633 int copy_crash_subbuf(const struct lttng_crash_layout
*layout
,
634 int fd_dest
, char *buf
, uint64_t offset
)
636 uint64_t buf_size
, subbuf_size
, num_subbuf
, sbidx
, id
,
637 sb_bindex
, rpages_offset
, p_offset
, seq_cc
,
638 committed
, commit_count_mask
, consumed_cur
,
644 * Get the current subbuffer by applying the proper mask to
645 * "offset", and looking up the subbuf location within the
649 buf_size
= layout
->buf_size
;
650 subbuf_size
= layout
->subbuf_size
;
651 num_subbuf
= layout
->num_subbuf
;
653 switch (layout
->word_size
) {
654 case 4: commit_count_mask
= 0xFFFFFFFFULL
/ num_subbuf
;
656 case 8: commit_count_mask
= 0xFFFFFFFFFFFFFFFFULL
/ num_subbuf
;
659 ERR("Unsupported word size: %u",
660 (unsigned int) layout
->word_size
);
664 DBG("Copy crash subbuffer at offset %lu", offset
);
665 sbidx
= subbuf_index(offset
, buf_size
, subbuf_size
);
668 * Find where the seq cc is located. Compute length of data to
671 seq_cc
= crash_get_array_field(layout
, buf
, commit_hot_array
,
672 sbidx
, commit_hot_seq
);
673 consumed_cur
= crash_get_field(layout
, buf
, consumed_offset
);
676 * Check that the buffer we are getting is after or at
677 * consumed_cur position.
679 if ((long) subbuf_trunc(offset
, subbuf_size
)
680 - (long) subbuf_trunc(consumed_cur
, subbuf_size
) < 0) {
681 DBG("No data: position is before consumed_cur");
686 * Check if subbuffer has been fully committed.
688 if (((seq_cc
- subbuf_size
) & commit_count_mask
)
689 - (buf_trunc(offset
, buf_size
) / num_subbuf
)
691 committed
= subbuf_size
;
693 committed
= subbuf_offset(seq_cc
, subbuf_size
);
695 DBG("No data committed, seq_cc: %" PRIu64
, seq_cc
);
700 /* Find actual physical offset in subbuffer table */
701 id
= crash_get_array_field(layout
, buf
, buf_wsb_array
,
703 sb_bindex
= subbuffer_id_get_index(layout
->mode
, id
,
705 rpages_offset
= crash_get_array_field(layout
, buf
, sb_array
,
706 sb_bindex
, sb_array_shmp_offset
);
707 p_offset
= crash_get_field(layout
, buf
+ rpages_offset
,
708 sb_backend_p_offset
);
709 subbuf_ptr
= buf
+ p_offset
;
711 if (committed
== subbuf_size
) {
713 * Packet header can be used.
715 if (layout
->length
.packet_size
) {
717 subbuf_ptr
+ layout
->offset
.packet_size
,
718 layout
->length
.packet_size
);
719 if (layout
->reverse_byte_order
) {
720 packet_size
= __bswap_64(packet_size
);
722 packet_size
/= CHAR_BIT
;
724 packet_size
= subbuf_size
;
730 * Find where to patch the sub-buffer header with actual
731 * readable data len and packet len, derived from seq
732 * cc. Patch it in our in-memory copy.
734 patch_size
= committed
* CHAR_BIT
;
735 if (layout
->reverse_byte_order
) {
736 patch_size
= __bswap_64(patch_size
);
738 if (layout
->length
.content_size
) {
739 memcpy(subbuf_ptr
+ layout
->offset
.content_size
,
740 &patch_size
, layout
->length
.content_size
);
742 if (layout
->length
.packet_size
) {
743 memcpy(subbuf_ptr
+ layout
->offset
.packet_size
,
744 &patch_size
, layout
->length
.packet_size
);
746 packet_size
= committed
;
750 * Copy packet into fd_dest.
752 writelen
= lttng_write(fd_dest
, subbuf_ptr
, packet_size
);
753 if (writelen
< packet_size
) {
754 PERROR("Error writing to output file");
757 DBG("Copied %" PRIu64
" bytes of data", packet_size
);
765 int copy_crash_data(const struct lttng_crash_layout
*layout
, int fd_dest
,
769 int ret
= 0, has_data
= 0;
772 uint64_t prod_offset
, consumed_offset
;
773 uint64_t offset
, subbuf_size
;
776 ret
= fstat(fd_src
, &statbuf
);
780 src_file_len
= layout
->mmap_length
;
781 buf
= zmalloc(src_file_len
);
785 readlen
= lttng_read(fd_src
, buf
, src_file_len
);
787 PERROR("Error reading input file");
792 prod_offset
= crash_get_field(layout
, buf
, prod_offset
);
793 DBG("prod_offset: 0x%" PRIx64
, prod_offset
);
794 consumed_offset
= crash_get_field(layout
, buf
, consumed_offset
);
795 DBG("consumed_offset: 0x%" PRIx64
, consumed_offset
);
796 subbuf_size
= layout
->subbuf_size
;
798 for (offset
= consumed_offset
; offset
< prod_offset
;
799 offset
+= subbuf_size
) {
800 ret
= copy_crash_subbuf(layout
, fd_dest
, buf
, offset
);
810 if (ret
&& ret
!= -ENODATA
) {
821 int extract_file(int output_dir_fd
, const char *output_file
,
822 int input_dir_fd
, const char *input_file
)
824 int fd_dest
, fd_src
, ret
= 0, closeret
;
825 struct lttng_crash_layout layout
;
827 layout
.reverse_byte_order
= 0; /* For reading magic number */
829 DBG("Extract file '%s'", input_file
);
830 fd_src
= openat(input_dir_fd
, input_file
, O_RDONLY
);
832 PERROR("Error opening '%s' for reading",
838 /* Query the crash ABI layout */
839 ret
= get_crash_layout(&layout
, fd_src
);
844 fd_dest
= openat(output_dir_fd
, output_file
,
845 O_RDWR
| O_CREAT
| O_EXCL
,
846 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
);
848 PERROR("Error opening '%s' for writing",
854 ret
= copy_crash_data(&layout
, fd_dest
, fd_src
);
860 closeret
= close(fd_dest
);
864 if (ret
== -ENODATA
) {
865 closeret
= unlinkat(output_dir_fd
, output_file
, 0);
871 closeret
= close(fd_src
);
880 int extract_all_files(const char *output_path
,
881 const char *input_path
)
883 DIR *input_dir
, *output_dir
;
884 int input_dir_fd
, output_dir_fd
, ret
= 0, closeret
;
885 struct dirent
*entry
; /* input */
887 /* Open input directory */
888 input_dir
= opendir(input_path
);
890 PERROR("Cannot open '%s' path", input_path
);
893 input_dir_fd
= dirfd(input_dir
);
894 if (input_dir_fd
< 0) {
899 /* Open output directory */
900 output_dir
= opendir(output_path
);
902 PERROR("Cannot open '%s' path", output_path
);
905 output_dir_fd
= dirfd(output_dir
);
906 if (output_dir_fd
< 0) {
911 while ((entry
= readdir(input_dir
))) {
912 if (!strcmp(entry
->d_name
, ".")
913 || !strcmp(entry
->d_name
, ".."))
915 ret
= extract_file(output_dir_fd
, entry
->d_name
,
916 input_dir_fd
, entry
->d_name
);
917 if (ret
== -ENODATA
) {
918 DBG("No data in file '%s', skipping", entry
->d_name
);
921 } else if (ret
< 0) {
923 } else if (ret
> 0) {
924 DBG("Skipping file '%s'", entry
->d_name
);
929 closeret
= closedir(output_dir
);
933 closeret
= closedir(input_dir
);
941 int extract_one_trace(const char *output_path
,
942 const char *input_path
)
944 char dest
[PATH_MAX
], src
[PATH_MAX
];
947 DBG("Extract crash trace '%s' into '%s'", input_path
, output_path
);
950 strncpy(dest
, output_path
, PATH_MAX
);
951 dest
[PATH_MAX
- 1] = '\0';
952 strncat(dest
, "/metadata", PATH_MAX
- strlen(dest
) - 1);
954 strncpy(src
, input_path
, PATH_MAX
);
955 src
[PATH_MAX
- 1] = '\0';
956 strncat(src
, "/metadata", PATH_MAX
- strlen(dest
) - 1);
958 ret
= copy_file(dest
, src
);
963 /* Extract each other file that has expected header */
964 return extract_all_files(output_path
, input_path
);
968 int extract_trace_recursive(const char *output_path
,
969 const char *input_path
)
972 int dir_fd
, ret
= 0, closeret
;
973 struct dirent
*entry
;
977 dir
= opendir(input_path
);
979 PERROR("Cannot open '%s' path", input_path
);
988 while ((entry
= readdir(dir
))) {
989 if (!strcmp(entry
->d_name
, ".")
990 || !strcmp(entry
->d_name
, "..")) {
993 switch (entry
->d_type
) {
996 char output_subpath
[PATH_MAX
];
997 char input_subpath
[PATH_MAX
];
999 strncpy(output_subpath
, output_path
,
1000 sizeof(output_subpath
));
1001 output_subpath
[sizeof(output_subpath
) - 1] = '\0';
1002 strncat(output_subpath
, "/",
1003 sizeof(output_subpath
) - strlen(output_subpath
) - 1);
1004 strncat(output_subpath
, entry
->d_name
,
1005 sizeof(output_subpath
) - strlen(output_subpath
) - 1);
1007 ret
= mkdir(output_subpath
, S_IRWXU
| S_IRWXG
);
1014 strncpy(input_subpath
, input_path
,
1015 sizeof(input_subpath
));
1016 input_subpath
[sizeof(input_subpath
) - 1] = '\0';
1017 strncat(input_subpath
, "/",
1018 sizeof(input_subpath
) - strlen(input_subpath
) - 1);
1019 strncat(input_subpath
, entry
->d_name
,
1020 sizeof(input_subpath
) - strlen(input_subpath
) - 1);
1022 ret
= extract_trace_recursive(output_subpath
,
1030 if (!strcmp(entry
->d_name
, "metadata")) {
1031 ret
= extract_one_trace(output_path
,
1034 WARN("Error extracting trace '%s', continuing anyway.",
1039 /* Ignore other files */
1047 closeret
= closedir(dir
);
1055 int delete_trace(const char *trace_path
)
1058 int trace_dir_fd
, ret
= 0, closeret
;
1059 struct dirent
*entry
;
1061 /* Open trace directory */
1062 trace_dir
= opendir(trace_path
);
1064 PERROR("Cannot open '%s' path", trace_path
);
1067 trace_dir_fd
= dirfd(trace_dir
);
1068 if (trace_dir_fd
< 0) {
1073 while ((entry
= readdir(trace_dir
))) {
1074 if (!strcmp(entry
->d_name
, ".")
1075 || !strcmp(entry
->d_name
, "..")) {
1078 switch (entry
->d_type
) {
1080 unlinkat(trace_dir_fd
, entry
->d_name
, AT_REMOVEDIR
);
1083 unlinkat(trace_dir_fd
, entry
->d_name
, 0);
1091 closeret
= closedir(trace_dir
);
1096 ret
= rmdir(trace_path
);
1102 int view_trace(const char *viewer_path
, const char *trace_path
)
1111 } else if (pid
> 0) {
1115 pid
= waitpid(pid
, &status
, 0);
1116 if (pid
< 0 || !WIFEXITED(status
)) {
1123 ret
= execlp(viewer_path
, viewer_path
,
1124 trace_path
, (char *) NULL
);
1129 exit(EXIT_SUCCESS
); /* Never reached */
1137 int main(int argc
, char *argv
[])
1139 int ret
, has_warning
= 0;
1140 const char *output_path
= NULL
;
1141 char tmppath
[] = "/tmp/lttng-crash-XXXXXX";
1143 progname
= argv
[0] ? argv
[0] : "lttng-crash";
1145 ret
= parse_args(argc
, argv
);
1148 } else if (ret
< 0) {
1152 if (opt_output_path
) {
1153 output_path
= opt_output_path
;
1154 ret
= mkdir(output_path
, S_IRWXU
| S_IRWXG
);
1160 output_path
= mkdtemp(tmppath
);
1167 ret
= extract_trace_recursive(output_path
, input_path
);
1170 } else if (ret
> 0) {
1173 if (!opt_output_path
) {
1175 ret
= view_trace(opt_viewer_path
, output_path
);
1179 /* unlink temporary trace */
1180 ret
= delete_trace(output_path
);