2 * Copyright (C) 2011 EfficiOS Inc.
3 * Copyright (C) 2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 * SPDX-License-Identifier: GPL-2.0-only
15 #include <sys/types.h>
23 #include <common/compat/endian.h>
28 #include <lttng/lttng.h>
29 #include <common/common.h>
30 #include <common/spawn-viewer.h>
31 #include <common/utils.h>
33 #define COPY_BUFLEN 4096
34 #define RB_CRASH_DUMP_ABI_LEN 32
36 #define RB_CRASH_DUMP_ABI_MAGIC_LEN 16
39 * The 128-bit magic number is xor'd in the process data so it does not
40 * cause a false positive when searching for buffers by scanning memory.
41 * The actual magic number is:
42 * 0x17, 0x7B, 0xF1, 0x77, 0xBF, 0x17, 0x7B, 0xF1,
43 * 0x77, 0xBF, 0x17, 0x7B, 0xF1, 0x77, 0xBF, 0x17,
45 #define RB_CRASH_DUMP_ABI_MAGIC_XOR \
47 0x17 ^ 0xFF, 0x7B ^ 0xFF, 0xF1 ^ 0xFF, 0x77 ^ 0xFF, \
48 0xBF ^ 0xFF, 0x17 ^ 0xFF, 0x7B ^ 0xFF, 0xF1 ^ 0xFF, \
49 0x77 ^ 0xFF, 0xBF ^ 0xFF, 0x17 ^ 0xFF, 0x7B ^ 0xFF, \
50 0xF1 ^ 0xFF, 0x77 ^ 0xFF, 0xBF ^ 0xFF, 0x17 ^ 0xFF, \
53 static const char *help_msg
=
54 #ifdef LTTNG_EMBED_HELP
55 #include <lttng-crash.1.h>
62 * Non-static to ensure the compiler does not optimize away the xor.
64 uint8_t lttng_crash_expected_magic_xor
[] = RB_CRASH_DUMP_ABI_MAGIC_XOR
;
66 #define RB_CRASH_ENDIAN 0x1234
67 #define RB_CRASH_ENDIAN_REVERSE 0x3412
69 enum lttng_crash_type
{
70 LTTNG_CRASH_TYPE_UST
= 0,
71 LTTNG_CRASH_TYPE_KERNEL
= 1,
74 /* LTTng ring buffer defines (copied) */
76 #define HALF_ULONG_BITS(wl) (((wl) * CHAR_BIT) >> 1)
78 #define SB_ID_OFFSET_SHIFT(wl) (HALF_ULONG_BITS(wl) + 1)
79 #define SB_ID_OFFSET_COUNT(wl) (1UL << SB_ID_OFFSET_SHIFT(wl))
80 #define SB_ID_OFFSET_MASK(wl) (~(SB_ID_OFFSET_COUNT(wl) - 1))
82 * Lowest bit of top word half belongs to noref. Used only for overwrite mode.
84 #define SB_ID_NOREF_SHIFT(wl) (SB_ID_OFFSET_SHIFT(wl) - 1)
85 #define SB_ID_NOREF_COUNT(wl) (1UL << SB_ID_NOREF_SHIFT(wl))
86 #define SB_ID_NOREF_MASK(wl) SB_ID_NOREF_COUNT(wl)
88 * In overwrite mode: lowest half of word is used for index.
89 * Limit of 2^16 subbuffers per buffer on 32-bit, 2^32 on 64-bit.
90 * In producer-consumer mode: whole word used for index.
92 #define SB_ID_INDEX_SHIFT(wl) 0
93 #define SB_ID_INDEX_COUNT(wl) (1UL << SB_ID_INDEX_SHIFT(wl))
94 #define SB_ID_INDEX_MASK(wl) (SB_ID_NOREF_COUNT(wl) - 1)
97 RING_BUFFER_OVERWRITE
= 0, /* Overwrite when buffer full */
98 RING_BUFFER_DISCARD
= 1, /* Discard when buffer full */
101 struct crash_abi_unknown
{
102 uint8_t magic
[RB_CRASH_DUMP_ABI_MAGIC_LEN
];
103 uint64_t mmap_length
; /* Overall length of crash record */
105 * { 0x12, 0x34 }: big endian
106 * { 0x34, 0x12 }: little endian
108 uint16_t major
; /* Major number. */
109 uint16_t minor
; /* Minor number. */
110 uint8_t word_size
; /* Word size (bytes). */
111 uint8_t layout_type
; /* enum lttng_crash_layout */
112 } __attribute__((packed
));
114 struct crash_abi_0_0
{
115 struct crash_abi_unknown parent
;
118 uint32_t prod_offset
;
119 uint32_t consumed_offset
;
120 uint32_t commit_hot_array
;
121 uint32_t commit_hot_seq
;
122 uint32_t buf_wsb_array
;
125 uint32_t sb_array_shmp_offset
;
126 uint32_t sb_backend_p_offset
;
127 uint32_t content_size
;
128 uint32_t packet_size
;
129 } __attribute__((packed
)) offset
;
132 uint8_t consumed_offset
;
133 uint8_t commit_hot_seq
;
135 uint8_t sb_array_shmp_offset
;
136 uint8_t sb_backend_p_offset
;
137 uint8_t content_size
;
139 } __attribute__((packed
)) length
;
141 uint32_t commit_hot_array
;
142 uint32_t buf_wsb_array
;
144 } __attribute__((packed
)) stride
;
146 uint64_t buf_size
; /* Size of the buffer */
147 uint64_t subbuf_size
; /* Sub-buffer size */
148 uint64_t num_subbuf
; /* Number of sub-buffers for writer */
149 uint32_t mode
; /* Buffer mode: 0: overwrite, 1: discard */
150 } __attribute__((packed
));
152 struct lttng_crash_layout
{
154 int prod_offset
, consumed_offset
,
155 commit_hot_array
, commit_hot_seq
,
156 buf_wsb_array
, buf_wsb_id
,
157 sb_array
, sb_array_shmp_offset
,
158 sb_backend_p_offset
, content_size
,
162 int prod_offset
, consumed_offset
,
163 commit_hot_seq
, buf_wsb_id
,
164 sb_array_shmp_offset
, sb_backend_p_offset
,
165 content_size
, packet_size
;
168 int commit_hot_array
, buf_wsb_array
, sb_array
;
171 int reverse_byte_order
;
174 uint64_t mmap_length
; /* Length of crash record */
175 uint64_t buf_size
; /* Size of the buffer */
176 uint64_t subbuf_size
; /* Sub-buffer size */
177 uint64_t num_subbuf
; /* Number of sub-buffers for writer */
178 uint32_t mode
; /* Buffer mode: 0: overwrite, 1: discard */
182 static const char *progname
;
183 static char *opt_viewer_path
= NULL
;
184 static char *opt_output_path
= NULL
;
186 static char *the_input_path
;
188 int lttng_opt_quiet
, lttng_opt_verbose
, lttng_opt_mi
;
194 /* Getopt options. No first level command. */
195 static struct option long_options
[] = {
196 { "version", 0, NULL
, 'V' },
197 { "help", 0, NULL
, 'h' },
198 { "verbose", 0, NULL
, 'v' },
199 { "viewer", 1, NULL
, 'e' },
200 { "extract", 1, NULL
, 'x' },
201 { "list-options", 0, NULL
, OPT_DUMP_OPTIONS
},
202 { NULL
, 0, NULL
, 0 },
205 static void usage(void)
207 int ret
= utils_show_help(1, "lttng-crash", help_msg
);
210 ERR("Cannot show --help for `lttng-crash`");
216 static void version(FILE *ofp
)
218 fprintf(ofp
, "%s (LTTng Crash Trace Viewer) " VERSION
" - " VERSION_NAME
221 GIT_VERSION
[0] == '\0' ? "" : " - " GIT_VERSION
,
222 EXTRA_VERSION_NAME
[0] == '\0' ? "" : " - " EXTRA_VERSION_NAME
);
228 * List options line by line. This is mostly for bash auto completion and to
229 * avoid difficult parsing.
231 static void list_options(FILE *ofp
)
234 struct option
*option
= NULL
;
236 option
= &long_options
[i
];
237 while (option
->name
!= NULL
) {
238 fprintf(ofp
, "--%s\n", option
->name
);
240 if (isprint(option
->val
)) {
241 fprintf(ofp
, "-%c\n", option
->val
);
245 option
= &long_options
[i
];
250 * Parse command line arguments.
252 * Return 0 if OK, else -1
254 static int parse_args(int argc
, char **argv
)
263 while ((opt
= getopt_long(argc
, argv
, "+Vhve:x:", long_options
, NULL
)) != -1) {
274 /* There is only 3 possible level of verbosity. (-vvv) */
275 if (lttng_opt_verbose
< 3) {
276 lttng_opt_verbose
+= 1;
280 free(opt_viewer_path
);
281 opt_viewer_path
= strdup(optarg
);
284 free(opt_output_path
);
285 opt_output_path
= strdup(optarg
);
287 case OPT_DUMP_OPTIONS
:
288 list_options(stdout
);
292 ERR("Unknown command-line option");
297 /* No leftovers, or more than one input path, print usage and quit */
298 if (argc
- optind
!= 1) {
299 ERR("Command-line error: Specify exactly one input path");
303 the_input_path
= argv
[optind
];
312 int copy_file(const char *file_dest
, const char *file_src
)
314 int fd_src
= -1, fd_dest
= -1;
315 ssize_t readlen
, writelen
;
316 char buf
[COPY_BUFLEN
];
319 DBG("Copy metadata file '%s' into '%s'", file_src
, file_dest
);
321 fd_src
= open(file_src
, O_RDONLY
);
323 PERROR("Error opening %s for reading", file_src
);
327 fd_dest
= open(file_dest
, O_RDWR
| O_CREAT
| O_EXCL
,
328 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
);
330 PERROR("Error opening %s for writing", file_dest
);
336 readlen
= lttng_read(fd_src
, buf
, COPY_BUFLEN
);
338 PERROR("Error reading input file");
345 writelen
= lttng_write(fd_dest
, buf
, readlen
);
346 if (writelen
< readlen
) {
347 PERROR("Error writing to output file");
356 if (close(fd_src
) < 0) {
357 PERROR("Error closing %s", file_src
);
362 if (close(fd_dest
) < 0) {
363 PERROR("Error closing %s", file_dest
);
370 uint64_t _crash_get_field(const struct lttng_crash_layout
*layout
,
371 const char *ptr
, size_t size
)
374 case 1: return *(uint8_t *) ptr
;
375 case 2: if (layout
->reverse_byte_order
) {
376 return bswap_16(*(uint16_t *) ptr
);
378 return *(uint16_t *) ptr
;
381 case 4: if (layout
->reverse_byte_order
) {
382 return bswap_32(*(uint32_t *) ptr
);
384 return *(uint32_t *) ptr
;
387 case 8: if (layout
->reverse_byte_order
) {
388 return bswap_64(*(uint64_t *) ptr
);
390 return *(uint64_t *) ptr
;
399 #define crash_get_field(layout, map, name) \
400 _crash_get_field(layout, (map) + (layout)->offset.name, \
403 #define crash_get_array_field(layout, map, array_name, idx, field_name) \
404 _crash_get_field(layout, \
405 (map) + (layout)->offset.array_name \
406 + (idx * (layout)->stride.array_name) \
407 + (layout)->offset.field_name, \
408 (layout)->length.field_name)
410 #define crash_get_hdr_raw_field(layout, hdr, name) ((hdr)->name)
412 #define crash_get_hdr_field(layout, hdr, name) \
413 _crash_get_field(layout, (const char *) &(hdr)->name, \
416 #define crash_get_layout(layout, hdr, name) \
418 (layout)->name = crash_get_hdr_field(layout, hdr, \
420 DBG("layout.%s = %" PRIu64, #name, \
421 (uint64_t) (layout)->name); \
425 int get_crash_layout_0_0(struct lttng_crash_layout
*layout
,
428 const struct crash_abi_0_0
*abi
= (const struct crash_abi_0_0
*) map
;
430 crash_get_layout(layout
, abi
, offset
.prod_offset
);
431 crash_get_layout(layout
, abi
, offset
.consumed_offset
);
432 crash_get_layout(layout
, abi
, offset
.commit_hot_array
);
433 crash_get_layout(layout
, abi
, offset
.commit_hot_seq
);
434 crash_get_layout(layout
, abi
, offset
.buf_wsb_array
);
435 crash_get_layout(layout
, abi
, offset
.buf_wsb_id
);
436 crash_get_layout(layout
, abi
, offset
.sb_array
);
437 crash_get_layout(layout
, abi
, offset
.sb_array_shmp_offset
);
438 crash_get_layout(layout
, abi
, offset
.sb_backend_p_offset
);
439 crash_get_layout(layout
, abi
, offset
.content_size
);
440 crash_get_layout(layout
, abi
, offset
.packet_size
);
442 crash_get_layout(layout
, abi
, length
.prod_offset
);
443 crash_get_layout(layout
, abi
, length
.consumed_offset
);
444 crash_get_layout(layout
, abi
, length
.commit_hot_seq
);
445 crash_get_layout(layout
, abi
, length
.buf_wsb_id
);
446 crash_get_layout(layout
, abi
, length
.sb_array_shmp_offset
);
447 crash_get_layout(layout
, abi
, length
.sb_backend_p_offset
);
448 crash_get_layout(layout
, abi
, length
.content_size
);
449 crash_get_layout(layout
, abi
, length
.packet_size
);
451 crash_get_layout(layout
, abi
, stride
.commit_hot_array
);
452 crash_get_layout(layout
, abi
, stride
.buf_wsb_array
);
453 crash_get_layout(layout
, abi
, stride
.sb_array
);
455 crash_get_layout(layout
, abi
, buf_size
);
456 crash_get_layout(layout
, abi
, subbuf_size
);
457 crash_get_layout(layout
, abi
, num_subbuf
);
458 crash_get_layout(layout
, abi
, mode
);
464 void print_dbg_magic(const uint8_t *magic
)
466 DBG("magic: 0x%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X%X",
467 magic
[0], magic
[1], magic
[2], magic
[3],
468 magic
[4], magic
[5], magic
[6], magic
[7],
469 magic
[8], magic
[9], magic
[10], magic
[11],
470 magic
[12], magic
[13], magic
[14], magic
[15]);
474 int check_magic(const uint8_t *magic
)
478 for (i
= 0; i
< RB_CRASH_DUMP_ABI_MAGIC_LEN
; i
++) {
479 if ((magic
[i
] ^ 0xFF) != lttng_crash_expected_magic_xor
[i
]) {
487 int get_crash_layout(struct lttng_crash_layout
*layout
, int fd
,
488 const char *input_file
)
491 int ret
= 0, unmapret
;
492 const uint8_t *magic
;
493 uint64_t mmap_length
;
494 uint16_t major
, minor
;
496 const struct crash_abi_unknown
*abi
;
498 enum lttng_crash_type layout_type
;
501 ret
= fstat(fd
, &stat
);
503 PERROR("Failed to fstat '%s'", input_file
);
506 if (stat
.st_size
< RB_CRASH_DUMP_ABI_LEN
) {
507 ERR("File '%s' truncated: file length of %" PRIi64
508 " bytes does not meet the minimal expected "
509 "length of %d bytes",
510 input_file
, (int64_t) stat
.st_size
,
511 RB_CRASH_DUMP_ABI_LEN
);
514 map
= (char *) mmap(NULL
, RB_CRASH_DUMP_ABI_LEN
, PROT_READ
, MAP_PRIVATE
,
516 if (map
== MAP_FAILED
) {
517 PERROR("Mapping file");
520 abi
= (const struct crash_abi_unknown
*) map
;
521 magic
= crash_get_hdr_raw_field(layout
, abi
, magic
);
522 print_dbg_magic(magic
);
523 if (check_magic(magic
)) {
524 DBG("Unknown magic number");
525 ret
= 1; /* positive return value, skip */
528 endian
= crash_get_hdr_field(layout
, abi
, endian
);
530 case RB_CRASH_ENDIAN
:
532 case RB_CRASH_ENDIAN_REVERSE
:
533 layout
->reverse_byte_order
= 1;
536 DBG("Unknown endianness value: 0x%X", (unsigned int) endian
);
537 ret
= 1; /* positive return value, skip */
540 layout_type
= (enum lttng_crash_type
) crash_get_hdr_field(layout
, abi
, layout_type
);
541 switch (layout_type
) {
542 case LTTNG_CRASH_TYPE_UST
:
544 case LTTNG_CRASH_TYPE_KERNEL
:
545 ERR("lttng-modules buffer layout support not implemented");
546 ret
= 1; /* positive return value, skip */
549 ERR("Unknown layout type %u", (unsigned int) layout_type
);
550 ret
= 1; /* positive return value, skip */
553 mmap_length
= crash_get_hdr_field(layout
, abi
, mmap_length
);
554 DBG("mmap_length: %" PRIu64
, mmap_length
);
555 layout
->mmap_length
= mmap_length
;
556 major
= crash_get_hdr_field(layout
, abi
, major
);
557 DBG("major: %u", major
);
558 minor
= crash_get_hdr_field(layout
, abi
, minor
);
559 DBG("minor: %u", minor
);
560 word_size
= crash_get_hdr_field(layout
, abi
, word_size
);
561 DBG("word_size: %u", word_size
);
566 ret
= get_crash_layout_0_0(layout
, map
);
572 ERR("Unsupported crash ABI %u.%u\n", major
, minor
);
577 ERR("Unsupported crash ABI %u.%u\n", major
, minor
);
581 layout
->word_size
= word_size
;
583 unmapret
= munmap(map
, RB_CRASH_DUMP_ABI_LEN
);
590 /* buf_trunc mask selects only the buffer number. */
592 uint64_t buf_trunc(uint64_t offset
, uint64_t buf_size
)
594 return offset
& ~(buf_size
- 1);
597 /* subbuf_trunc mask selects the subbuffer number. */
599 uint64_t subbuf_trunc(uint64_t offset
, uint64_t subbuf_size
)
601 return offset
& ~(subbuf_size
- 1);
604 /* buf_offset mask selects only the offset within the current buffer. */
606 uint64_t buf_offset(uint64_t offset
, uint64_t buf_size
)
608 return offset
& (buf_size
- 1);
611 /* subbuf_offset mask selects the offset within the current subbuffer. */
613 uint64_t subbuf_offset(uint64_t offset
, uint64_t subbuf_size
)
615 return offset
& (subbuf_size
- 1);
618 /* subbuf_index returns the index of the current subbuffer within the buffer. */
620 uint64_t subbuf_index(uint64_t offset
, uint64_t buf_size
, uint64_t subbuf_size
)
622 return buf_offset(offset
, buf_size
) / subbuf_size
;
626 uint64_t subbuffer_id_get_index(uint32_t mode
, uint64_t id
,
629 if (mode
== RING_BUFFER_OVERWRITE
)
630 return id
& SB_ID_INDEX_MASK(wl
);
636 int copy_crash_subbuf(const struct lttng_crash_layout
*layout
,
637 int fd_dest
, char *buf
, uint64_t offset
)
639 uint64_t buf_size
, subbuf_size
, num_subbuf
, sbidx
, id
,
640 sb_bindex
, rpages_offset
, p_offset
, seq_cc
,
641 committed
, commit_count_mask
, consumed_cur
,
647 * Get the current subbuffer by applying the proper mask to
648 * "offset", and looking up the subbuf location within the
652 buf_size
= layout
->buf_size
;
653 subbuf_size
= layout
->subbuf_size
;
654 num_subbuf
= layout
->num_subbuf
;
656 switch (layout
->word_size
) {
657 case 4: commit_count_mask
= 0xFFFFFFFFULL
/ num_subbuf
;
659 case 8: commit_count_mask
= 0xFFFFFFFFFFFFFFFFULL
/ num_subbuf
;
662 ERR("Unsupported word size: %u",
663 (unsigned int) layout
->word_size
);
667 DBG("Copy crash subbuffer at offset %" PRIu64
, offset
);
668 sbidx
= subbuf_index(offset
, buf_size
, subbuf_size
);
671 * Find where the seq cc is located. Compute length of data to
674 seq_cc
= crash_get_array_field(layout
, buf
, commit_hot_array
,
675 sbidx
, commit_hot_seq
);
676 consumed_cur
= crash_get_field(layout
, buf
, consumed_offset
);
679 * Check that the buffer we are getting is after or at
680 * consumed_cur position.
682 if ((long) subbuf_trunc(offset
, subbuf_size
)
683 - (long) subbuf_trunc(consumed_cur
, subbuf_size
) < 0) {
684 DBG("No data: position is before consumed_cur");
689 * Check if subbuffer has been fully committed.
691 if (((seq_cc
- subbuf_size
) & commit_count_mask
)
692 - (buf_trunc(offset
, buf_size
) / num_subbuf
)
694 committed
= subbuf_size
;
696 committed
= subbuf_offset(seq_cc
, subbuf_size
);
698 DBG("No data committed, seq_cc: %" PRIu64
, seq_cc
);
703 /* Find actual physical offset in subbuffer table */
704 id
= crash_get_array_field(layout
, buf
, buf_wsb_array
,
706 sb_bindex
= subbuffer_id_get_index(layout
->mode
, id
,
708 rpages_offset
= crash_get_array_field(layout
, buf
, sb_array
,
709 sb_bindex
, sb_array_shmp_offset
);
710 p_offset
= crash_get_field(layout
, buf
+ rpages_offset
,
711 sb_backend_p_offset
);
712 subbuf_ptr
= buf
+ p_offset
;
714 if (committed
== subbuf_size
) {
716 * Packet header can be used.
718 if (layout
->length
.packet_size
) {
720 subbuf_ptr
+ layout
->offset
.packet_size
,
721 layout
->length
.packet_size
);
722 if (layout
->reverse_byte_order
) {
723 packet_size
= bswap_64(packet_size
);
725 packet_size
/= CHAR_BIT
;
727 packet_size
= subbuf_size
;
733 * Find where to patch the sub-buffer header with actual
734 * readable data len and packet len, derived from seq
735 * cc. Patch it in our in-memory copy.
737 patch_size
= committed
* CHAR_BIT
;
738 if (layout
->reverse_byte_order
) {
739 patch_size
= bswap_64(patch_size
);
741 if (layout
->length
.content_size
) {
742 memcpy(subbuf_ptr
+ layout
->offset
.content_size
,
743 &patch_size
, layout
->length
.content_size
);
745 if (layout
->length
.packet_size
) {
746 memcpy(subbuf_ptr
+ layout
->offset
.packet_size
,
747 &patch_size
, layout
->length
.packet_size
);
749 packet_size
= committed
;
753 * Copy packet into fd_dest.
755 writelen
= lttng_write(fd_dest
, subbuf_ptr
, packet_size
);
756 if (writelen
< packet_size
) {
757 PERROR("Error writing to output file");
760 DBG("Copied %" PRIu64
" bytes of data", packet_size
);
768 int copy_crash_data(const struct lttng_crash_layout
*layout
, int fd_dest
,
772 int ret
= 0, has_data
= 0;
775 uint64_t prod_offset
, consumed_offset
;
776 uint64_t offset
, subbuf_size
;
779 ret
= fstat(fd_src
, &statbuf
);
783 src_file_len
= layout
->mmap_length
;
784 buf
= (char *) zmalloc(src_file_len
);
788 readlen
= lttng_read(fd_src
, buf
, src_file_len
);
790 PERROR("Error reading input file");
795 prod_offset
= crash_get_field(layout
, buf
, prod_offset
);
796 DBG("prod_offset: 0x%" PRIx64
, prod_offset
);
797 consumed_offset
= crash_get_field(layout
, buf
, consumed_offset
);
798 DBG("consumed_offset: 0x%" PRIx64
, consumed_offset
);
799 subbuf_size
= layout
->subbuf_size
;
801 for (offset
= consumed_offset
; offset
< prod_offset
;
802 offset
+= subbuf_size
) {
803 ret
= copy_crash_subbuf(layout
, fd_dest
, buf
, offset
);
813 if (ret
&& ret
!= -ENODATA
) {
824 int extract_file(int output_dir_fd
, const char *output_file
,
825 int input_dir_fd
, const char *input_file
)
827 int fd_dest
, fd_src
, ret
= 0, closeret
;
828 struct lttng_crash_layout layout
;
830 layout
.reverse_byte_order
= 0; /* For reading magic number */
832 DBG("Extract file '%s'", input_file
);
833 fd_src
= openat(input_dir_fd
, input_file
, O_RDONLY
);
835 PERROR("Error opening '%s' for reading",
841 /* Query the crash ABI layout */
842 ret
= get_crash_layout(&layout
, fd_src
, input_file
);
847 fd_dest
= openat(output_dir_fd
, output_file
,
848 O_RDWR
| O_CREAT
| O_EXCL
,
849 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
);
851 PERROR("Error opening '%s' for writing",
857 ret
= copy_crash_data(&layout
, fd_dest
, fd_src
);
863 closeret
= close(fd_dest
);
867 if (ret
== -ENODATA
) {
868 closeret
= unlinkat(output_dir_fd
, output_file
, 0);
874 closeret
= close(fd_src
);
883 int extract_all_files(const char *output_path
,
884 const char *input_path
)
886 DIR *input_dir
, *output_dir
;
887 int input_dir_fd
, output_dir_fd
, ret
= 0, closeret
;
888 struct dirent
*entry
; /* input */
890 /* Open input directory */
891 input_dir
= opendir(input_path
);
893 PERROR("Cannot open '%s' path", input_path
);
896 input_dir_fd
= dirfd(input_dir
);
897 if (input_dir_fd
< 0) {
902 /* Open output directory */
903 output_dir
= opendir(output_path
);
905 PERROR("Cannot open '%s' path", output_path
);
908 output_dir_fd
= dirfd(output_dir
);
909 if (output_dir_fd
< 0) {
914 while ((entry
= readdir(input_dir
))) {
915 if (!strcmp(entry
->d_name
, ".")
916 || !strcmp(entry
->d_name
, ".."))
918 ret
= extract_file(output_dir_fd
, entry
->d_name
,
919 input_dir_fd
, entry
->d_name
);
920 if (ret
== -ENODATA
) {
921 DBG("No data in file '%s', skipping", entry
->d_name
);
924 } else if (ret
< 0) {
926 } else if (ret
> 0) {
927 DBG("Skipping file '%s'", entry
->d_name
);
932 closeret
= closedir(output_dir
);
936 closeret
= closedir(input_dir
);
944 int extract_one_trace(const char *output_path
,
945 const char *input_path
)
947 char dest
[PATH_MAX
], src
[PATH_MAX
];
950 DBG("Extract crash trace '%s' into '%s'", input_path
, output_path
);
953 strncpy(dest
, output_path
, PATH_MAX
);
954 dest
[PATH_MAX
- 1] = '\0';
955 strncat(dest
, "/metadata", PATH_MAX
- strlen(dest
) - 1);
957 strncpy(src
, input_path
, PATH_MAX
);
958 src
[PATH_MAX
- 1] = '\0';
959 strncat(src
, "/metadata", PATH_MAX
- strlen(dest
) - 1);
961 ret
= copy_file(dest
, src
);
966 /* Extract each other file that has expected header */
967 return extract_all_files(output_path
, input_path
);
971 int extract_trace_recursive(const char *output_path
,
972 const char *input_path
)
975 int dir_fd
, ret
= 0, closeret
;
976 struct dirent
*entry
;
981 dir
= opendir(input_path
);
983 PERROR("Cannot open '%s' path", input_path
);
987 path_len
= strlen(input_path
);
995 while ((entry
= readdir(dir
))) {
998 char filename
[PATH_MAX
];
1000 if (!strcmp(entry
->d_name
, ".")
1001 || !strcmp(entry
->d_name
, "..")) {
1005 name_len
= strlen(entry
->d_name
);
1006 if (path_len
+ name_len
+ 2 > sizeof(filename
)) {
1007 ERR("Failed to remove file: path name too long (%s/%s)",
1008 input_path
, entry
->d_name
);
1012 if (snprintf(filename
, sizeof(filename
), "%s/%s",
1013 input_path
, entry
->d_name
) < 0) {
1014 ERR("Failed to format path.");
1018 if (stat(filename
, &st
)) {
1023 if (S_ISDIR(st
.st_mode
)) {
1024 char output_subpath
[PATH_MAX
];
1025 char input_subpath
[PATH_MAX
];
1027 strncpy(output_subpath
, output_path
,
1028 sizeof(output_subpath
));
1029 output_subpath
[sizeof(output_subpath
) - 1] = '\0';
1030 strncat(output_subpath
, "/",
1031 sizeof(output_subpath
) - strlen(output_subpath
) - 1);
1032 strncat(output_subpath
, entry
->d_name
,
1033 sizeof(output_subpath
) - strlen(output_subpath
) - 1);
1035 ret
= mkdir(output_subpath
, S_IRWXU
| S_IRWXG
);
1042 strncpy(input_subpath
, input_path
,
1043 sizeof(input_subpath
));
1044 input_subpath
[sizeof(input_subpath
) - 1] = '\0';
1045 strncat(input_subpath
, "/",
1046 sizeof(input_subpath
) - strlen(input_subpath
) - 1);
1047 strncat(input_subpath
, entry
->d_name
,
1048 sizeof(input_subpath
) - strlen(input_subpath
) - 1);
1050 ret
= extract_trace_recursive(output_subpath
,
1055 } else if (S_ISREG(st
.st_mode
) || S_ISLNK(st
.st_mode
)) {
1056 if (!strcmp(entry
->d_name
, "metadata")) {
1057 ret
= extract_one_trace(output_path
,
1060 WARN("Error extracting trace '%s', continuing anyway.",
1071 closeret
= closedir(dir
);
1079 int delete_dir_recursive(const char *path
)
1082 int dir_fd
, ret
= 0, closeret
;
1084 struct dirent
*entry
;
1086 /* Open trace directory */
1087 dir
= opendir(path
);
1089 PERROR("Cannot open '%s' path", path
);
1091 goto end_no_closedir
;
1094 path_len
= strlen(path
);
1096 dir_fd
= dirfd(dir
);
1103 while ((entry
= readdir(dir
))) {
1106 char filename
[PATH_MAX
];
1108 if (!strcmp(entry
->d_name
, ".")
1109 || !strcmp(entry
->d_name
, "..")) {
1113 name_len
= strlen(entry
->d_name
);
1114 if (path_len
+ name_len
+ 2 > sizeof(filename
)) {
1115 ERR("Failed to remove file: path name too long (%s/%s)",
1116 path
, entry
->d_name
);
1120 if (snprintf(filename
, sizeof(filename
), "%s/%s",
1121 path
, entry
->d_name
) < 0) {
1122 ERR("Failed to format path.");
1126 if (stat(filename
, &st
)) {
1131 if (S_ISDIR(st
.st_mode
)) {
1132 char *subpath
= (char *) zmalloc(PATH_MAX
);
1135 PERROR("zmalloc path");
1139 strncpy(subpath
, path
, PATH_MAX
);
1140 subpath
[PATH_MAX
- 1] = '\0';
1141 strncat(subpath
, "/",
1142 PATH_MAX
- strlen(subpath
) - 1);
1143 strncat(subpath
, entry
->d_name
,
1144 PATH_MAX
- strlen(subpath
) - 1);
1146 ret
= delete_dir_recursive(subpath
);
1149 /* Error occurred, abort traversal. */
1152 } else if (S_ISREG(st
.st_mode
)) {
1153 ret
= unlinkat(dir_fd
, entry
->d_name
, 0);
1155 PERROR("Unlinking '%s'", entry
->d_name
);
1167 PERROR("rmdir '%s'", path
);
1170 closeret
= closedir(dir
);
1179 int view_trace(const char *trace_path
, char *viewer_path
)
1188 } else if (pid
> 0) {
1192 pid
= waitpid(pid
, &status
, 0);
1193 if (pid
< 0 || !WIFEXITED(status
)) {
1200 ret
= spawn_viewer(trace_path
, viewer_path
, false);
1213 int main(int argc
, char *argv
[])
1216 bool has_warning
= false;
1217 const char *output_path
= NULL
;
1218 char tmppath
[] = "/tmp/lttng-crash-XXXXXX";
1220 progname
= argv
[0] ? argv
[0] : "lttng-crash";
1222 ret
= parse_args(argc
, argv
);
1225 } else if (ret
< 0) {
1230 if (opt_output_path
) {
1231 output_path
= opt_output_path
;
1232 ret
= mkdir(output_path
, S_IRWXU
| S_IRWXG
);
1239 output_path
= mkdtemp(tmppath
);
1247 ret
= extract_trace_recursive(output_path
, the_input_path
);
1251 } else if (ret
> 0) {
1252 /* extract_trace_recursive reported a warning. */
1255 if (!opt_output_path
) {
1257 ret
= view_trace(output_path
, opt_viewer_path
);
1261 /* unlink temporary trace */
1262 ret
= delete_dir_recursive(output_path
);
1268 exit(has_warning
? EXIT_FAILURE
: EXIT_SUCCESS
);