X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fjournal%2Fcoredump.c;h=afd69cda5d88f0e087fc6ed3e5223caac4fdca97;hb=347272731e15d3c4a70fad7ccd7185e8e8059d01;hp=764c5e72ab3c9596231981c1e962eb51334d8719;hpb=6388c31525eff90aadddad448217fa92232890ca;p=elogind.git diff --git a/src/journal/coredump.c b/src/journal/coredump.c index 764c5e72a..afd69cda5 100644 --- a/src/journal/coredump.c +++ b/src/journal/coredump.c @@ -31,6 +31,7 @@ #include "log.h" #include "util.h" +#include "strv.h" #include "macro.h" #include "mkdir.h" #include "special.h" @@ -40,10 +41,17 @@ #include "copy.h" #include "stacktrace.h" #include "path-util.h" +#include "compress.h" #ifdef HAVE_ACL -#include -#include "acl-util.h" +# 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 */ @@ -62,13 +70,14 @@ assert_cc(JOURNAL_SIZE_MAX <= ENTRY_SIZE_MAX); enum { - ARG_PID = 1, - ARG_UID, - ARG_GID, - ARG_SIGNAL, - ARG_TIMESTAMP, - ARG_COMM, - _ARG_MAX + INFO_PID, + INFO_UID, + INFO_GID, + INFO_SIGNAL, + INFO_TIMESTAMP, + INFO_COMM, + INFO_EXE, + _INFO_LEN }; typedef enum CoredumpStorage { @@ -80,11 +89,6 @@ typedef enum CoredumpStorage { _COREDUMP_STORAGE_INVALID = -1 } CoredumpStorage; -static CoredumpStorage arg_storage = COREDUMP_STORAGE_EXTERNAL; -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 const char* const coredump_storage_table[_COREDUMP_STORAGE_MAX] = { [COREDUMP_STORAGE_NONE] = "none", [COREDUMP_STORAGE_EXTERNAL] = "external", @@ -93,15 +97,45 @@ 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"); +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 CoredumpStorage arg_storage = COREDUMP_STORAGE_EXTERNAL; +static CoredumpCompression arg_compression = COREDUMP_COMPRESSION_XZ; +static unsigned arg_compression_level = LZMA_PRESET_DEFAULT; + +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 int parse_config(void) { static const ConfigTableItem items[] = { - { "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", "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 }, {} }; @@ -115,6 +149,13 @@ static int parse_config(void) { 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 } static int fix_acl(int fd, uid_t uid) { @@ -159,28 +200,32 @@ static int fix_acl(int fd, uid_t uid) { return 0; } -static int fix_xattr(int fd, char *argv[]) { +static int fix_xattr(int fd, const char *info[_INFO_LEN]) { - static const char * const xattrs[_ARG_MAX] = { - [ARG_PID] = "user.coredump.pid", - [ARG_UID] = "user.coredump.uid", - [ARG_GID] = "user.coredump.gid", - [ARG_SIGNAL] = "user.coredump.signal", - [ARG_TIMESTAMP] = "user.coredump.timestamp", - [ARG_COMM] = "user.coredump.comm", + static const char * const xattrs[_INFO_LEN] = { + [INFO_PID] = "user.coredump.pid", + [INFO_UID] = "user.coredump.uid", + [INFO_GID] = "user.coredump.gid", + [INFO_SIGNAL] = "user.coredump.signal", + [INFO_TIMESTAMP] = "user.coredump.timestamp", + [INFO_COMM] = "user.coredump.comm", + [INFO_EXE] = "user.coredump.exe", }; int r = 0; unsigned i; - /* Attach some metadate to coredumps via extended + /* Attach some metadata to coredumps via extended * attributes. Just because we can. */ - for (i = 0; i < _ARG_MAX; i++) { - if (isempty(argv[i])) + for (i = 0; i < _INFO_LEN; i++) { + int k; + + if (isempty(info[i]) || !xattrs[i]) continue; - if (fsetxattr(fd, xattrs[i], argv[i], strlen(argv[i]), XATTR_CREATE) < 0) + k = fsetxattr(fd, xattrs[i], info[i], strlen(info[i]), XATTR_CREATE); + if (k < 0 && r == 0) r = -errno; } @@ -189,27 +234,73 @@ static int fix_xattr(int fd, char *argv[]) { #define filename_escape(s) xescape((s), "./ ") -static int save_external_coredump(char **argv, uid_t uid, char **ret_filename, int *ret_fd, off_t *ret_size) { +static int fix_permissions(int fd, const char *filename, const char *target, + const char *info[_INFO_LEN], uid_t uid) { + + /* Ignore errors on these */ + fchmod(fd, 0640); + fix_acl(fd, uid); + fix_xattr(fd, info); + + if (fsync(fd) < 0) { + log_error("Failed to sync coredump %s: %m", filename); + return -errno; + } + + if (rename(filename, target) < 0) { + log_error("Failed to rename coredump %s -> %s: %m", filename, target); + return -errno; + } + + return 0; +} + +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. */ + + if (IN_SET(arg_storage, COREDUMP_STORAGE_EXTERNAL, COREDUMP_STORAGE_BOTH) && + size <= arg_external_size_max) + return 0; + + if (!filename) + return 1; + + if (unlink(filename) < 0) { + log_error("Failed to unlink %s: %m", filename); + return -errno; + } + + 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; sd_id128_t boot; struct stat st; int r; - assert(argv); + assert(info); assert(ret_filename); assert(ret_fd); assert(ret_size); - c = filename_escape(argv[ARG_COMM]); + c = filename_escape(info[INFO_COMM]); if (!c) return log_oom(); - p = filename_escape(argv[ARG_PID]); + p = filename_escape(info[INFO_PID]); if (!p) return log_oom(); - t = filename_escape(argv[ARG_TIMESTAMP]); + t = filename_escape(info[INFO_TIMESTAMP]); if (!t) return log_oom(); @@ -236,38 +327,85 @@ static int save_external_coredump(char **argv, uid_t uid, char **ret_filename, i fd = open(tmp, O_CREAT|O_EXCL|O_RDWR|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0640); if (fd < 0) { - log_error("Failed to create coredump file: %m"); + log_error("Failed to create coredump file %s: %m", tmp); return -errno; } - r = copy_bytes(STDIN_FILENO, fd); - if (r < 0) { + 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]); + 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]); + goto fail; + } else if (r < 0) { log_error("Failed to dump coredump to file: %s", strerror(-r)); goto fail; } - /* Ignore errors on these */ - fchmod(fd, 0640); - fix_acl(fd, uid); - fix_xattr(fd, argv); - - if (fsync(fd) < 0) { - log_error("Failed to sync coredump: %m"); - r = -errno; - 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: %m"); - r = -errno; + log_error("Failed to fstat coredump %s: %m", tmp); goto fail; } - if (rename(tmp, fn) < 0) { - log_error("Failed to rename coredump: %m"); - r = -errno; - goto fail; +#ifdef HAVE_XZ + /* 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) { + + _cleanup_free_ char *fn2 = NULL; + char *tmp2; + _cleanup_close_ int fd2 = -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); + 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; + } + + fn2 = strappend(fn, ".xz"); + if (!fn2) { + log_oom(); + goto fail2; + } + + r = fix_permissions(fd2, tmp2, fn2, info, uid); + if (r < 0) + goto fail2; + + *ret_filename = fn2; /* compressed */ + *ret_fd = fd; /* uncompressed */ + *ret_size = st.st_size; /* uncompressed */ + + fn2 = NULL; + fd = -1; + + return 0; + + fail2: + unlink_noerrno(tmp2); } +#endif + +uncompressed: + r = fix_permissions(fd, tmp, fn, info, uid); + if (r < 0) + goto fail; *ret_filename = fn; *ret_fd = fd; @@ -298,7 +436,7 @@ static int allocate_journal_field(int fd, size_t size, char **ret, size_t *ret_s field = malloc(9 + size); if (!field) { - log_warning("Failed to allocate memory fore coredump, coredump will not be stored."); + log_warning("Failed to allocate memory for coredump, coredump will not be stored."); return -ENOMEM; } @@ -322,30 +460,14 @@ static int allocate_journal_field(int fd, size_t size, char **ret, size_t *ret_s return 0; } -static int maybe_remove_external_coredump(const char *filename, off_t size) { - - if (!filename) - return 0; - - if (IN_SET(arg_storage, COREDUMP_STORAGE_EXTERNAL, COREDUMP_STORAGE_BOTH) && - size <= arg_external_size_max) - return 0; - - if (unlink(filename) < 0) { - log_error("Failed to unlink %s: %m", filename); - return -errno; - } - - return 0; -} - 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; + *exe = NULL, *comm = NULL; + const char *info[_INFO_LEN]; _cleanup_close_ int coredump_fd = -1; @@ -366,41 +488,55 @@ int main(int argc, char* argv[]) { log_set_target(LOG_TARGET_KMSG); log_open(); - if (argc != _ARG_MAX) { - log_error("Invalid number of arguments passed from kernel."); + if (argc < INFO_COMM + 1) { + log_error("Not enough arguments passed from kernel (%d, expected %d).", + argc - 1, INFO_COMM + 1 - 1); r = -EINVAL; goto finish; } /* Ignore all parse errors */ parse_config(); - log_debug("Selected storage '%s'.", coredump_storage_to_string(arg_storage)); + 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); - /* Exit early if we cannot write the coredump to disk anyway */ - if (path_is_read_only_fs("/var/lib") != 0) { - log_error("Coredump directory not mounted or not writable, skipping coredump."); - r = -EROFS; - goto finish; - } - - r = parse_uid(argv[ARG_UID], &uid); + r = parse_uid(argv[INFO_UID + 1], &uid); if (r < 0) { log_error("Failed to parse UID."); goto finish; } - r = parse_pid(argv[ARG_PID], &pid); + r = parse_pid(argv[INFO_PID + 1], &pid); if (r < 0) { log_error("Failed to parse PID."); goto finish; } - r = parse_gid(argv[ARG_GID], &gid); + r = parse_gid(argv[INFO_GID + 1], &gid); if (r < 0) { log_error("Failed to parse GID."); goto finish; } + if (get_process_comm(pid, &comm) < 0) { + log_warning("Failed to get COMM, falling back to the commandline."); + comm = strv_join(argv + INFO_COMM + 1, " "); + } + + if (get_process_exe(pid, &exe) < 0) + log_warning("Failed to get EXE."); + + info[INFO_PID] = argv[INFO_PID + 1]; + info[INFO_UID] = argv[INFO_UID + 1]; + info[INFO_GID] = argv[INFO_GID + 1]; + info[INFO_SIGNAL] = argv[INFO_SIGNAL + 1]; + info[INFO_TIMESTAMP] = argv[INFO_TIMESTAMP + 1]; + info[INFO_COMM] = comm; + info[INFO_EXE] = exe; + if (cg_pid_get_unit(pid, &t) >= 0) { if (streq(t, SPECIAL_JOURNALD_SERVICE)) { @@ -412,7 +548,7 @@ int main(int argc, char* argv[]) { if (arg_storage != COREDUMP_STORAGE_NONE) arg_storage = COREDUMP_STORAGE_EXTERNAL; - r = save_external_coredump(argv, uid, &coredump_filename, &coredump_fd, &coredump_size); + r = save_external_coredump(info, uid, &coredump_filename, &coredump_fd, &coredump_size); if (r < 0) goto finish; @@ -436,26 +572,22 @@ int main(int argc, char* argv[]) { log_set_target(LOG_TARGET_JOURNAL_OR_KMSG); log_open(); - core_pid = strappend("COREDUMP_PID=", argv[ARG_PID]); + core_pid = strappend("COREDUMP_PID=", info[INFO_PID]); if (core_pid) IOVEC_SET_STRING(iovec[j++], core_pid); - core_uid = strappend("COREDUMP_UID=", argv[ARG_UID]); + core_uid = strappend("COREDUMP_UID=", info[INFO_UID]); if (core_uid) IOVEC_SET_STRING(iovec[j++], core_uid); - core_gid = strappend("COREDUMP_GID=", argv[ARG_GID]); + core_gid = strappend("COREDUMP_GID=", info[INFO_GID]); if (core_gid) IOVEC_SET_STRING(iovec[j++], core_gid); - core_signal = strappend("COREDUMP_SIGNAL=", argv[ARG_SIGNAL]); + core_signal = strappend("COREDUMP_SIGNAL=", info[INFO_SIGNAL]); if (core_signal) IOVEC_SET_STRING(iovec[j++], core_signal); - core_comm = strappend("COREDUMP_COMM=", argv[ARG_COMM]); - if (core_comm) - IOVEC_SET_STRING(iovec[j++], core_comm); - if (sd_pid_get_session(pid, &t) >= 0) { core_session = strappend("COREDUMP_SESSION=", t); free(t); @@ -479,7 +611,13 @@ int main(int argc, char* argv[]) { IOVEC_SET_STRING(iovec[j++], core_slice); } - if (get_process_exe(pid, &exe) >= 0) { + if (comm) { + core_comm = strappend("COREDUMP_COMM=", comm); + if (core_comm) + IOVEC_SET_STRING(iovec[j++], core_comm); + } + + if (exe) { core_exe = strappend("COREDUMP_EXE=", exe); if (core_exe) IOVEC_SET_STRING(iovec[j++], core_exe); @@ -501,7 +639,7 @@ int main(int argc, char* argv[]) { IOVEC_SET_STRING(iovec[j++], core_cgroup); } - core_timestamp = strjoin("COREDUMP_TIMESTAMP=", argv[ARG_TIMESTAMP], "000000", NULL); + core_timestamp = strjoin("COREDUMP_TIMESTAMP=", info[INFO_TIMESTAMP], "000000", NULL); if (core_timestamp) IOVEC_SET_STRING(iovec[j++], core_timestamp); @@ -509,9 +647,10 @@ int main(int argc, char* argv[]) { IOVEC_SET_STRING(iovec[j++], "PRIORITY=2"); /* Always stream the coredump to disk, if that's possible */ - r = save_external_coredump(argv, uid, &coredump_filename, &coredump_fd, &coredump_size); + r = save_external_coredump(info, uid, &coredump_filename, &coredump_fd, &coredump_size); if (r < 0) - goto finish; + /* skip whole core dumping part */ + goto log; /* If we don't want to keep the coredump on disk, remove it * now, as later on we will lack the privileges for @@ -540,14 +679,15 @@ int main(int argc, char* argv[]) { r = coredump_make_stack_trace(coredump_fd, exe, &stacktrace); if (r >= 0) - core_message = strjoin("MESSAGE=Process ", argv[ARG_PID], " (", argv[ARG_COMM], ") of user ", argv[ARG_UID], " dumped core.\n\n", stacktrace, NULL); + core_message = strjoin("MESSAGE=Process ", info[INFO_PID], " (", comm, ") of user ", info[INFO_UID], " dumped core.\n\n", stacktrace, NULL); else log_warning("Failed to generate stack trace: %s", strerror(-r)); } if (!core_message) #endif - core_message = strjoin("MESSAGE=Process ", argv[ARG_PID], " (", argv[ARG_COMM], ") of user ", argv[ARG_UID], " dumped core.", NULL); +log: + core_message = strjoin("MESSAGE=Process ", info[INFO_PID], " (", comm, ") of user ", info[INFO_UID], " dumped core.", NULL); if (core_message) IOVEC_SET_STRING(iovec[j++], core_message);