2 This file is part of systemd.
4 Copyright 2012 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/prctl.h>
23 #include <sys/xattr.h>
28 #include <elfutils/libdwfl.h>
31 #include "sd-daemon.h"
32 #include "sd-journal.h"
34 #include "sd-messages.h"
37 #include "alloc-util.h"
38 #include "capability-util.h"
39 #include "cgroup-util.h"
41 #include "conf-parser.h"
43 #include "coredump-vacuum.h"
44 #include "dirent-util.h"
50 #include "journal-importer.h"
55 #include "parse-util.h"
56 #include "process-util.h"
57 #include "signal-util.h"
58 #include "socket-util.h"
60 #include "stacktrace.h"
61 #include "string-table.h"
62 #include "string-util.h"
64 #include "user-util.h"
67 /* The maximum size up to which we process coredumps */
68 #define PROCESS_SIZE_MAX ((uint64_t) (2LLU*1024LLU*1024LLU*1024LLU))
70 /* The maximum size up to which we leave the coredump around on disk */
71 #define EXTERNAL_SIZE_MAX PROCESS_SIZE_MAX
73 /* The maximum size up to which we store the coredump in the journal */
74 #define JOURNAL_SIZE_MAX ((size_t) (767LU*1024LU*1024LU))
76 /* Make sure to not make this larger than the maximum journal entry
77 * size. See DATA_SIZE_MAX in journald-native.c. */
78 assert_cc(JOURNAL_SIZE_MAX
<= DATA_SIZE_MAX
);
81 /* We use this as array indexes for a couple of special fields we use for
82 * naming coredump files, and attaching xattrs, and for indexing argv[].
84 * Our pattern for man:systectl(1) kernel.core_pattern is such that the
85 * kernel passes fields until CONTEXT_RLIMIT as arguments in argv[]. After
86 * that it gets complicated: the kernel passes "comm" as one or more fields
87 * starting at index CONTEXT_COMM (in other words, full "comm" is under index
88 * CONTEXT_COMM when it does not contain spaces, which is the common
89 * case). This mapping is not reversible, so we prefer to retrieve "comm"
90 * from /proc. We only fall back to argv[CONTEXT_COMM...] when that fails.
92 * In the internal context[] array, fields before CONTEXT_COMM are the
93 * strings from argv[], so they should not be freed. The strings at indices
94 * CONTEXT_COMM and higher are allocated by us and should be freed at the
109 typedef enum CoredumpStorage
{
110 COREDUMP_STORAGE_NONE
,
111 COREDUMP_STORAGE_EXTERNAL
,
112 COREDUMP_STORAGE_JOURNAL
,
113 _COREDUMP_STORAGE_MAX
,
114 _COREDUMP_STORAGE_INVALID
= -1
117 static const char* const coredump_storage_table
[_COREDUMP_STORAGE_MAX
] = {
118 [COREDUMP_STORAGE_NONE
] = "none",
119 [COREDUMP_STORAGE_EXTERNAL
] = "external",
120 [COREDUMP_STORAGE_JOURNAL
] = "journal",
123 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(coredump_storage
, CoredumpStorage
);
124 static DEFINE_CONFIG_PARSE_ENUM(config_parse_coredump_storage
, coredump_storage
, CoredumpStorage
, "Failed to parse storage setting");
126 static CoredumpStorage arg_storage
= COREDUMP_STORAGE_EXTERNAL
;
127 static bool arg_compress
= true;
128 static uint64_t arg_process_size_max
= PROCESS_SIZE_MAX
;
129 static uint64_t arg_external_size_max
= EXTERNAL_SIZE_MAX
;
130 static uint64_t arg_journal_size_max
= JOURNAL_SIZE_MAX
;
131 static uint64_t arg_keep_free
= (uint64_t) -1;
132 static uint64_t arg_max_use
= (uint64_t) -1;
134 static int parse_config(void) {
135 static const ConfigTableItem items
[] = {
136 { "Coredump", "Storage", config_parse_coredump_storage
, 0, &arg_storage
},
137 { "Coredump", "Compress", config_parse_bool
, 0, &arg_compress
},
138 { "Coredump", "ProcessSizeMax", config_parse_iec_uint64
, 0, &arg_process_size_max
},
139 { "Coredump", "ExternalSizeMax", config_parse_iec_uint64
, 0, &arg_external_size_max
},
140 { "Coredump", "JournalSizeMax", config_parse_iec_size
, 0, &arg_journal_size_max
},
141 { "Coredump", "KeepFree", config_parse_iec_uint64
, 0, &arg_keep_free
},
142 { "Coredump", "MaxUse", config_parse_iec_uint64
, 0, &arg_max_use
},
146 return config_parse_many_nulstr(PKGSYSCONFDIR
"/coredump.conf",
147 CONF_PATHS_NULSTR("systemd/coredump.conf.d"),
149 config_item_table_lookup
, items
,
150 CONFIG_PARSE_WARN
, NULL
);
153 static inline uint64_t storage_size_max(void) {
154 return arg_storage
== COREDUMP_STORAGE_EXTERNAL
? arg_external_size_max
: arg_journal_size_max
;
157 static int fix_acl(int fd
, uid_t uid
) {
160 _cleanup_(acl_freep
) acl_t acl
= NULL
;
162 acl_permset_t permset
;
167 if (uid
<= SYSTEM_UID_MAX
)
170 /* Make sure normal users can read (but not write or delete)
171 * their own coredumps */
173 acl
= acl_get_fd(fd
);
175 return log_error_errno(errno
, "Failed to get ACL: %m");
177 if (acl_create_entry(&acl
, &entry
) < 0 ||
178 acl_set_tag_type(entry
, ACL_USER
) < 0 ||
179 acl_set_qualifier(entry
, &uid
) < 0)
180 return log_error_errno(errno
, "Failed to patch ACL: %m");
182 if (acl_get_permset(entry
, &permset
) < 0 ||
183 acl_add_perm(permset
, ACL_READ
) < 0)
184 return log_warning_errno(errno
, "Failed to patch ACL: %m");
186 r
= calc_acl_mask_if_needed(&acl
);
188 return log_warning_errno(r
, "Failed to patch ACL: %m");
190 if (acl_set_fd(fd
, acl
) < 0)
191 return log_error_errno(errno
, "Failed to apply ACL: %m");
197 static int fix_xattr(int fd
, const char *context
[_CONTEXT_MAX
]) {
199 static const char * const xattrs
[_CONTEXT_MAX
] = {
200 [CONTEXT_PID
] = "user.coredump.pid",
201 [CONTEXT_UID
] = "user.coredump.uid",
202 [CONTEXT_GID
] = "user.coredump.gid",
203 [CONTEXT_SIGNAL
] = "user.coredump.signal",
204 [CONTEXT_TIMESTAMP
] = "user.coredump.timestamp",
205 [CONTEXT_RLIMIT
] = "user.coredump.rlimit",
206 [CONTEXT_COMM
] = "user.coredump.comm",
207 [CONTEXT_EXE
] = "user.coredump.exe",
215 /* Attach some metadata to coredumps via extended
216 * attributes. Just because we can. */
218 for (i
= 0; i
< _CONTEXT_MAX
; i
++) {
221 if (isempty(context
[i
]) || !xattrs
[i
])
224 k
= fsetxattr(fd
, xattrs
[i
], context
[i
], strlen(context
[i
]), XATTR_CREATE
);
232 #define filename_escape(s) xescape((s), "./ ")
234 static inline const char *coredump_tmpfile_name(const char *s
) {
235 return s
? s
: "(unnamed temporary file)";
238 static int fix_permissions(
240 const char *filename
,
242 const char *context
[_CONTEXT_MAX
],
251 /* Ignore errors on these */
252 (void) fchmod(fd
, 0640);
253 (void) fix_acl(fd
, uid
);
254 (void) fix_xattr(fd
, context
);
257 return log_error_errno(errno
, "Failed to sync coredump %s: %m", coredump_tmpfile_name(filename
));
259 r
= link_tmpfile(fd
, filename
, target
);
261 return log_error_errno(r
, "Failed to move coredump %s into place: %m", target
);
266 static int maybe_remove_external_coredump(const char *filename
, uint64_t size
) {
268 /* Returns 1 if might remove, 0 if will not remove, < 0 on error. */
270 if (arg_storage
== COREDUMP_STORAGE_EXTERNAL
&&
271 size
<= arg_external_size_max
)
277 if (unlink(filename
) < 0 && errno
!= ENOENT
)
278 return log_error_errno(errno
, "Failed to unlink %s: %m", filename
);
283 static int make_filename(const char *context
[_CONTEXT_MAX
], char **ret
) {
284 _cleanup_free_
char *c
= NULL
, *u
= NULL
, *p
= NULL
, *t
= NULL
;
285 sd_id128_t boot
= {};
290 c
= filename_escape(context
[CONTEXT_COMM
]);
294 u
= filename_escape(context
[CONTEXT_UID
]);
298 r
= sd_id128_get_boot(&boot
);
302 p
= filename_escape(context
[CONTEXT_PID
]);
306 t
= filename_escape(context
[CONTEXT_TIMESTAMP
]);
311 "/var/lib/systemd/coredump/core.%s.%s." SD_ID128_FORMAT_STR
".%s.%s000000",
314 SD_ID128_FORMAT_VAL(boot
),
322 static int save_external_coredump(
323 const char *context
[_CONTEXT_MAX
],
329 bool *ret_truncated
) {
331 _cleanup_free_
char *fn
= NULL
, *tmp
= NULL
;
332 _cleanup_close_
int fd
= -1;
333 uint64_t rlimit
, max_size
;
339 assert(ret_filename
);
344 r
= parse_uid(context
[CONTEXT_UID
], &uid
);
346 return log_error_errno(r
, "Failed to parse UID: %m");
348 r
= safe_atou64(context
[CONTEXT_RLIMIT
], &rlimit
);
350 return log_error_errno(r
, "Failed to parse resource limit: %s", context
[CONTEXT_RLIMIT
]);
351 if (rlimit
< page_size()) {
352 /* Is coredumping disabled? Then don't bother saving/processing the coredump.
353 * Anything below PAGE_SIZE cannot give a readable coredump (the kernel uses
354 * ELF_EXEC_PAGESIZE which is not easily accessible, but is usually the same as PAGE_SIZE. */
355 log_info("Resource limits disable core dumping for process %s (%s).",
356 context
[CONTEXT_PID
], context
[CONTEXT_COMM
]);
360 /* Never store more than the process configured, or than we actually shall keep or process */
361 max_size
= MIN(rlimit
, MAX(arg_process_size_max
, storage_size_max()));
363 r
= make_filename(context
, &fn
);
365 return log_error_errno(r
, "Failed to determine coredump file name: %m");
367 mkdir_p_label("/var/lib/systemd/coredump", 0755);
369 fd
= open_tmpfile_linkable(fn
, O_RDWR
|O_CLOEXEC
, &tmp
);
371 return log_error_errno(fd
, "Failed to create temporary file for coredump %s: %m", fn
);
373 r
= copy_bytes(input_fd
, fd
, max_size
, 0);
375 log_error_errno(r
, "Cannot store coredump of %s (%s): %m", context
[CONTEXT_PID
], context
[CONTEXT_COMM
]);
378 *ret_truncated
= r
== 1;
381 LOG_MESSAGE("Core file was truncated to %zu bytes.", max_size
),
382 "SIZE_LIMIT=%zu", max_size
,
383 "MESSAGE_ID=" SD_MESSAGE_TRUNCATED_CORE_STR
,
386 if (fstat(fd
, &st
) < 0) {
387 log_error_errno(errno
, "Failed to fstat core file %s: %m", coredump_tmpfile_name(tmp
));
391 if (lseek(fd
, 0, SEEK_SET
) == (off_t
) -1) {
392 log_error_errno(errno
, "Failed to seek on %s: %m", coredump_tmpfile_name(tmp
));
396 #if HAVE_XZ || HAVE_LZ4
397 /* If we will remove the coredump anyway, do not compress. */
398 if (arg_compress
&& !maybe_remove_external_coredump(NULL
, st
.st_size
)) {
400 _cleanup_free_
char *fn_compressed
= NULL
, *tmp_compressed
= NULL
;
401 _cleanup_close_
int fd_compressed
= -1;
403 fn_compressed
= strappend(fn
, COMPRESSED_EXT
);
404 if (!fn_compressed
) {
409 fd_compressed
= open_tmpfile_linkable(fn_compressed
, O_RDWR
|O_CLOEXEC
, &tmp_compressed
);
410 if (fd_compressed
< 0) {
411 log_error_errno(fd_compressed
, "Failed to create temporary file for coredump %s: %m", fn_compressed
);
415 r
= compress_stream(fd
, fd_compressed
, -1);
417 log_error_errno(r
, "Failed to compress %s: %m", coredump_tmpfile_name(tmp_compressed
));
418 goto fail_compressed
;
421 r
= fix_permissions(fd_compressed
, tmp_compressed
, fn_compressed
, context
, uid
);
423 goto fail_compressed
;
425 /* OK, this worked, we can get rid of the uncompressed version now */
429 *ret_filename
= fn_compressed
; /* compressed */
430 *ret_node_fd
= fd_compressed
; /* compressed */
431 *ret_data_fd
= fd
; /* uncompressed */
432 *ret_size
= (uint64_t) st
.st_size
; /* uncompressed */
434 fn_compressed
= NULL
;
435 fd
= fd_compressed
= -1;
441 (void) unlink(tmp_compressed
);
447 r
= fix_permissions(fd
, tmp
, fn
, context
, uid
);
454 *ret_size
= (uint64_t) st
.st_size
;
467 static int allocate_journal_field(int fd
, size_t size
, char **ret
, size_t *ret_size
) {
468 _cleanup_free_
char *field
= NULL
;
475 if (lseek(fd
, 0, SEEK_SET
) == (off_t
) -1)
476 return log_warning_errno(errno
, "Failed to seek: %m");
478 field
= malloc(9 + size
);
480 log_warning("Failed to allocate memory for coredump, coredump will not be stored.");
484 memcpy(field
, "COREDUMP=", 9);
486 n
= read(fd
, field
+ 9, size
);
488 return log_error_errno((int) n
, "Failed to read core data: %m");
489 if ((size_t) n
< size
) {
490 log_error("Core data too short.");
495 *ret_size
= size
+ 9;
502 /* Joins /proc/[pid]/fd/ and /proc/[pid]/fdinfo/ into the following lines:
516 static int compose_open_fds(pid_t pid
, char **open_fds
) {
517 _cleanup_closedir_
DIR *proc_fd_dir
= NULL
;
518 _cleanup_close_
int proc_fdinfo_fd
= -1;
519 _cleanup_free_
char *buffer
= NULL
;
520 _cleanup_fclose_
FILE *stream
= NULL
;
521 const char *fddelim
= "", *path
;
522 struct dirent
*dent
= NULL
;
527 assert(open_fds
!= NULL
);
529 path
= procfs_file_alloca(pid
, "fd");
530 proc_fd_dir
= opendir(path
);
534 proc_fdinfo_fd
= openat(dirfd(proc_fd_dir
), "../fdinfo", O_DIRECTORY
|O_NOFOLLOW
|O_CLOEXEC
|O_PATH
);
535 if (proc_fdinfo_fd
< 0)
538 stream
= open_memstream(&buffer
, &size
);
542 FOREACH_DIRENT(dent
, proc_fd_dir
, return -errno
) {
543 _cleanup_fclose_
FILE *fdinfo
= NULL
;
544 _cleanup_free_
char *fdname
= NULL
;
548 r
= readlinkat_malloc(dirfd(proc_fd_dir
), dent
->d_name
, &fdname
);
552 fprintf(stream
, "%s%s:%s\n", fddelim
, dent
->d_name
, fdname
);
555 /* Use the directory entry from /proc/[pid]/fd with /proc/[pid]/fdinfo */
556 fd
= openat(proc_fdinfo_fd
, dent
->d_name
, O_NOFOLLOW
|O_CLOEXEC
|O_RDONLY
);
560 fdinfo
= fdopen(fd
, "re");
561 if (fdinfo
== NULL
) {
566 FOREACH_LINE(line
, fdinfo
, break) {
567 fputs_unlocked(line
, stream
);
568 if (!endswith(line
, "\n"))
574 stream
= safe_fclose(stream
);
585 static int get_process_ns(pid_t pid
, const char *namespace, ino_t
*ns
) {
588 _cleanup_close_
int proc_ns_dir_fd
;
590 p
= procfs_file_alloca(pid
, "ns");
592 proc_ns_dir_fd
= open(p
, O_DIRECTORY
| O_CLOEXEC
| O_RDONLY
);
593 if (proc_ns_dir_fd
< 0)
596 if (fstatat(proc_ns_dir_fd
, namespace, &stbuf
, /* flags */0) < 0)
603 static int get_mount_namespace_leader(pid_t pid
, pid_t
*container_pid
) {
604 pid_t cpid
= pid
, ppid
= 0;
608 r
= get_process_ns(pid
, "mnt", &proc_mntns
);
615 r
= get_process_ppid(cpid
, &ppid
);
619 r
= get_process_ns(ppid
, "mnt", &parent_mntns
);
623 if (proc_mntns
!= parent_mntns
)
632 *container_pid
= ppid
;
636 /* Returns 1 if the parent was found.
637 * Returns 0 if there is not a process we can call the pid's
638 * container parent (the pid's process isn't 'containerized').
639 * Returns a negative number on errors.
641 static int get_process_container_parent_cmdline(pid_t pid
, char** cmdline
) {
644 const char *proc_root_path
;
645 struct stat root_stat
, proc_root_stat
;
647 /* To compare inodes of / and /proc/[pid]/root */
648 if (stat("/", &root_stat
) < 0)
651 proc_root_path
= procfs_file_alloca(pid
, "root");
652 if (stat(proc_root_path
, &proc_root_stat
) < 0)
655 /* The process uses system root. */
656 if (proc_root_stat
.st_ino
== root_stat
.st_ino
) {
661 r
= get_mount_namespace_leader(pid
, &container_pid
);
665 r
= get_process_cmdline(container_pid
, 0, false, cmdline
);
672 static int change_uid_gid(const char *context
[]) {
677 r
= parse_uid(context
[CONTEXT_UID
], &uid
);
681 if (uid
<= SYSTEM_UID_MAX
) {
682 const char *user
= "systemd-coredump";
684 r
= get_user_creds(&user
, &uid
, &gid
, NULL
, NULL
);
686 log_warning_errno(r
, "Cannot resolve %s user. Proceeding to dump core as root: %m", user
);
690 r
= parse_gid(context
[CONTEXT_GID
], &gid
);
695 return drop_privileges(uid
, gid
, 0);
698 static bool is_journald_crash(const char *context
[_CONTEXT_MAX
]) {
701 return streq_ptr(context
[CONTEXT_UNIT
], SPECIAL_JOURNALD_SERVICE
);
704 static bool is_pid1_crash(const char *context
[_CONTEXT_MAX
]) {
707 return streq_ptr(context
[CONTEXT_UNIT
], SPECIAL_INIT_SCOPE
) ||
708 streq_ptr(context
[CONTEXT_PID
], "1");
711 #define SUBMIT_COREDUMP_FIELDS 4
713 static int submit_coredump(
714 const char *context
[_CONTEXT_MAX
],
716 size_t n_iovec_allocated
,
720 _cleanup_close_
int coredump_fd
= -1, coredump_node_fd
= -1;
721 _cleanup_free_
char *core_message
= NULL
, *filename
= NULL
, *coredump_data
= NULL
;
722 uint64_t coredump_size
= UINT64_MAX
;
723 bool truncated
= false, journald_crash
;
728 assert(n_iovec_allocated
>= n_iovec
+ SUBMIT_COREDUMP_FIELDS
);
729 assert(input_fd
>= 0);
731 journald_crash
= is_journald_crash(context
);
733 /* Vacuum before we write anything again */
734 (void) coredump_vacuum(-1, arg_keep_free
, arg_max_use
);
736 /* Always stream the coredump to disk, if that's possible */
737 r
= save_external_coredump(context
, input_fd
,
738 &filename
, &coredump_node_fd
, &coredump_fd
, &coredump_size
, &truncated
);
740 /* Skip whole core dumping part */
743 /* If we don't want to keep the coredump on disk, remove it now, as later on we will lack the privileges for
744 * it. However, we keep the fd to it, so that we can still process it and log it. */
745 r
= maybe_remove_external_coredump(filename
, coredump_size
);
749 const char *coredump_filename
;
751 coredump_filename
= strjoina("COREDUMP_FILENAME=", filename
);
752 iovec
[n_iovec
++] = IOVEC_MAKE_STRING(coredump_filename
);
753 } else if (arg_storage
== COREDUMP_STORAGE_EXTERNAL
)
754 log_info("The core will not be stored: size %"PRIu64
" is greater than %"PRIu64
" (the configured maximum)",
755 coredump_size
, arg_external_size_max
);
757 /* Vacuum again, but exclude the coredump we just created */
758 (void) coredump_vacuum(coredump_node_fd
>= 0 ? coredump_node_fd
: coredump_fd
, arg_keep_free
, arg_max_use
);
760 /* Now, let's drop privileges to become the user who owns the segfaulted process and allocate the coredump
761 * memory under the user's uid. This also ensures that the credentials journald will see are the ones of the
762 * coredumping user, thus making sure the user gets access to the core dump. Let's also get rid of all
763 * capabilities, if we run as root, we won't need them anymore. */
764 r
= change_uid_gid(context
);
766 return log_error_errno(r
, "Failed to drop privileges: %m");
769 /* Try to get a strack trace if we can */
770 if (coredump_size
<= arg_process_size_max
) {
771 _cleanup_free_
char *stacktrace
= NULL
;
773 r
= coredump_make_stack_trace(coredump_fd
, context
[CONTEXT_EXE
], &stacktrace
);
775 core_message
= strjoin("MESSAGE=Process ", context
[CONTEXT_PID
],
776 " (", context
[CONTEXT_COMM
], ") of user ",
777 context
[CONTEXT_UID
], " dumped core.",
778 journald_crash
? "\nCoredump diverted to " : "",
779 journald_crash
? filename
: "",
781 else if (r
== -EINVAL
)
782 log_warning("Failed to generate stack trace: %s", dwfl_errmsg(dwfl_errno()));
784 log_warning_errno(r
, "Failed to generate stack trace: %m");
786 log_debug("Not generating stack trace: core size %"PRIu64
" is greater than %"PRIu64
" (the configured maximum)",
787 coredump_size
, arg_process_size_max
);
792 core_message
= strjoin("MESSAGE=Process ", context
[CONTEXT_PID
],
793 " (", context
[CONTEXT_COMM
], ") of user ",
794 context
[CONTEXT_UID
], " dumped core.",
795 journald_crash
? "\nCoredump diverted to " : NULL
,
796 journald_crash
? filename
: NULL
);
800 if (journald_crash
) {
801 /* We cannot log to the journal, so just print the MESSAGE.
802 * The target was set previously to something safe. */
803 log_dispatch(LOG_ERR
, 0, core_message
);
807 iovec
[n_iovec
++] = IOVEC_MAKE_STRING(core_message
);
810 iovec
[n_iovec
++] = IOVEC_MAKE_STRING("COREDUMP_TRUNCATED=1");
812 /* Optionally store the entire coredump in the journal */
813 if (arg_storage
== COREDUMP_STORAGE_JOURNAL
) {
814 if (coredump_size
<= arg_journal_size_max
) {
817 /* Store the coredump itself in the journal */
819 r
= allocate_journal_field(coredump_fd
, (size_t) coredump_size
, &coredump_data
, &sz
);
821 iovec
[n_iovec
++] = IOVEC_MAKE(coredump_data
, sz
);
823 log_warning_errno(r
, "Failed to attach the core to the journal entry: %m");
825 log_info("The core will not be stored: size %"PRIu64
" is greater than %"PRIu64
" (the configured maximum)",
826 coredump_size
, arg_journal_size_max
);
829 assert(n_iovec
<= n_iovec_allocated
);
831 r
= sd_journal_sendv(iovec
, n_iovec
);
833 return log_error_errno(r
, "Failed to log coredump: %m");
838 static void map_context_fields(const struct iovec
*iovec
, const char* context
[]) {
840 static const char * const context_field_names
[] = {
841 [CONTEXT_PID
] = "COREDUMP_PID=",
842 [CONTEXT_UID
] = "COREDUMP_UID=",
843 [CONTEXT_GID
] = "COREDUMP_GID=",
844 [CONTEXT_SIGNAL
] = "COREDUMP_SIGNAL=",
845 [CONTEXT_TIMESTAMP
] = "COREDUMP_TIMESTAMP=",
846 [CONTEXT_RLIMIT
] = "COREDUMP_RLIMIT=",
847 [CONTEXT_COMM
] = "COREDUMP_COMM=",
848 [CONTEXT_EXE
] = "COREDUMP_EXE=",
856 for (i
= 0; i
< ELEMENTSOF(context_field_names
); i
++) {
859 if (!context_field_names
[i
])
862 l
= strlen(context_field_names
[i
]);
863 if (iovec
->iov_len
< l
)
866 if (memcmp(iovec
->iov_base
, context_field_names
[i
], l
) != 0)
869 /* Note that these strings are NUL terminated, because we made sure that a trailing NUL byte is in the
870 * buffer, though not included in the iov_len count. (see below) */
871 context
[i
] = (char*) iovec
->iov_base
+ l
;
876 static int process_socket(int fd
) {
877 _cleanup_close_
int coredump_fd
= -1;
878 struct iovec
*iovec
= NULL
;
879 size_t n_iovec
= 0, n_allocated
= 0, i
, k
;
880 const char *context
[_CONTEXT_MAX
] = {};
885 log_set_target(LOG_TARGET_AUTO
);
886 log_parse_environment();
889 log_debug("Processing coredump received on stdin...");
893 struct cmsghdr cmsghdr
;
894 uint8_t buf
[CMSG_SPACE(sizeof(int))];
897 .msg_control
= &control
,
898 .msg_controllen
= sizeof(control
),
904 if (!GREEDY_REALLOC(iovec
, n_allocated
, n_iovec
+ SUBMIT_COREDUMP_FIELDS
)) {
909 l
= next_datagram_size_fd(fd
);
911 r
= log_error_errno(l
, "Failed to determine datagram size to read: %m");
917 iovec
[n_iovec
].iov_len
= l
;
918 iovec
[n_iovec
].iov_base
= malloc(l
+ 1);
919 if (!iovec
[n_iovec
].iov_base
) {
924 mh
.msg_iov
= iovec
+ n_iovec
;
926 n
= recvmsg(fd
, &mh
, MSG_NOSIGNAL
|MSG_CMSG_CLOEXEC
);
928 free(iovec
[n_iovec
].iov_base
);
929 r
= log_error_errno(errno
, "Failed to receive datagram: %m");
934 struct cmsghdr
*cmsg
, *found
= NULL
;
935 /* The final zero-length datagram carries the file descriptor and tells us that we're done. */
937 free(iovec
[n_iovec
].iov_base
);
939 CMSG_FOREACH(cmsg
, &mh
) {
940 if (cmsg
->cmsg_level
== SOL_SOCKET
&&
941 cmsg
->cmsg_type
== SCM_RIGHTS
&&
942 cmsg
->cmsg_len
== CMSG_LEN(sizeof(int))) {
949 log_error("Coredump file descriptor missing.");
954 assert(coredump_fd
< 0);
955 coredump_fd
= *(int*) CMSG_DATA(found
);
959 /* Add trailing NUL byte, in case these are strings */
960 ((char*) iovec
[n_iovec
].iov_base
)[n
] = 0;
961 iovec
[n_iovec
].iov_len
= (size_t) n
;
964 map_context_fields(iovec
+ n_iovec
, context
);
968 if (!GREEDY_REALLOC(iovec
, n_allocated
, n_iovec
+ SUBMIT_COREDUMP_FIELDS
)) {
973 /* Make sure we got all data we really need */
974 assert(context
[CONTEXT_PID
]);
975 assert(context
[CONTEXT_UID
]);
976 assert(context
[CONTEXT_GID
]);
977 assert(context
[CONTEXT_SIGNAL
]);
978 assert(context
[CONTEXT_TIMESTAMP
]);
979 assert(context
[CONTEXT_RLIMIT
]);
980 assert(context
[CONTEXT_COMM
]);
981 assert(coredump_fd
>= 0);
983 /* Small quirk: the journal fields contain the timestamp padded with six zeroes, so that the kernel-supplied 1s
984 * granularity timestamps becomes 1µs granularity, i.e. the granularity systemd usually operates in. Since we
985 * are reconstructing the original kernel context, we chop this off again, here. */
986 k
= strlen(context
[CONTEXT_TIMESTAMP
]);
988 context
[CONTEXT_TIMESTAMP
] = strndupa(context
[CONTEXT_TIMESTAMP
], k
- 6);
990 r
= submit_coredump(context
, iovec
, n_allocated
, n_iovec
, coredump_fd
);
993 for (i
= 0; i
< n_iovec
; i
++)
994 free(iovec
[i
].iov_base
);
1000 static int send_iovec(const struct iovec iovec
[], size_t n_iovec
, int input_fd
) {
1002 static const union sockaddr_union sa
= {
1003 .un
.sun_family
= AF_UNIX
,
1004 .un
.sun_path
= "/run/systemd/coredump",
1006 _cleanup_close_
int fd
= -1;
1010 assert(iovec
|| n_iovec
<= 0);
1011 assert(input_fd
>= 0);
1013 fd
= socket(AF_UNIX
, SOCK_SEQPACKET
|SOCK_CLOEXEC
, 0);
1015 return log_error_errno(errno
, "Failed to create coredump socket: %m");
1017 if (connect(fd
, &sa
.sa
, SOCKADDR_UN_LEN(sa
.un
)) < 0)
1018 return log_error_errno(errno
, "Failed to connect to coredump service: %m");
1020 for (i
= 0; i
< n_iovec
; i
++) {
1021 struct msghdr mh
= {
1022 .msg_iov
= (struct iovec
*) iovec
+ i
,
1025 struct iovec copy
[2];
1028 if (sendmsg(fd
, &mh
, MSG_NOSIGNAL
) >= 0)
1031 if (errno
== EMSGSIZE
&& mh
.msg_iov
[0].iov_len
> 0) {
1032 /* This field didn't fit? That's a pity. Given that this is just metadata,
1033 * let's truncate the field at half, and try again. We append three dots, in
1034 * order to show that this is truncated. */
1036 if (mh
.msg_iov
!= copy
) {
1037 /* We don't want to modify the caller's iovec, hence let's create our
1038 * own array, consisting of two new iovecs, where the first is a
1039 * (truncated) copy of what we want to send, and the second one
1040 * contains the trailing dots. */
1042 copy
[1] = (struct iovec
) {
1043 .iov_base
= (char[]) { '.', '.', '.' },
1051 copy
[0].iov_len
/= 2; /* halve it, and try again */
1055 return log_error_errno(errno
, "Failed to send coredump datagram: %m");
1059 r
= send_one_fd(fd
, input_fd
, 0);
1061 return log_error_errno(r
, "Failed to send coredump fd: %m");
1066 static char* set_iovec_field(struct iovec iovec
[27], size_t *n_iovec
, const char *field
, const char *value
) {
1069 x
= strappend(field
, value
);
1071 iovec
[(*n_iovec
)++] = IOVEC_MAKE_STRING(x
);
1075 static char* set_iovec_field_free(struct iovec iovec
[27], size_t *n_iovec
, const char *field
, char *value
) {
1078 x
= set_iovec_field(iovec
, n_iovec
, field
, value
);
1083 static int gather_pid_metadata(
1084 char* context
[_CONTEXT_MAX
],
1085 char **comm_fallback
,
1086 struct iovec
*iovec
, size_t *n_iovec
) {
1088 /* We need 26 empty slots in iovec!
1090 * Note that if we fail on oom later on, we do not roll-back changes to the iovec structure. (It remains valid,
1091 * with the first n_iovec fields initialized.) */
1099 r
= parse_pid(context
[CONTEXT_PID
], &pid
);
1101 return log_error_errno(r
, "Failed to parse PID \"%s\": %m", context
[CONTEXT_PID
]);
1103 r
= get_process_comm(pid
, &context
[CONTEXT_COMM
]);
1105 log_warning_errno(r
, "Failed to get COMM, falling back to the command line: %m");
1106 context
[CONTEXT_COMM
] = strv_join(comm_fallback
, " ");
1107 if (!context
[CONTEXT_COMM
])
1111 r
= get_process_exe(pid
, &context
[CONTEXT_EXE
]);
1113 log_warning_errno(r
, "Failed to get EXE, ignoring: %m");
1115 if (cg_pid_get_unit(pid
, &context
[CONTEXT_UNIT
]) >= 0) {
1116 if (!is_journald_crash((const char**) context
)) {
1117 /* OK, now we know it's not the journal, hence we can make use of it now. */
1118 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG
);
1122 /* If this is PID 1 disable coredump collection, we'll unlikely be able to process it later on. */
1123 if (is_pid1_crash((const char**) context
)) {
1124 log_notice("Due to PID 1 having crashed coredump collection will now be turned off.");
1125 (void) write_string_file("/proc/sys/kernel/core_pattern", "|/bin/false", 0);
1128 set_iovec_field(iovec
, n_iovec
, "COREDUMP_UNIT=", context
[CONTEXT_UNIT
]);
1131 if (cg_pid_get_user_unit(pid
, &t
) >= 0)
1132 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_USER_UNIT=", t
);
1134 /* The next few are mandatory */
1135 if (!set_iovec_field(iovec
, n_iovec
, "COREDUMP_PID=", context
[CONTEXT_PID
]))
1138 if (!set_iovec_field(iovec
, n_iovec
, "COREDUMP_UID=", context
[CONTEXT_UID
]))
1141 if (!set_iovec_field(iovec
, n_iovec
, "COREDUMP_GID=", context
[CONTEXT_GID
]))
1144 if (!set_iovec_field(iovec
, n_iovec
, "COREDUMP_SIGNAL=", context
[CONTEXT_SIGNAL
]))
1147 if (!set_iovec_field(iovec
, n_iovec
, "COREDUMP_RLIMIT=", context
[CONTEXT_RLIMIT
]))
1150 if (!set_iovec_field(iovec
, n_iovec
, "COREDUMP_COMM=", context
[CONTEXT_COMM
]))
1153 if (context
[CONTEXT_EXE
] &&
1154 !set_iovec_field(iovec
, n_iovec
, "COREDUMP_EXE=", context
[CONTEXT_EXE
]))
1157 if (sd_pid_get_session(pid
, &t
) >= 0)
1158 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_SESSION=", t
);
1160 if (sd_pid_get_owner_uid(pid
, &owner_uid
) >= 0) {
1161 r
= asprintf(&t
, "COREDUMP_OWNER_UID=" UID_FMT
, owner_uid
);
1163 iovec
[(*n_iovec
)++] = IOVEC_MAKE_STRING(t
);
1166 if (sd_pid_get_slice(pid
, &t
) >= 0)
1167 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_SLICE=", t
);
1169 if (get_process_cmdline(pid
, 0, false, &t
) >= 0)
1170 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_CMDLINE=", t
);
1172 if (cg_pid_get_path_shifted(pid
, NULL
, &t
) >= 0)
1173 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_CGROUP=", t
);
1175 if (compose_open_fds(pid
, &t
) >= 0)
1176 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_OPEN_FDS=", t
);
1178 p
= procfs_file_alloca(pid
, "status");
1179 if (read_full_file(p
, &t
, NULL
) >= 0)
1180 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_PROC_STATUS=", t
);
1182 p
= procfs_file_alloca(pid
, "maps");
1183 if (read_full_file(p
, &t
, NULL
) >= 0)
1184 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_PROC_MAPS=", t
);
1186 p
= procfs_file_alloca(pid
, "limits");
1187 if (read_full_file(p
, &t
, NULL
) >= 0)
1188 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_PROC_LIMITS=", t
);
1190 p
= procfs_file_alloca(pid
, "cgroup");
1191 if (read_full_file(p
, &t
, NULL
) >=0)
1192 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_PROC_CGROUP=", t
);
1194 p
= procfs_file_alloca(pid
, "mountinfo");
1195 if (read_full_file(p
, &t
, NULL
) >=0)
1196 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_PROC_MOUNTINFO=", t
);
1198 if (get_process_cwd(pid
, &t
) >= 0)
1199 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_CWD=", t
);
1201 if (get_process_root(pid
, &t
) >= 0) {
1202 bool proc_self_root_is_slash
;
1204 proc_self_root_is_slash
= strcmp(t
, "/") == 0;
1206 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_ROOT=", t
);
1208 /* If the process' root is "/", then there is a chance it has
1209 * mounted own root and hence being containerized. */
1210 if (proc_self_root_is_slash
&& get_process_container_parent_cmdline(pid
, &t
) > 0)
1211 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_CONTAINER_CMDLINE=", t
);
1214 if (get_process_environ(pid
, &t
) >= 0)
1215 set_iovec_field_free(iovec
, n_iovec
, "COREDUMP_ENVIRON=", t
);
1217 t
= strjoin("COREDUMP_TIMESTAMP=", context
[CONTEXT_TIMESTAMP
], "000000", NULL
);
1219 iovec
[(*n_iovec
)++] = IOVEC_MAKE_STRING(t
);
1221 if (safe_atoi(context
[CONTEXT_SIGNAL
], &signo
) >= 0 && SIGNAL_VALID(signo
))
1222 set_iovec_field(iovec
, n_iovec
, "COREDUMP_SIGNAL_NAME=SIG", signal_to_string(signo
));
1224 return 0; /* we successfully acquired all metadata */
1227 static int process_kernel(int argc
, char* argv
[]) {
1229 char* context
[_CONTEXT_MAX
] = {};
1230 struct iovec iovec
[28 + SUBMIT_COREDUMP_FIELDS
];
1231 size_t i
, n_iovec
, n_to_free
= 0;
1234 log_debug("Processing coredump received from the kernel...");
1236 if (argc
< CONTEXT_COMM
+ 1) {
1237 log_error("Not enough arguments passed by the kernel (%i, expected %i).", argc
- 1, CONTEXT_COMM
+ 1 - 1);
1241 context
[CONTEXT_PID
] = argv
[1 + CONTEXT_PID
];
1242 context
[CONTEXT_UID
] = argv
[1 + CONTEXT_UID
];
1243 context
[CONTEXT_GID
] = argv
[1 + CONTEXT_GID
];
1244 context
[CONTEXT_SIGNAL
] = argv
[1 + CONTEXT_SIGNAL
];
1245 context
[CONTEXT_TIMESTAMP
] = argv
[1 + CONTEXT_TIMESTAMP
];
1246 context
[CONTEXT_RLIMIT
] = argv
[1 + CONTEXT_RLIMIT
];
1248 r
= gather_pid_metadata(context
, argv
+ 1 + CONTEXT_COMM
, iovec
, &n_to_free
);
1252 n_iovec
= n_to_free
;
1254 iovec
[n_iovec
++] = IOVEC_MAKE_STRING("MESSAGE_ID=" SD_MESSAGE_COREDUMP_STR
);
1256 assert_cc(2 == LOG_CRIT
);
1257 iovec
[n_iovec
++] = IOVEC_MAKE_STRING("PRIORITY=2");
1259 assert(n_iovec
<= ELEMENTSOF(iovec
));
1261 if (is_journald_crash((const char**) context
) || is_pid1_crash((const char**) context
))
1262 r
= submit_coredump((const char**) context
,
1263 iovec
, ELEMENTSOF(iovec
), n_iovec
,
1266 r
= send_iovec(iovec
, n_iovec
, STDIN_FILENO
);
1269 for (i
= 0; i
< n_to_free
; i
++)
1270 free(iovec
[i
].iov_base
);
1272 /* Those fields are allocated by gather_pid_metadata */
1273 free(context
[CONTEXT_COMM
]);
1274 free(context
[CONTEXT_EXE
]);
1275 free(context
[CONTEXT_UNIT
]);
1280 static int process_backtrace(int argc
, char *argv
[]) {
1281 char *context
[_CONTEXT_MAX
] = {};
1282 _cleanup_free_
char *message
= NULL
;
1283 _cleanup_free_
struct iovec
*iovec
= NULL
;
1284 size_t n_iovec
, n_allocated
, n_to_free
= 0, i
;
1286 JournalImporter importer
= {
1290 log_debug("Processing backtrace on stdin...");
1292 if (argc
< CONTEXT_COMM
+ 1) {
1293 log_error("Not enough arguments passed (%i, expected %i).", argc
- 1, CONTEXT_COMM
+ 1 - 1);
1297 context
[CONTEXT_PID
] = argv
[2 + CONTEXT_PID
];
1298 context
[CONTEXT_UID
] = argv
[2 + CONTEXT_UID
];
1299 context
[CONTEXT_GID
] = argv
[2 + CONTEXT_GID
];
1300 context
[CONTEXT_SIGNAL
] = argv
[2 + CONTEXT_SIGNAL
];
1301 context
[CONTEXT_TIMESTAMP
] = argv
[2 + CONTEXT_TIMESTAMP
];
1302 context
[CONTEXT_RLIMIT
] = argv
[2 + CONTEXT_RLIMIT
];
1304 n_allocated
= 33 + COREDUMP_STORAGE_EXTERNAL
;
1305 /* 25 metadata, 2 static, +unknown input, 4 storage, rounded up */
1306 iovec
= new(struct iovec
, n_allocated
);
1310 r
= gather_pid_metadata(context
, argv
+ 2 + CONTEXT_COMM
, iovec
, &n_to_free
);
1314 /* This was a special crash, and has already been processed. */
1318 n_iovec
= n_to_free
;
1321 r
= journal_importer_process_data(&importer
);
1323 log_error_errno(r
, "Failed to parse journal entry on stdin: %m");
1326 if (r
== 1 || /* complete entry */
1327 journal_importer_eof(&importer
)) /* end of data */
1331 if (!GREEDY_REALLOC(iovec
, n_allocated
, n_iovec
+ importer
.iovw
.count
+ 2))
1334 if (journal_importer_eof(&importer
)) {
1335 log_warning("Did not receive a full journal entry on stdin, ignoring message sent by reporter");
1337 message
= strjoin("MESSAGE=Process ", context
[CONTEXT_PID
],
1338 " (", context
[CONTEXT_COMM
], ")"
1339 " of user ", context
[CONTEXT_UID
],
1340 " failed with ", context
[CONTEXT_SIGNAL
]);
1345 iovec
[n_iovec
++] = IOVEC_MAKE_STRING(message
);
1347 for (i
= 0; i
< importer
.iovw
.count
; i
++)
1348 iovec
[n_iovec
++] = importer
.iovw
.iovec
[i
];
1351 iovec
[n_iovec
++] = IOVEC_MAKE_STRING("MESSAGE_ID=" SD_MESSAGE_BACKTRACE_STR
);
1352 assert_cc(2 == LOG_CRIT
);
1353 iovec
[n_iovec
++] = IOVEC_MAKE_STRING("PRIORITY=2");
1355 assert(n_iovec
<= n_allocated
);
1357 r
= sd_journal_sendv(iovec
, n_iovec
);
1359 log_error_errno(r
, "Failed to log backtrace: %m");
1362 for (i
= 0; i
< n_to_free
; i
++)
1363 free(iovec
[i
].iov_base
);
1365 /* Those fields are allocated by gather_pid_metadata */
1366 free(context
[CONTEXT_COMM
]);
1367 free(context
[CONTEXT_EXE
]);
1368 free(context
[CONTEXT_UNIT
]);
1373 int main(int argc
, char *argv
[]) {
1376 /* First, log to a safe place, since we don't know what crashed and it might
1377 * be journald which we'd rather not log to then. */
1379 log_set_target(LOG_TARGET_KMSG
);
1382 /* Make sure we never enter a loop */
1383 (void) prctl(PR_SET_DUMPABLE
, 0);
1385 /* Ignore all parse errors */
1386 (void) parse_config();
1388 log_debug("Selected storage '%s'.", coredump_storage_to_string(arg_storage
));
1389 log_debug("Selected compression %s.", yes_no(arg_compress
));
1391 r
= sd_listen_fds(false);
1393 log_error_errno(r
, "Failed to determine number of file descriptor: %m");
1397 /* If we got an fd passed, we are running in coredumpd mode. Otherwise we
1398 * are invoked from the kernel as coredump handler. */
1400 if (streq_ptr(argv
[1], "--backtrace"))
1401 r
= process_backtrace(argc
, argv
);
1403 r
= process_kernel(argc
, argv
);
1405 r
= process_socket(SD_LISTEN_FDS_START
);
1407 log_error("Received unexpected number of file descriptors.");
1412 return r
< 0 ? EXIT_FAILURE
: EXIT_SUCCESS
;