chiark / gitweb /
journald: removed gendered pronouns in comment
[elogind.git] / src / journal / coredump.c
index 4d9ef1c7ee2a39e7b7a9f8df9798842c58d03940..88d720f6517c8c82e4b73cecfbe4771f570bf95d 100644 (file)
 #include <sys/types.h>
 #include <sys/xattr.h>
 
-#include <systemd/sd-journal.h>
-#include <systemd/sd-login.h>
+#ifdef HAVE_ELFUTILS
+#  include <dwarf.h>
+#  include <elfutils/libdwfl.h>
+#endif
+
+#include "systemd/sd-journal.h"
+#include "systemd/sd-login.h"
 
 #include "log.h"
 #include "util.h"
 #include "copy.h"
 #include "stacktrace.h"
 #include "path-util.h"
+#include "compress.h"
+#include "coredump-vacuum.h"
 
 #ifdef HAVE_ACL
-#include <sys/acl.h>
-#include "acl-util.h"
+#  include <sys/acl.h>
+#  include "acl-util.h"
 #endif
 
 /* The maximum size up to which we process coredumps */
@@ -59,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,
@@ -82,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",
@@ -97,26 +99,30 @@ 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 int parse_config(void) {
+static CoredumpStorage arg_storage = COREDUMP_STORAGE_EXTERNAL;
+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", "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", "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);
+        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) {
@@ -126,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;
 
@@ -176,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. */
 
@@ -195,49 +205,116 @@ static int fix_xattr(int fd, const char *info[_INFO_LEN]) {
 
 #define filename_escape(s) xescape((s), "./ ")
 
-static int save_external_coredump(const char *info[_INFO_LEN],
-                                  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) {
 
-        _cleanup_free_ char *p = NULL, *t = NULL, *c = NULL, *fn = NULL, *tmp = NULL;
-        _cleanup_close_ int fd = -1;
+        assert(fd >= 0);
+        assert(filename);
+        assert(target);
+        assert(info);
+
+        /* 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 && errno != ENOENT) {
+                log_error("Failed to unlink %s: %m", filename);
+                return -errno;
+        }
+
+        return 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)
@@ -247,47 +324,90 @@ static int save_external_coredump(const char *info[_INFO_LEN],
 
         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, 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;
         }
 
-        /* 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", tmp);
-                r = -errno;
-                goto fail;
-        }
-
         if (fstat(fd, &st) < 0) {
                 log_error("Failed to fstat coredump %s: %m", tmp);
-                r = -errno;
                 goto fail;
         }
 
-        if (rename(tmp, fn) < 0) {
-                log_error("Failed to rename coredump %s -> %s: %m", tmp, fn);
-                r = -errno;
+        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_compress) {
+
+                _cleanup_free_ char *fn_compressed = NULL, *tmp_compressed = NULL;
+                _cleanup_close_ int fd_compressed = -1;
+
+                fn_compressed = strappend(fn, COMPRESSED_EXT);
+                if (!fn_compressed) {
+                        log_oom();
+                        goto uncompressed;
+                }
+
+                tmp_compressed = tempfn_random(fn_compressed);
+                if (!tmp_compressed) {
+                        log_oom();
+                        goto uncompressed;
+                }
+
+                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(fd_compressed, tmp_compressed, fn_compressed, info, uid);
+                if (r < 0)
+                        goto fail_compressed;
+
+                /* OK, this worked, we can get rid of the uncompressed version now */
+                unlink_noerrno(tmp);
+
+                *ret_filename = fn_compressed;    /* compressed */
+                *ret_fd = fd;                     /* uncompressed */
+                *ret_size = st.st_size;           /* uncompressed */
+
+                fn_compressed = NULL;
+                fd = -1;
+
+                return 0;
+
+        fail_compressed:
+                unlink_noerrno(tmp_compressed);
+        }
+
+uncompressed:
+#endif
+        r = fix_permissions(fd, tmp, fn, info, uid);
+        if (r < 0)
+                goto fail;
+
         *ret_filename = fn;
         *ret_fd = fd;
         *ret_size = st.st_size;
@@ -317,7 +437,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;
         }
 
@@ -341,35 +461,18 @@ 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, *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;
@@ -395,14 +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));
 
-        /* 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;
-        }
+        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) {
@@ -449,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;
                 }
 
@@ -498,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);
         }
 
@@ -547,24 +645,37 @@ 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)
-                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
          * 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");
@@ -580,12 +691,15 @@ 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));
         }
 
         if (!core_message)
 #endif
+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);