summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorLennart Poettering <lennart@poettering.net>2014-06-18 22:02:18 +0200
committerLennart Poettering <lennart@poettering.net>2014-06-19 00:00:24 +0200
commit34c10968cbe3b5591b3c0ce225b8694edd9709d0 (patch)
tree3f708515fbe0eff8c66f9a140c5be027ac00f664 /src
parent3bdace9bf779ce051f00c14914b35c3a26164aa9 (diff)
coredump: optionally store coredumps on disk, not in the journal
Introduce a new configuration file /etc/systemd/coredump.conf to configure when to place coredumps in the journal and when on disk. Since the coredumps are quite large, default to storing them only on disk.
Diffstat (limited to 'src')
-rw-r--r--src/journal/coredump.c443
-rw-r--r--src/journal/coredump.conf14
-rw-r--r--src/journal/journald-server.c2
-rw-r--r--src/shared/acl-util.h8
-rw-r--r--src/shared/sleep-config.c4
-rw-r--r--src/sleep/sleep.c1
6 files changed, 374 insertions, 98 deletions
diff --git a/src/journal/coredump.c b/src/journal/coredump.c
index 74b1dbd013..a396491a4b 100644
--- a/src/journal/coredump.c
+++ b/src/journal/coredump.c
@@ -23,12 +23,11 @@
#include <unistd.h>
#include <stdio.h>
#include <sys/prctl.h>
+#include <sys/types.h>
+#include <attr/xattr.h>
#include <systemd/sd-journal.h>
-
-#ifdef HAVE_LOGIND
#include <systemd/sd-login.h>
-#endif
#include "log.h"
#include "util.h"
@@ -37,13 +36,28 @@
#include "special.h"
#include "cgroup-util.h"
#include "journald-native.h"
+#include "conf-parser.h"
+#include "copy.h"
+
+#ifdef HAVE_ACL
+#include <sys/acl.h>
+#include "acl-util.h"
+#endif
+
+/* The maximum size up to which we process coredumps */
+#define PROCESS_SIZE_MAX ((off_t) (2LLU*1024LLU*1024LLU*1024LLU))
+
+/* The maximum size up to which we leave the coredump around on
+ * disk */
+#define EXTERNAL_SIZE_MAX PROCESS_SIZE_MAX
+
+/* The maximum size up to which we store the coredump in the
+ * journal */
+#define JOURNAL_SIZE_MAX ((size_t) (767LU*1024LU*1024LU))
-/* Few programs have less than 3MiB resident */
-#define COREDUMP_MIN_START (3*1024*1024u)
/* Make sure to not make this larger than the maximum journal entry
* size. See ENTRY_SIZE_MAX in journald-native.c. */
-#define COREDUMP_MAX (767*1024*1024u)
-assert_cc(COREDUMP_MAX <= ENTRY_SIZE_MAX);
+assert_cc(JOURNAL_SIZE_MAX <= ENTRY_SIZE_MAX);
enum {
ARG_PID = 1,
@@ -55,44 +69,272 @@ enum {
_ARG_MAX
};
-static int divert_coredump(void) {
- _cleanup_fclose_ FILE *f = NULL;
+typedef enum CoredumpStorage {
+ COREDUMP_STORAGE_NONE,
+ COREDUMP_STORAGE_EXTERNAL,
+ COREDUMP_STORAGE_JOURNAL,
+ COREDUMP_STORAGE_BOTH,
+ _COREDUMP_STORAGE_MAX,
+ _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",
+ [COREDUMP_STORAGE_JOURNAL] = "journal",
+ [COREDUMP_STORAGE_BOTH] = "both",
+};
+
+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 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 },
+ {}
+ };
+
+ return config_parse(
+ NULL,
+ "/etc/systemd/coredump.conf",
+ NULL,
+ "Coredump\0",
+ config_item_table_lookup,
+ (void*) items,
+ false,
+ false,
+ NULL);
+}
+
+static int fix_acl(int fd, uid_t uid) {
+
+#ifdef HAVE_ACL
+ _cleanup_(acl_freep) acl_t acl = NULL;
+ acl_entry_t entry;
+ acl_permset_t permset;
+
+ if (uid <= SYSTEM_UID_MAX)
+ return 0;
+
+ /* Make sure normal users can read (but not write or delete)
+ * their own coredumps */
+
+ acl = acl_get_fd(fd);
+ if (!acl) {
+ log_error("Failed to get ACL: %m");
+ return -errno;
+ }
+
+ if (acl_create_entry(&acl, &entry) < 0 ||
+ acl_set_tag_type(entry, ACL_USER) < 0 ||
+ acl_set_qualifier(entry, &uid) < 0) {
+ log_error("Failed to patch ACL: %m");
+ return -errno;
+ }
+
+ if (acl_get_permset(entry, &permset) < 0 ||
+ acl_add_perm(permset, ACL_READ) < 0 ||
+ calc_acl_mask_if_needed(&acl) < 0) {
+ log_warning("Failed to patch ACL: %m");
+ return -errno;
+ }
+
+ if (acl_set_fd(fd, acl) < 0) {
+ log_error("Failed to apply ACL: %m");
+ return -errno;
+ }
+#endif
+
+ return 0;
+}
+
+static int fix_xattr(int fd, char *argv[]) {
+ int r = 0;
+
+ /* Attach some metadate to coredumps via extended
+ * attributes. Just because we can. */
+
+ if (!isempty(argv[ARG_PID]))
+ if (fsetxattr(fd, "user.coredump.pid", argv[ARG_PID], strlen(argv[ARG_PID]), XATTR_CREATE) < 0)
+ r = -errno;
+
+ if (!isempty(argv[ARG_UID]))
+ if (fsetxattr(fd, "user.coredump.uid", argv[ARG_UID], strlen(argv[ARG_UID]), XATTR_CREATE) < 0)
+ r = -errno;
+
+ if (!isempty(argv[ARG_GID]))
+ if (fsetxattr(fd, "user.coredump.gid", argv[ARG_GID], strlen(argv[ARG_GID]), XATTR_CREATE) < 0)
+ r = -errno;
+
+ if (!isempty(argv[ARG_SIGNAL]))
+ if (fsetxattr(fd, "user.coredump.signal", argv[ARG_SIGNAL], strlen(argv[ARG_SIGNAL]), XATTR_CREATE) < 0)
+ r = -errno;
+
+ if (!isempty(argv[ARG_TIMESTAMP]))
+ if (fsetxattr(fd, "user.coredump.timestamp", argv[ARG_TIMESTAMP], strlen(argv[ARG_TIMESTAMP]), XATTR_CREATE) < 0)
+ r = -errno;
- log_info("Detected coredump of the journal daemon itself, diverting coredump to /var/lib/systemd/coredump/.");
+ if (!isempty(argv[ARG_COMM]))
+ if (fsetxattr(fd, "user.coredump.comm", argv[ARG_COMM], strlen(argv[ARG_COMM]), XATTR_CREATE) < 0)
+ r = -errno;
+
+ return r;
+}
+
+#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) {
+ _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(ret_filename);
+ assert(ret_fd);
+ assert(ret_size);
+
+ c = filename_escape(argv[ARG_COMM]);
+ if (!c)
+ return log_oom();
+
+ p = filename_escape(argv[ARG_PID]);
+ if (!p)
+ return log_oom();
+
+ t = filename_escape(argv[ARG_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;
+ }
+
+ r = asprintf(&fn,
+ "/var/lib/systemd/coredump/core.%s." SD_ID128_FORMAT_STR ".%s.%s000000",
+ c,
+ SD_ID128_FORMAT_VAL(boot),
+ p,
+ t);
+ if (r < 0)
+ return log_oom();
+
+ tmp = tempfn_random(fn);
+ if (!tmp)
+ return log_oom();
mkdir_p_label("/var/lib/systemd/coredump", 0755);
- f = fopen("/var/lib/systemd/coredump/core.systemd-journald", "we");
- if (!f) {
+ 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");
return -errno;
}
- for (;;) {
- uint8_t buffer[4096];
- size_t l, q;
+ r = copy_bytes(STDIN_FILENO, fd);
+ if (r < 0) {
+ log_error("Failed to dump coredump to file: %s", strerror(-r));
+ goto fail;
+ }
- l = fread(buffer, 1, sizeof(buffer), stdin);
- if (l <= 0) {
- if (ferror(f)) {
- log_error("Failed to read coredump: %m");
- return -errno;
- }
+ /* Ignore errors on these */
+ fchmod(fd, 0640);
+ fix_acl(fd, uid);
+ fix_xattr(fd, argv);
- break;
- }
+ if (fsync(fd) < 0) {
+ log_error("Failed to sync coredump: %m");
+ r = -errno;
+ goto fail;
+ }
- q = fwrite(buffer, 1, l, f);
- if (q != l) {
- log_error("Failed to write coredump: %m");
- return -errno;
- }
+ if (fstat(fd, &st) < 0) {
+ log_error("Failed to fstat coredump: %m");
+ r = -errno;
+ goto fail;
+ }
+
+ if (rename(tmp, fn) < 0) {
+ log_error("Failed to rename coredump: %m");
+ r = -errno;
+ goto fail;
+ }
+
+ *ret_filename = fn;
+ *ret_fd = fd;
+ *ret_size = st.st_size;
+
+ fn = NULL;
+ fd = -1;
+
+ return 0;
+
+fail:
+ unlink_noerrno(tmp);
+ return r;
+}
+
+static int allocate_journal_field(int fd, size_t size, char **ret, size_t *ret_size) {
+ _cleanup_free_ char *field = NULL;
+ ssize_t n;
+
+ assert(ret);
+ assert(ret_size);
+
+ if (lseek(fd, 0, SEEK_SET) == (off_t) -1) {
+ log_warning("Failed to seek: %m");
+ return -errno;
}
- fflush(f);
+ field = malloc(9 + size);
+ if (!field) {
+ log_warning("Failed to allocate memory fore coredump, coredump will not be stored.");
+ return -ENOMEM;
+ }
+
+ memcpy(field, "COREDUMP=", 9);
+
+ n = read(fd, field + 9, size);
+ if (n < 0) {
+ log_error("Failed to read core data: %s", strerror(-n));
+ return (int) n;
+ }
+ if ((size_t) n < size) {
+ log_error("Core data too short.");
+ return -EIO;
+ }
+
+ *ret = field;
+ *ret_size = size + 9;
+
+ field = NULL;
+
+ return 0;
+}
- if (ferror(f)) {
- log_error("Failed to write coredump: %m");
+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;
}
@@ -100,47 +342,80 @@ static int divert_coredump(void) {
}
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;
+
+ _cleanup_close_ int coredump_fd = -1;
+
+ struct iovec iovec[14];
+ off_t coredump_size;
int r, j = 0;
- char *t;
- ssize_t n;
pid_t pid;
uid_t uid;
gid_t gid;
- struct iovec iovec[14];
- size_t coredump_bufsize = 0, coredump_size = 0;
- _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;
+ char *t;
+ /* Make sure we never enter a loop */
prctl(PR_SET_DUMPABLE, 0);
- if (argc != _ARG_MAX) {
- log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
- log_open();
+ /* First, log to a safe place, since we don't know what
+ * crashed and it might be journald which we'd rather not log
+ * to then. */
+ log_set_target(LOG_TARGET_KMSG);
+ log_set_max_level(LOG_DEBUG);
+ log_open();
+ if (argc != _ARG_MAX) {
log_error("Invalid number of arguments passed from kernel.");
r = -EINVAL;
goto finish;
}
- r = parse_pid(argv[ARG_PID], &pid);
+ /* Ignore all parse errors */
+ parse_config();
+ log_debug("Selected storage '%s'.", coredump_storage_to_string(arg_storage));
+
+ r = parse_uid(argv[ARG_UID], &uid);
if (r < 0) {
- log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
- log_open();
+ log_error("Failed to parse UID.");
+ goto finish;
+ }
+ r = parse_pid(argv[ARG_PID], &pid);
+ if (r < 0) {
log_error("Failed to parse PID.");
goto finish;
}
+ r = parse_gid(argv[ARG_GID], &gid);
+ if (r < 0) {
+ log_error("Failed to parse GID.");
+ goto finish;
+ }
+
if (cg_pid_get_unit(pid, &t) >= 0) {
if (streq(t, SPECIAL_JOURNALD_SERVICE)) {
- /* Make sure we don't make use of the journal,
- * if it's the journal which is crashing */
- log_set_target(LOG_TARGET_KMSG);
- log_open();
- r = divert_coredump();
+ /* If we are journald, we cut things short,
+ * don't write to the journal, but still
+ * create a coredump. */
+
+ if (arg_storage != COREDUMP_STORAGE_NONE)
+ arg_storage = COREDUMP_STORAGE_EXTERNAL;
+
+ r = save_external_coredump(argv, uid, &coredump_filename, &coredump_fd, &coredump_size);
+ if (r < 0)
+ goto finish;
+
+ r = maybe_remove_external_coredump(coredump_filename, coredump_size);
+ if (r < 0)
+ goto finish;
+
+ log_info("Detected coredump of the journal daemon itself, diverted to %s.", coredump_filename);
goto finish;
}
@@ -151,23 +426,11 @@ int main(int argc, char* argv[]) {
if (core_unit)
IOVEC_SET_STRING(iovec[j++], core_unit);
- /* OK, now we know it's not the journal, hence make use of
- * it */
+ /* OK, now we know it's not the journal, hence we can make use
+ * of it now. */
log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
log_open();
- r = parse_uid(argv[ARG_UID], &uid);
- if (r < 0) {
- log_error("Failed to parse UID.");
- goto finish;
- }
-
- r = parse_gid(argv[ARG_GID], &gid);
- if (r < 0) {
- log_error("Failed to parse GID.");
- goto finish;
- }
-
core_pid = strappend("COREDUMP_PID=", argv[ARG_PID]);
if (core_pid)
IOVEC_SET_STRING(iovec[j++], core_pid);
@@ -188,7 +451,6 @@ int main(int argc, char* argv[]) {
if (core_comm)
IOVEC_SET_STRING(iovec[j++], core_comm);
-#ifdef HAVE_LOGIND
if (sd_pid_get_session(pid, &t) >= 0) {
core_session = strappend("COREDUMP_SESSION=", t);
free(t);
@@ -197,8 +459,6 @@ int main(int argc, char* argv[]) {
IOVEC_SET_STRING(iovec[j++], core_session);
}
-#endif
-
if (get_process_exe(pid, &t) >= 0) {
core_exe = strappend("COREDUMP_EXE=", t);
free(t);
@@ -226,12 +486,22 @@ int main(int argc, char* argv[]) {
if (core_message)
IOVEC_SET_STRING(iovec[j++], core_message);
+ /* Always stream the coredump to disk, if that's possible */
+ r = save_external_coredump(argv, uid, &coredump_filename, &coredump_fd, &coredump_size);
+ if (r < 0)
+ goto finish;
+
+ /* If we don't want to keep the coredump on disk, remove it
+ * now, as later on we will lack the privileges for it. */
+ r = maybe_remove_external_coredump(coredump_filename, coredump_size);
+ if (r < 0)
+ goto finish;
+
/* 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. */
-
if (setresgid(gid, gid, gid) < 0 ||
setresuid(uid, uid, uid) < 0) {
log_error("Failed to drop privileges: %m");
@@ -239,40 +509,21 @@ int main(int argc, char* argv[]) {
goto finish;
}
- for (;;) {
- if (!GREEDY_REALLOC(coredump_data, coredump_bufsize,
- MAX(coredump_size + 1, COREDUMP_MIN_START/2))) {
- log_warning("Failed to allocate memory for core, core will not be stored.");
- goto finalize;
- }
+ /* Optionally store the entire coredump in the journal */
+ if (IN_SET(arg_storage, COREDUMP_STORAGE_JOURNAL, COREDUMP_STORAGE_BOTH) &&
+ coredump_size <= (off_t) arg_journal_size_max) {
+ size_t sz;
- if (coredump_size == 0) {
- memcpy(coredump_data, "COREDUMP=", 9);
- coredump_size = 9;
- }
+ /* Store the coredump itself in the journal */
- n = loop_read(STDIN_FILENO, coredump_data + coredump_size,
- coredump_bufsize - coredump_size, false);
- if (n < 0) {
- log_error("Failed to read core data: %s", strerror(-n));
- r = (int) n;
- goto finish;
- } else if (n == 0)
- break;
-
- coredump_size += n;
-
- if (coredump_size > COREDUMP_MAX) {
- log_error("Core too large, core will not be stored.");
- goto finalize;
+ r = allocate_journal_field(coredump_fd, (size_t) coredump_size, &coredump_data, &sz);
+ if (r >= 0) {
+ iovec[j].iov_base = coredump_data;
+ iovec[j].iov_len = sz;
+ j++;
}
}
- iovec[j].iov_base = coredump_data;
- iovec[j].iov_len = coredump_size;
- j++;
-
-finalize:
r = sd_journal_sendv(iovec, j);
if (r < 0)
log_error("Failed to log coredump: %s", strerror(-r));
diff --git a/src/journal/coredump.conf b/src/journal/coredump.conf
new file mode 100644
index 0000000000..53e471ed70
--- /dev/null
+++ b/src/journal/coredump.conf
@@ -0,0 +1,14 @@
+# This file is part of systemd.
+#
+# systemd is free software; you can redistribute it and/or modify it
+# under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2.1 of the License, or
+# (at your option) any later version.
+#
+# See coredump.conf(5) for details
+
+[Coredump]
+#Storage=external
+#ProcessSizeMax=2G
+#ExternalSizeMax=2G
+#JournalSizeMax=767M
diff --git a/src/journal/journald-server.c b/src/journal/journald-server.c
index eda5dcf7e9..39a1a07eda 100644
--- a/src/journal/journald-server.c
+++ b/src/journal/journald-server.c
@@ -205,7 +205,7 @@ void server_fix_perms(Server *s, JournalFile *f, uid_t uid) {
log_warning("Failed to fix access mode on %s, ignoring: %s", f->path, strerror(-r));
#ifdef HAVE_ACL
- if (uid <= 0)
+ if (uid <= SYSTEM_UID_MAX)
return;
acl = acl_get_fd(f->fd);
diff --git a/src/shared/acl-util.h b/src/shared/acl-util.h
index 36ef490d7e..a753ad14fd 100644
--- a/src/shared/acl-util.h
+++ b/src/shared/acl-util.h
@@ -26,3 +26,11 @@
int acl_find_uid(acl_t acl, uid_t uid, acl_entry_t *entry);
int calc_acl_mask_if_needed(acl_t *acl_p);
int search_acl_groups(char*** dst, const char* path, bool* belong);
+
+static inline void acl_freep(acl_t *acl) {
+
+ if (!*acl)
+ return;
+
+ acl_free(*acl);
+}
diff --git a/src/shared/sleep-config.c b/src/shared/sleep-config.c
index cf1cd400e8..1972cdbb38 100644
--- a/src/shared/sleep-config.c
+++ b/src/shared/sleep-config.c
@@ -31,6 +31,7 @@
#define USE(x, y) do{ (x) = (y); (y) = NULL; } while(0)
int parse_sleep_config(const char *verb, char ***_modes, char ***_states) {
+
_cleanup_strv_free_ char
**suspend_mode = NULL, **suspend_state = NULL,
**hibernate_mode = NULL, **hibernate_state = NULL,
@@ -44,7 +45,8 @@ int parse_sleep_config(const char *verb, char ***_modes, char ***_states) {
{ "Sleep", "HibernateState", config_parse_strv, 0, &hibernate_state },
{ "Sleep", "HybridSleepMode", config_parse_strv, 0, &hybrid_mode },
{ "Sleep", "HybridSleepState", config_parse_strv, 0, &hybrid_state },
- {}};
+ {}
+ };
int r;
FILE _cleanup_fclose_ *f;
diff --git a/src/sleep/sleep.c b/src/sleep/sleep.c
index 94bcb2944a..118d10c23a 100644
--- a/src/sleep/sleep.c
+++ b/src/sleep/sleep.c
@@ -135,6 +135,7 @@ static int execute(char **modes, char **states) {
}
static int help(void) {
+
printf("%s COMMAND\n\n"
"Suspend the system, hibernate the system, or both.\n\n"
"Commands:\n"