X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fjournal%2Fcoredump.c;h=88d720f6517c8c82e4b73cecfbe4771f570bf95d;hp=afd69cda5d88f0e087fc6ed3e5223caac4fdca97;hb=b26c631ac99ac7f4f5cfa5b9b933f0bb22cace97;hpb=347272731e15d3c4a70fad7ccd7185e8e8059d01 diff --git a/src/journal/coredump.c b/src/journal/coredump.c index afd69cda5..88d720f65 100644 --- a/src/journal/coredump.c +++ b/src/journal/coredump.c @@ -26,8 +26,13 @@ #include #include -#include -#include +#ifdef HAVE_ELFUTILS +# include +# include +#endif + +#include "systemd/sd-journal.h" +#include "systemd/sd-login.h" #include "log.h" #include "util.h" @@ -42,18 +47,13 @@ #include "stacktrace.h" #include "path-util.h" #include "compress.h" +#include "coredump-vacuum.h" #ifdef HAVE_ACL # include # include "acl-util.h" #endif -#ifdef HAVE_XZ -# include -#else -# define LZMA_PRESET_DEFAULT 0 -#endif - /* The maximum size up to which we process coredumps */ #define PROCESS_SIZE_MAX ((off_t) (2LLU*1024LLU*1024LLU*1024LLU)) @@ -66,8 +66,8 @@ #define JOURNAL_SIZE_MAX ((size_t) (767LU*1024LU*1024LU)) /* Make sure to not make this larger than the maximum journal entry - * size. See ENTRY_SIZE_MAX in journald-native.c. */ -assert_cc(JOURNAL_SIZE_MAX <= ENTRY_SIZE_MAX); + * size. See DATA_SIZE_MAX in journald-native.c. */ +assert_cc(JOURNAL_SIZE_MAX <= DATA_SIZE_MAX); enum { INFO_PID, @@ -97,65 +97,32 @@ static const char* const coredump_storage_table[_COREDUMP_STORAGE_MAX] = { }; DEFINE_PRIVATE_STRING_TABLE_LOOKUP(coredump_storage, CoredumpStorage); -static DEFINE_CONFIG_PARSE_ENUM(config_parse_coredump_storage, coredump_storage, - CoredumpStorage, - "Failed to parse storage setting"); - -typedef enum CoredumpCompression { - COREDUMP_COMPRESSION_NONE, - COREDUMP_COMPRESSION_XZ, - _COREDUMP_COMPRESSION_MAX, - _COREDUMP_COMPRESSION_INVALID = -1 -} CoredumpCompression; - -static const char* const coredump_compression_table[_COREDUMP_COMPRESSION_MAX] = { - [COREDUMP_COMPRESSION_NONE] = "none", - [COREDUMP_COMPRESSION_XZ] = "xz", -}; - -DEFINE_PRIVATE_STRING_TABLE_LOOKUP(coredump_compression, CoredumpCompression); -static DEFINE_CONFIG_PARSE_ENUM(config_parse_coredump_compression, coredump_compression, - CoredumpCompression, - "Failed to parse compression setting"); +static DEFINE_CONFIG_PARSE_ENUM(config_parse_coredump_storage, coredump_storage, CoredumpStorage, "Failed to parse storage setting"); static CoredumpStorage arg_storage = COREDUMP_STORAGE_EXTERNAL; -static CoredumpCompression arg_compression = COREDUMP_COMPRESSION_XZ; -static unsigned arg_compression_level = LZMA_PRESET_DEFAULT; - +static bool arg_compress = true; static off_t arg_process_size_max = PROCESS_SIZE_MAX; static off_t arg_external_size_max = EXTERNAL_SIZE_MAX; static size_t arg_journal_size_max = JOURNAL_SIZE_MAX; +static off_t arg_keep_free = (off_t) -1; +static off_t arg_max_use = (off_t) -1; static int parse_config(void) { - static const ConfigTableItem items[] = { - { "Coredump", "Storage", config_parse_coredump_storage, 0, &arg_storage }, - { "Coredump", "Compression", config_parse_coredump_compression, 0, &arg_compression }, - { "Coredump", "CompressionLevel", config_parse_unsigned, 0, &arg_compression_level }, - - { "Coredump", "ProcessSizeMax", config_parse_iec_off, 0, &arg_process_size_max }, - { "Coredump", "ExternalSizeMax", config_parse_iec_off, 0, &arg_external_size_max }, - { "Coredump", "JournalSizeMax", config_parse_iec_size, 0, &arg_journal_size_max }, + { "Coredump", "Storage", config_parse_coredump_storage, 0, &arg_storage }, + { "Coredump", "Compress", config_parse_bool, 0, &arg_compress }, + { "Coredump", "ProcessSizeMax", config_parse_iec_off, 0, &arg_process_size_max }, + { "Coredump", "ExternalSizeMax", config_parse_iec_off, 0, &arg_external_size_max }, + { "Coredump", "JournalSizeMax", config_parse_iec_size, 0, &arg_journal_size_max }, + { "Coredump", "KeepFree", config_parse_iec_off, 0, &arg_keep_free }, + { "Coredump", "MaxUse", config_parse_iec_off, 0, &arg_max_use }, {} }; - return config_parse( - NULL, - "/etc/systemd/coredump.conf", - NULL, - "Coredump\0", - config_item_table_lookup, - (void*) items, - false, - false, - NULL); - -#ifdef HAVE_XZ - if (arg_compression_level > 9) { - log_warning("Invalid CompressionLevel %u, ignoring.", arg_compression_level); - arg_compression_level = LZMA_PRESET_DEFAULT; - } -#endif + return config_parse(NULL, "/etc/systemd/coredump.conf", NULL, + "Coredump\0", + config_item_table_lookup, items, + false, false, true, NULL); } static int fix_acl(int fd, uid_t uid) { @@ -165,6 +132,8 @@ static int fix_acl(int fd, uid_t uid) { acl_entry_t entry; acl_permset_t permset; + assert(fd >= 0); + if (uid <= SYSTEM_UID_MAX) return 0; @@ -215,6 +184,8 @@ static int fix_xattr(int fd, const char *info[_INFO_LEN]) { int r = 0; unsigned i; + assert(fd >= 0); + /* Attach some metadata to coredumps via extended * attributes. Just because we can. */ @@ -234,8 +205,17 @@ static int fix_xattr(int fd, const char *info[_INFO_LEN]) { #define filename_escape(s) xescape((s), "./ ") -static int fix_permissions(int fd, const char *filename, const char *target, - const char *info[_INFO_LEN], uid_t uid) { +static int fix_permissions( + int fd, + const char *filename, + const char *target, + const char *info[_INFO_LEN], + uid_t uid) { + + assert(fd >= 0); + assert(filename); + assert(target); + assert(info); /* Ignore errors on these */ fchmod(fd, 0640); @@ -257,7 +237,7 @@ static int fix_permissions(int fd, const char *filename, const char *target, static int maybe_remove_external_coredump(const char *filename, off_t size) { - /* Returns 1 if might remove, 0 if will not remove, <0 on error. */ + /* Returns 1 if might remove, 0 if will not remove, < 0 on error. */ if (IN_SET(arg_storage, COREDUMP_STORAGE_EXTERNAL, COREDUMP_STORAGE_BOTH) && size <= arg_external_size_max) @@ -266,7 +246,7 @@ static int maybe_remove_external_coredump(const char *filename, off_t size) { if (!filename) return 1; - if (unlink(filename) < 0) { + if (unlink(filename) < 0 && errno != ENOENT) { log_error("Failed to unlink %s: %m", filename); return -errno; } @@ -274,50 +254,67 @@ static int maybe_remove_external_coredump(const char *filename, off_t size) { return 1; } - -static int save_external_coredump(const char *info[_INFO_LEN], - uid_t uid, - char **ret_filename, - int *ret_fd, - off_t *ret_size) { - - _cleanup_free_ char *p = NULL, *t = NULL, *c = NULL, *fn = NULL, *tmp = NULL; - _cleanup_close_ int fd = -1; +static int make_filename(const char *info[_INFO_LEN], char **ret) { + _cleanup_free_ char *c = NULL, *u = NULL, *p = NULL, *t = NULL; sd_id128_t boot; - struct stat st; int r; assert(info); - assert(ret_filename); - assert(ret_fd); - assert(ret_size); c = filename_escape(info[INFO_COMM]); if (!c) - return log_oom(); + return -ENOMEM; + + u = filename_escape(info[INFO_UID]); + if (!u) + return -ENOMEM; + + r = sd_id128_get_boot(&boot); + if (r < 0) + return r; p = filename_escape(info[INFO_PID]); if (!p) - return log_oom(); + return -ENOMEM; t = filename_escape(info[INFO_TIMESTAMP]); if (!t) - return log_oom(); - - r = sd_id128_get_boot(&boot); - if (r < 0) { - log_error("Failed to determine boot ID: %s", strerror(-r)); - return r; - } + return -ENOMEM; - r = asprintf(&fn, - "/var/lib/systemd/coredump/core.%s." SD_ID128_FORMAT_STR ".%s.%s000000", + if (asprintf(ret, + "/var/lib/systemd/coredump/core.%s.%s." SD_ID128_FORMAT_STR ".%s.%s000000", c, + u, SD_ID128_FORMAT_VAL(boot), p, - t); - if (r < 0) - return log_oom(); + t) < 0) + return -ENOMEM; + + return 0; +} + +static int save_external_coredump( + const char *info[_INFO_LEN], + uid_t uid, + char **ret_filename, + int *ret_fd, + off_t *ret_size) { + + _cleanup_free_ char *fn = NULL, *tmp = NULL; + _cleanup_close_ int fd = -1; + struct stat st; + int r; + + assert(info); + assert(ret_filename); + assert(ret_fd); + assert(ret_size); + + r = make_filename(info, &fn); + if (r < 0) { + log_error("Failed to determine coredump file name: %s", strerror(-r)); + return r; + } tmp = tempfn_random(fn); if (!tmp) @@ -333,76 +330,80 @@ static int save_external_coredump(const char *info[_INFO_LEN], r = copy_bytes(STDIN_FILENO, fd, arg_process_size_max); if (r == -E2BIG) { - log_error("Coredump of %s (%s) is larger than configured processing limit, refusing.", - info[INFO_PID], info[INFO_COMM]); + log_error("Coredump of %s (%s) is larger than configured processing limit, refusing.", info[INFO_PID], info[INFO_COMM]); goto fail; } else if (IN_SET(r, -EDQUOT, -ENOSPC)) { - log_error("Not enough disk space for coredump of %s (%s), refusing.", - info[INFO_PID], info[INFO_COMM]); + log_error("Not enough disk space for coredump of %s (%s), refusing.", info[INFO_PID], info[INFO_COMM]); goto fail; } else if (r < 0) { log_error("Failed to dump coredump to file: %s", strerror(-r)); goto fail; } - if (lseek(fd, 0, SEEK_SET) == (off_t) -1) { - log_error("Failed to seek on %s: %m", tmp); - goto uncompressed; - } - if (fstat(fd, &st) < 0) { log_error("Failed to fstat coredump %s: %m", tmp); goto fail; } -#ifdef HAVE_XZ + if (lseek(fd, 0, SEEK_SET) == (off_t) -1) { + log_error("Failed to seek on %s: %m", tmp); + goto fail; + } + +#if defined(HAVE_XZ) || defined(HAVE_LZ4) /* If we will remove the coredump anyway, do not compress. */ if (maybe_remove_external_coredump(NULL, st.st_size) == 0 - && arg_compression == COREDUMP_COMPRESSION_XZ) { + && arg_compress) { - _cleanup_free_ char *fn2 = NULL; - char *tmp2; - _cleanup_close_ int fd2 = -1; + _cleanup_free_ char *fn_compressed = NULL, *tmp_compressed = NULL; + _cleanup_close_ int fd_compressed = -1; - tmp2 = strappenda(tmp, ".xz"); - fd2 = open(tmp2, O_CREAT|O_EXCL|O_RDWR|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0640); - if (fd2 < 0) { - log_error("Failed to create file %s: %m", tmp2); + fn_compressed = strappend(fn, COMPRESSED_EXT); + if (!fn_compressed) { + log_oom(); goto uncompressed; } - r = compress_stream(fd, fd2, arg_compression_level, -1); - if (r < 0) { - log_error("Failed to compress %s: %s", tmp2, strerror(-r)); - unlink_noerrno(tmp2); - goto fail2; + tmp_compressed = tempfn_random(fn_compressed); + if (!tmp_compressed) { + log_oom(); + goto uncompressed; } - fn2 = strappend(fn, ".xz"); - if (!fn2) { - log_oom(); - goto fail2; + fd_compressed = open(tmp_compressed, O_CREAT|O_EXCL|O_RDWR|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0640); + if (fd_compressed < 0) { + log_error("Failed to create file %s: %m", tmp_compressed); + goto uncompressed; + } + + r = compress_stream(fd, fd_compressed, -1); + if (r < 0) { + log_error("Failed to compress %s: %s", tmp_compressed, strerror(-r)); + goto fail_compressed; } - r = fix_permissions(fd2, tmp2, fn2, info, uid); + r = fix_permissions(fd_compressed, tmp_compressed, fn_compressed, info, uid); if (r < 0) - goto fail2; + goto fail_compressed; + + /* OK, this worked, we can get rid of the uncompressed version now */ + unlink_noerrno(tmp); - *ret_filename = fn2; /* compressed */ - *ret_fd = fd; /* uncompressed */ - *ret_size = st.st_size; /* uncompressed */ + *ret_filename = fn_compressed; /* compressed */ + *ret_fd = fd; /* uncompressed */ + *ret_size = st.st_size; /* uncompressed */ - fn2 = NULL; + fn_compressed = NULL; fd = -1; return 0; - fail2: - unlink_noerrno(tmp2); + fail_compressed: + unlink_noerrno(tmp_compressed); } -#endif uncompressed: +#endif r = fix_permissions(fd, tmp, fn, info, uid); if (r < 0) goto fail; @@ -465,13 +466,13 @@ int main(int argc, char* argv[]) { _cleanup_free_ char *core_pid = NULL, *core_uid = NULL, *core_gid = NULL, *core_signal = NULL, *core_timestamp = NULL, *core_comm = NULL, *core_exe = NULL, *core_unit = NULL, *core_session = NULL, *core_message = NULL, *core_cmdline = NULL, *coredump_data = NULL, - *coredump_filename = NULL, *core_slice = NULL, *core_cgroup = NULL, *core_owner_uid = NULL, - *exe = NULL, *comm = NULL; + *core_slice = NULL, *core_cgroup = NULL, *core_owner_uid = NULL, + *exe = NULL, *comm = NULL, *filename = NULL; const char *info[_INFO_LEN]; _cleanup_close_ int coredump_fd = -1; - struct iovec iovec[17]; + struct iovec iovec[18]; off_t coredump_size; int r, j = 0; uid_t uid, owner_uid; @@ -497,11 +498,9 @@ int main(int argc, char* argv[]) { /* Ignore all parse errors */ parse_config(); - log_debug("Selected storage '%s'.", - coredump_storage_to_string(arg_storage)); - log_debug("Selected compression %s:%u.", - coredump_compression_to_string(arg_storage), - arg_compression_level); + + log_debug("Selected storage '%s'.", coredump_storage_to_string(arg_storage)); + log_debug("Selected compression %s.", yes_no(arg_compress)); r = parse_uid(argv[INFO_UID + 1], &uid); if (r < 0) { @@ -548,15 +547,15 @@ int main(int argc, char* argv[]) { if (arg_storage != COREDUMP_STORAGE_NONE) arg_storage = COREDUMP_STORAGE_EXTERNAL; - r = save_external_coredump(info, uid, &coredump_filename, &coredump_fd, &coredump_size); + r = save_external_coredump(info, uid, &filename, &coredump_fd, &coredump_size); if (r < 0) goto finish; - r = maybe_remove_external_coredump(coredump_filename, coredump_size); + r = maybe_remove_external_coredump(filename, coredump_size); if (r < 0) goto finish; - log_info("Detected coredump of the journal daemon itself, diverted to %s.", coredump_filename); + log_info("Detected coredump of the journal daemon itself, diverted to %s.", filename); goto finish; } @@ -597,9 +596,9 @@ int main(int argc, char* argv[]) { } if (sd_pid_get_owner_uid(pid, &owner_uid) >= 0) { - asprintf(&core_owner_uid, "COREDUMP_OWNER_UID=" UID_FMT, owner_uid); - - if (core_owner_uid) + r = asprintf(&core_owner_uid, + "COREDUMP_OWNER_UID=" UID_FMT, owner_uid); + if (r > 0) IOVEC_SET_STRING(iovec[j++], core_owner_uid); } @@ -646,8 +645,11 @@ int main(int argc, char* argv[]) { IOVEC_SET_STRING(iovec[j++], "MESSAGE_ID=fc2e22bc6ee647b6b90729ab34a250b1"); IOVEC_SET_STRING(iovec[j++], "PRIORITY=2"); + /* Vacuum before we write anything again */ + coredump_vacuum(-1, arg_keep_free, arg_max_use); + /* Always stream the coredump to disk, if that's possible */ - r = save_external_coredump(info, uid, &coredump_filename, &coredump_fd, &coredump_size); + r = save_external_coredump(info, uid, &filename, &coredump_fd, &coredump_size); if (r < 0) /* skip whole core dumping part */ goto log; @@ -656,15 +658,24 @@ int main(int argc, char* argv[]) { * now, as later on we will lack the privileges for * it. However, we keep the fd to it, so that we can still * process it and log it. */ - r = maybe_remove_external_coredump(coredump_filename, coredump_size); + r = maybe_remove_external_coredump(filename, coredump_size); if (r < 0) goto finish; + if (r == 0) { + const char *coredump_filename; + + coredump_filename = strappenda("COREDUMP_FILENAME=", filename); + IOVEC_SET_STRING(iovec[j++], coredump_filename); + } + + /* Vacuum again, but exclude the coredump we just created */ + coredump_vacuum(coredump_fd, arg_keep_free, arg_max_use); /* Now, let's drop privileges to become the user who owns the * segfaulted process and allocate the coredump memory under - * his uid. This also ensures that the credentials journald - * will see are the ones of the coredumping user, thus making - * sure the user himself gets access to the core dump. */ + * the user's uid. This also ensures that the credentials + * journald will see are the ones of the coredumping user, + * thus making sure the user gets access to the core dump. */ if (setresgid(gid, gid, gid) < 0 || setresuid(uid, uid, uid) < 0) { log_error("Failed to drop privileges: %m"); @@ -680,6 +691,8 @@ int main(int argc, char* argv[]) { r = coredump_make_stack_trace(coredump_fd, exe, &stacktrace); if (r >= 0) core_message = strjoin("MESSAGE=Process ", info[INFO_PID], " (", comm, ") of user ", info[INFO_UID], " dumped core.\n\n", stacktrace, NULL); + else if (r == -EINVAL) + log_warning("Failed to generate stack trace: %s", dwfl_errmsg(dwfl_errno())); else log_warning("Failed to generate stack trace: %s", strerror(-r)); }