#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 "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 */
#define PROCESS_SIZE_MAX ((off_t) (2LLU*1024LLU*1024LLU*1024LLU))
#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,
};
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 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 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", "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 },
+ { "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) {
acl_entry_t entry;
acl_permset_t permset;
+ assert(fd >= 0);
+
if (uid <= SYSTEM_UID_MAX)
return 0;
int r = 0;
unsigned i;
+ assert(fd >= 0);
+
/* Attach some metadata to coredumps via extended
* attributes. Just because we can. */
#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);
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)
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;
+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();
-
- p = filename_escape(info[INFO_PID]);
- if (!p)
- return log_oom();
+ return -ENOMEM;
u = filename_escape(info[INFO_UID]);
if (!u)
- return log_oom();
-
- t = filename_escape(info[INFO_TIMESTAMP]);
- if (!t)
- return log_oom();
+ return -ENOMEM;
r = sd_id128_get_boot(&boot);
- if (r < 0) {
- log_error("Failed to determine boot ID: %s", strerror(-r));
+ if (r < 0)
return r;
- }
- r = asprintf(&fn,
+ p = filename_escape(info[INFO_PID]);
+ if (!p)
+ return -ENOMEM;
+
+ t = filename_escape(info[INFO_TIMESTAMP]);
+ if (!t)
+ return -ENOMEM;
+
+ 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)
}
r = copy_bytes(STDIN_FILENO, fd, arg_process_size_max);
- if (r == -E2BIG) {
+ if (r == -EFBIG) {
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)) {
if (lseek(fd, 0, SEEK_SET) == (off_t) -1) {
log_error("Failed to seek on %s: %m", tmp);
- goto uncompressed;
+ goto fail;
}
-#ifdef HAVE_XZ
+#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, LZMA_PRESET_DEFAULT, -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;
- *ret_filename = fn2; /* compressed */
- *ret_fd = fd; /* uncompressed */
- *ret_size = st.st_size; /* uncompressed */
+ /* OK, this worked, we can get rid of the uncompressed version now */
+ unlink_noerrno(tmp);
- fn2 = NULL;
+ *ret_filename = fn_compressed; /* compressed */
+ *ret_fd = fd; /* uncompressed */
+ *ret_size = st.st_size; /* uncompressed */
+
+ 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;
/* Ignore all parse errors */
parse_config();
- log_debug("Selected storage '%s'.",
- coredump_storage_to_string(arg_storage));
- log_debug("Selected compression %s.",
- coredump_compression_to_string(arg_compression));
+
+ 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) {
}
if (get_process_comm(pid, &comm) < 0) {
- log_warning("Failed to get COMM, falling back to the commandline.");
+ log_warning("Failed to get COMM, falling back to the command line.");
comm = strv_join(argv + INFO_COMM + 1, " ");
}
}
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);
}
/* 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");
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));
}