X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-crash%2Flttng-crash.c;h=06b3f8a25fa72a0c32f6c64df8cc7a4711ef44f7;hp=dda157be3cfe03c789f992dcf1bf2c10a11face4;hb=5f98d630e06cc5c89e8601b12be6d70fb7f8093d;hpb=d7ba13889c8692b14f99238ddf2721ed78df89d2 diff --git a/src/bin/lttng-crash/lttng-crash.c b/src/bin/lttng-crash/lttng-crash.c index dda157be3..06b3f8a25 100644 --- a/src/bin/lttng-crash/lttng-crash.c +++ b/src/bin/lttng-crash/lttng-crash.c @@ -34,6 +34,7 @@ #include #include #include +#include #include #include @@ -103,7 +104,7 @@ enum rb_modes { struct crash_abi_unknown { uint8_t magic[RB_CRASH_DUMP_ABI_MAGIC_LEN]; - uint64_t mmap_length; /* Overall lenght of crash record */ + uint64_t mmap_length; /* Overall length of crash record */ uint16_t endian; /* * { 0x12, 0x34 }: big endian * { 0x34, 0x12 }: little endian @@ -183,11 +184,10 @@ struct lttng_crash_layout { /* Variables */ static char *progname, - *opt_viewer_path = DEFAULT_VIEWER, - *opt_output_path; + *opt_viewer_path = NULL, + *opt_output_path = NULL; -static int nr_input_paths; -static char **input_paths; +static char *input_path; int lttng_opt_quiet, lttng_opt_verbose, lttng_opt_mi; @@ -210,7 +210,7 @@ static void usage(FILE *ofp) { fprintf(ofp, "LTTng Crash Trace Viewer " VERSION " - " VERSION_NAME "%s\n\n", GIT_VERSION[0] == '\0' ? "" : " - " GIT_VERSION); - fprintf(ofp, "usage: lttng [OPTIONS] FILE...\n"); + fprintf(ofp, "usage: lttng-crash [OPTIONS] FILE\n"); fprintf(ofp, "\n"); fprintf(ofp, "Options:\n"); fprintf(ofp, " -V, --version Show version.\n"); @@ -275,7 +275,7 @@ static int parse_args(int argc, char **argv) exit(EXIT_FAILURE); } - while ((opt = getopt_long(argc, argv, "+Vhvex:", long_options, NULL)) != -1) { + while ((opt = getopt_long(argc, argv, "+Vhve:x:", long_options, NULL)) != -1) { switch (opt) { case 'V': version(stdout); @@ -292,9 +292,11 @@ static int parse_args(int argc, char **argv) } break; case 'e': + free(opt_viewer_path); opt_viewer_path = strdup(optarg); break; case 'x': + free(opt_output_path); opt_output_path = strdup(optarg); break; case OPT_DUMP_OPTIONS: @@ -307,14 +309,17 @@ static int parse_args(int argc, char **argv) } } - /* No leftovers, print usage and quit */ - if ((argc - optind) == 0) { + if (!opt_viewer_path) { + opt_viewer_path = DEFAULT_VIEWER; + } + + /* No leftovers, or more than one input path, print usage and quit */ + if ((argc - optind) == 0 || (argc - optind) > 1) { usage(stderr); goto error; } - input_paths = &argv[optind]; - nr_input_paths = argc - optind; + input_path = argv[optind]; end: return ret; @@ -325,29 +330,33 @@ error: static int copy_file(const char *file_dest, const char *file_src) { - int fd_src, fd_dest; + int fd_src = -1, fd_dest = -1; ssize_t readlen, writelen; char buf[COPY_BUFLEN]; + int ret; DBG("Copy metadata file '%s' into '%s'", file_src, file_dest); fd_src = open(file_src, O_RDONLY); if (fd_src < 0) { PERROR("Error opening %s for reading", file_src); - return fd_src; + ret = -errno; + goto error; } fd_dest = open(file_dest, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); if (fd_dest < 0) { PERROR("Error opening %s for writing", file_dest); - return fd_dest; + ret = -errno; + goto error; } for (;;) { readlen = lttng_read(fd_src, buf, COPY_BUFLEN); if (readlen < 0) { PERROR("Error reading input file"); - return -1; + ret = -1; + goto error; } if (!readlen) { break; @@ -355,10 +364,25 @@ int copy_file(const char *file_dest, const char *file_src) writelen = lttng_write(fd_dest, buf, readlen); if (writelen < readlen) { PERROR("Error writing to output file"); - return -1; + ret = -1; + goto error; } } - return 0; + + ret = 0; +error: + if (fd_src >= 0) { + if (close(fd_src) < 0) { + PERROR("Error closing %s", file_src); + } + } + + if (fd_dest >= 0) { + if (close(fd_dest) < 0) { + PERROR("Error closing %s", file_dest); + } + } + return ret; } static @@ -644,7 +668,7 @@ int copy_crash_subbuf(const struct lttng_crash_layout *layout, return -EINVAL; } - DBG("Copy crash subbuffer at offset %lu", offset); + DBG("Copy crash subbuffer at offset %" PRIu64, offset); sbidx = subbuf_index(offset, buf_size, subbuf_size); /* @@ -768,7 +792,8 @@ int copy_crash_data(const struct lttng_crash_layout *layout, int fd_dest, readlen = lttng_read(fd_src, buf, src_file_len); if (readlen < 0) { PERROR("Error reading input file"); - return -1; + ret = -1; + goto end; } prod_offset = crash_get_field(layout, buf, prod_offset); @@ -947,60 +972,150 @@ int extract_one_trace(const char *output_path, } static -int extract_all_traces(const char *output_path, - char **input_paths, - int nr_input_paths) +int extract_trace_recursive(const char *output_path, + const char *input_path) { - int ret, i; + DIR *dir; + int dir_fd, ret = 0, closeret; + struct dirent *entry; int has_warning = 0; - /* Only one input path is currently supported */ - if (nr_input_paths != 1) { - ERR("Only a single input path is currently supported.\n"); + /* Open directory */ + dir = opendir(input_path); + if (!dir) { + PERROR("Cannot open '%s' path", input_path); + return -1; + } + dir_fd = dirfd(dir); + if (dir_fd < 0) { + PERROR("dirfd"); return -1; } - for (i = 0; i < nr_input_paths; i++) { - ret = extract_one_trace(output_path, - input_paths[i]); - if (ret) { - WARN("Error extracting trace '%s', continuing anyway.", - input_paths[i]); + while ((entry = readdir(dir))) { + if (!strcmp(entry->d_name, ".") + || !strcmp(entry->d_name, "..")) { + continue; + } + switch (entry->d_type) { + case DT_DIR: + { + char output_subpath[PATH_MAX]; + char input_subpath[PATH_MAX]; + + strncpy(output_subpath, output_path, + sizeof(output_subpath)); + output_subpath[sizeof(output_subpath) - 1] = '\0'; + strncat(output_subpath, "/", + sizeof(output_subpath) - strlen(output_subpath) - 1); + strncat(output_subpath, entry->d_name, + sizeof(output_subpath) - strlen(output_subpath) - 1); + + ret = mkdir(output_subpath, S_IRWXU | S_IRWXG); + if (ret) { + PERROR("mkdir"); + has_warning = 1; + goto end; + } + + strncpy(input_subpath, input_path, + sizeof(input_subpath)); + input_subpath[sizeof(input_subpath) - 1] = '\0'; + strncat(input_subpath, "/", + sizeof(input_subpath) - strlen(input_subpath) - 1); + strncat(input_subpath, entry->d_name, + sizeof(input_subpath) - strlen(input_subpath) - 1); + + ret = extract_trace_recursive(output_subpath, + input_subpath); + if (ret) { + has_warning = 1; + } + break; + } + case DT_REG: + case DT_LNK: + if (!strcmp(entry->d_name, "metadata")) { + ret = extract_one_trace(output_path, + input_path); + if (ret) { + WARN("Error extracting trace '%s', continuing anyway.", + input_path); + has_warning = 1; + } + } + /* Ignore other files */ + break; + default: has_warning = 1; + goto end; } } +end: + closeret = closedir(dir); + if (closeret) { + PERROR("closedir"); + } return has_warning; } static -int delete_trace(const char *trace_path) +int delete_dir_recursive(const char *path) { - DIR *trace_dir; - int trace_dir_fd, ret = 0, closeret; + DIR *dir; + int dir_fd, ret = 0, closeret; struct dirent *entry; /* Open trace directory */ - trace_dir = opendir(trace_path); - if (!trace_dir) { - PERROR("Cannot open '%s' path", trace_path); - return -1; + dir = opendir(path); + if (!dir) { + PERROR("Cannot open '%s' path", path); + ret = -errno; + goto end; } - trace_dir_fd = dirfd(trace_dir); - if (trace_dir_fd < 0) { + dir_fd = dirfd(dir); + if (dir_fd < 0) { PERROR("dirfd"); - return -1; + ret = -errno; + goto end; } - while ((entry = readdir(trace_dir))) { + while ((entry = readdir(dir))) { if (!strcmp(entry->d_name, ".") - || !strcmp(entry->d_name, "..")) + || !strcmp(entry->d_name, "..")) { continue; + } switch (entry->d_type) { case DT_DIR: - unlinkat(trace_dir_fd, entry->d_name, AT_REMOVEDIR); + { + char *subpath = zmalloc(PATH_MAX); + + if (!subpath) { + PERROR("zmalloc path"); + ret = -1; + goto end; + } + strncpy(subpath, path, PATH_MAX); + subpath[PATH_MAX - 1] = '\0'; + strncat(subpath, "/", + PATH_MAX - strlen(subpath) - 1); + strncat(subpath, entry->d_name, + PATH_MAX - strlen(subpath) - 1); + + ret = delete_dir_recursive(subpath); + free(subpath); + if (ret) { + /* Error occured, abort traversal. */ + goto end; + } break; + } case DT_REG: - unlinkat(trace_dir_fd, entry->d_name, 0); + ret = unlinkat(dir_fd, entry->d_name, 0); + if (ret) { + PERROR("Unlinking '%s'", entry->d_name); + goto end; + } break; default: ret = -EINVAL; @@ -1008,17 +1123,19 @@ int delete_trace(const char *trace_path) } } end: - closeret = closedir(trace_dir); + if (!ret) { + ret = rmdir(path); + if (ret) { + PERROR("rmdir '%s'", path); + } + } + closeret = closedir(dir); if (closeret) { PERROR("closedir"); } - if (!ret) { - ret = rmdir(trace_path); - } return ret; } - static int view_trace(const char *viewer_path, const char *trace_path) { @@ -1057,7 +1174,8 @@ int view_trace(const char *viewer_path, const char *trace_path) */ int main(int argc, char *argv[]) { - int ret, has_warning = 0; + int ret; + bool has_warning = false; const char *output_path = NULL; char tmppath[] = "/tmp/lttng-crash-XXXXXX"; @@ -1065,9 +1183,10 @@ int main(int argc, char *argv[]) ret = parse_args(argc, argv); if (ret > 0) { - exit(EXIT_SUCCESS); + goto end; } else if (ret < 0) { - exit(EXIT_FAILURE); + has_warning = true; + goto end; } if (opt_output_path) { @@ -1075,35 +1194,38 @@ int main(int argc, char *argv[]) ret = mkdir(output_path, S_IRWXU | S_IRWXG); if (ret) { PERROR("mkdir"); - exit(EXIT_FAILURE); + has_warning = true; + goto end; } } else { output_path = mkdtemp(tmppath); if (!output_path) { PERROR("mkdtemp"); - exit(EXIT_FAILURE); + has_warning = true; + goto end; } } - ret = extract_all_traces(output_path, input_paths, - nr_input_paths); + ret = extract_trace_recursive(output_path, input_path); if (ret < 0) { - exit(EXIT_FAILURE); + has_warning = true; + goto end; } else if (ret > 0) { - has_warning = 1; + /* extract_trace_recursive reported a warning. */ + has_warning = true; } if (!opt_output_path) { /* View trace */ ret = view_trace(opt_viewer_path, output_path); - if (ret) - has_warning = 1; - + if (ret) { + has_warning = true; + } /* unlink temporary trace */ - ret = delete_trace(output_path); - if (ret) - has_warning = 1; + ret = delete_dir_recursive(output_path); + if (ret) { + has_warning = true; + } } - if (has_warning) - exit(EXIT_FAILURE); - exit(EXIT_SUCCESS); +end: + exit(has_warning ? EXIT_FAILURE : EXIT_SUCCESS); }