summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
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"