#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
+
+#ifdef HAVE_XZ
+# include <lzma.h>
+#else
+# define LZMA_PRESET_DEFAULT 0
#endif
/* The maximum size up to which we process coredumps */
_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",
};
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 off_t arg_keep_free = (off_t) -1;
+static off_t arg_max_use = (off_t) -1;
static int parse_config(void) {
+ int r;
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 },
+ { "Coredump", "KeepFree", config_parse_iec_off, 0, &arg_keep_free },
+ { "Coredump", "MaxUse", config_parse_iec_off, 0, &arg_max_use },
{}
};
- return config_parse(
+ r = config_parse(
NULL,
"/etc/systemd/coredump.conf",
NULL,
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 r;
}
static int fix_acl(int fd, uid_t uid) {
#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;
+ /* 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 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, *u = NULL;
_cleanup_close_ int fd = -1;
sd_id128_t boot;
struct stat st;
if (!p)
return log_oom();
+ u = filename_escape(info[INFO_UID]);
+ if (!u)
+ return log_oom();
+
t = filename_escape(info[INFO_TIMESTAMP]);
if (!t)
return log_oom();
}
r = asprintf(&fn,
- "/var/lib/systemd/coredump/core.%s." SD_ID128_FORMAT_STR ".%s.%s000000",
+ "/var/lib/systemd/coredump/core.%s.%s." SD_ID128_FORMAT_STR ".%s.%s000000",
c,
+ u,
SD_ID128_FORMAT_VAL(boot),
p,
t);
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;
- goto fail;
+ if (lseek(fd, 0, SEEK_SET) == (off_t) -1) {
+ log_error("Failed to seek on %s: %m", tmp);
+ goto uncompressed;
}
+#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;
*ret_size = st.st_size;
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;
}
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;
/* 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_compression),
+ arg_compression_level);
r = parse_uid(argv[INFO_UID + 1], &uid);
if (r < 0) {
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;
}
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;
* 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