chiark / gitweb /
8678ec6a59e131db22ac43924728eafd0d7dee9f
[elogind.git] / src / journal / coredump.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2012 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <unistd.h>
24 #include <stdio.h>
25 #include <sys/prctl.h>
26 #include <sys/types.h>
27 #include <sys/xattr.h>
28
29 #ifdef HAVE_ELFUTILS
30 #  include <dwarf.h>
31 #  include <elfutils/libdwfl.h>
32 #endif
33
34 #include "systemd/sd-journal.h"
35 #include "systemd/sd-login.h"
36
37 #include "log.h"
38 #include "util.h"
39 #include "fileio.h"
40 #include "strv.h"
41 #include "macro.h"
42 #include "mkdir.h"
43 #include "special.h"
44 #include "cgroup-util.h"
45 #include "journald-native.h"
46 #include "conf-parser.h"
47 #include "copy.h"
48 #include "stacktrace.h"
49 #include "path-util.h"
50 #include "compress.h"
51 #include "coredump-vacuum.h"
52
53 #ifdef HAVE_ACL
54 #  include <sys/acl.h>
55 #  include "acl-util.h"
56 #endif
57
58 /* The maximum size up to which we process coredumps */
59 #define PROCESS_SIZE_MAX ((off_t) (2LLU*1024LLU*1024LLU*1024LLU))
60
61 /* The maximum size up to which we leave the coredump around on
62  * disk */
63 #define EXTERNAL_SIZE_MAX PROCESS_SIZE_MAX
64
65 /* The maximum size up to which we store the coredump in the
66  * journal */
67 #define JOURNAL_SIZE_MAX ((size_t) (767LU*1024LU*1024LU))
68
69 /* Make sure to not make this larger than the maximum journal entry
70  * size. See DATA_SIZE_MAX in journald-native.c. */
71 assert_cc(JOURNAL_SIZE_MAX <= DATA_SIZE_MAX);
72
73 enum {
74         INFO_PID,
75         INFO_UID,
76         INFO_GID,
77         INFO_SIGNAL,
78         INFO_TIMESTAMP,
79         INFO_COMM,
80         INFO_EXE,
81         _INFO_LEN
82 };
83
84 typedef enum CoredumpStorage {
85         COREDUMP_STORAGE_NONE,
86         COREDUMP_STORAGE_EXTERNAL,
87         COREDUMP_STORAGE_JOURNAL,
88         COREDUMP_STORAGE_BOTH,
89         _COREDUMP_STORAGE_MAX,
90         _COREDUMP_STORAGE_INVALID = -1
91 } CoredumpStorage;
92
93 static const char* const coredump_storage_table[_COREDUMP_STORAGE_MAX] = {
94         [COREDUMP_STORAGE_NONE] = "none",
95         [COREDUMP_STORAGE_EXTERNAL] = "external",
96         [COREDUMP_STORAGE_JOURNAL] = "journal",
97         [COREDUMP_STORAGE_BOTH] = "both",
98 };
99
100 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(coredump_storage, CoredumpStorage);
101 static DEFINE_CONFIG_PARSE_ENUM(config_parse_coredump_storage, coredump_storage, CoredumpStorage, "Failed to parse storage setting");
102
103 static CoredumpStorage arg_storage = COREDUMP_STORAGE_EXTERNAL;
104 static bool arg_compress = true;
105 static off_t arg_process_size_max = PROCESS_SIZE_MAX;
106 static off_t arg_external_size_max = EXTERNAL_SIZE_MAX;
107 static size_t arg_journal_size_max = JOURNAL_SIZE_MAX;
108 static off_t arg_keep_free = (off_t) -1;
109 static off_t arg_max_use = (off_t) -1;
110
111 static int parse_config(void) {
112         static const ConfigTableItem items[] = {
113                 { "Coredump", "Storage",          config_parse_coredump_storage,  0, &arg_storage           },
114                 { "Coredump", "Compress",         config_parse_bool,              0, &arg_compress          },
115                 { "Coredump", "ProcessSizeMax",   config_parse_iec_off,           0, &arg_process_size_max  },
116                 { "Coredump", "ExternalSizeMax",  config_parse_iec_off,           0, &arg_external_size_max },
117                 { "Coredump", "JournalSizeMax",   config_parse_iec_size,          0, &arg_journal_size_max  },
118                 { "Coredump", "KeepFree",         config_parse_iec_off,           0, &arg_keep_free         },
119                 { "Coredump", "MaxUse",           config_parse_iec_off,           0, &arg_max_use           },
120                 {}
121         };
122
123         return config_parse_many("/etc/systemd/coredump.conf",
124                                  CONF_DIRS_NULSTR("systemd/coredump.conf"),
125                                  "Coredump\0",
126                                  config_item_table_lookup, items,
127                                  false, NULL);
128 }
129
130 static int fix_acl(int fd, uid_t uid) {
131
132 #ifdef HAVE_ACL
133         _cleanup_(acl_freep) acl_t acl = NULL;
134         acl_entry_t entry;
135         acl_permset_t permset;
136
137         assert(fd >= 0);
138
139         if (uid <= SYSTEM_UID_MAX)
140                 return 0;
141
142         /* Make sure normal users can read (but not write or delete)
143          * their own coredumps */
144
145         acl = acl_get_fd(fd);
146         if (!acl)
147                 return log_error_errno(errno, "Failed to get ACL: %m");
148
149         if (acl_create_entry(&acl, &entry) < 0 ||
150             acl_set_tag_type(entry, ACL_USER) < 0 ||
151             acl_set_qualifier(entry, &uid) < 0) {
152                 log_error_errno(errno, "Failed to patch ACL: %m");
153                 return -errno;
154         }
155
156         if (acl_get_permset(entry, &permset) < 0 ||
157             acl_add_perm(permset, ACL_READ) < 0 ||
158             calc_acl_mask_if_needed(&acl) < 0) {
159                 log_warning_errno(errno, "Failed to patch ACL: %m");
160                 return -errno;
161         }
162
163         if (acl_set_fd(fd, acl) < 0)
164                 return log_error_errno(errno, "Failed to apply ACL: %m");
165 #endif
166
167         return 0;
168 }
169
170 static int fix_xattr(int fd, const char *info[_INFO_LEN]) {
171
172         static const char * const xattrs[_INFO_LEN] = {
173                 [INFO_PID] = "user.coredump.pid",
174                 [INFO_UID] = "user.coredump.uid",
175                 [INFO_GID] = "user.coredump.gid",
176                 [INFO_SIGNAL] = "user.coredump.signal",
177                 [INFO_TIMESTAMP] = "user.coredump.timestamp",
178                 [INFO_COMM] = "user.coredump.comm",
179                 [INFO_EXE] = "user.coredump.exe",
180         };
181
182         int r = 0;
183         unsigned i;
184
185         assert(fd >= 0);
186
187         /* Attach some metadata to coredumps via extended
188          * attributes. Just because we can. */
189
190         for (i = 0; i < _INFO_LEN; i++) {
191                 int k;
192
193                 if (isempty(info[i]) || !xattrs[i])
194                         continue;
195
196                 k = fsetxattr(fd, xattrs[i], info[i], strlen(info[i]), XATTR_CREATE);
197                 if (k < 0 && r == 0)
198                         r = -errno;
199         }
200
201         return r;
202 }
203
204 #define filename_escape(s) xescape((s), "./ ")
205
206 static int fix_permissions(
207                 int fd,
208                 const char *filename,
209                 const char *target,
210                 const char *info[_INFO_LEN],
211                 uid_t uid) {
212
213         assert(fd >= 0);
214         assert(filename);
215         assert(target);
216         assert(info);
217
218         /* Ignore errors on these */
219         fchmod(fd, 0640);
220         fix_acl(fd, uid);
221         fix_xattr(fd, info);
222
223         if (fsync(fd) < 0)
224                 return log_error_errno(errno, "Failed to sync coredump %s: %m", filename);
225
226         if (rename(filename, target) < 0)
227                 return log_error_errno(errno, "Failed to rename coredump %s -> %s: %m", filename, target);
228
229         return 0;
230 }
231
232 static int maybe_remove_external_coredump(const char *filename, off_t size) {
233
234         /* Returns 1 if might remove, 0 if will not remove, < 0 on error. */
235
236         if (IN_SET(arg_storage, COREDUMP_STORAGE_EXTERNAL, COREDUMP_STORAGE_BOTH) &&
237             size <= arg_external_size_max)
238                 return 0;
239
240         if (!filename)
241                 return 1;
242
243         if (unlink(filename) < 0 && errno != ENOENT)
244                 return log_error_errno(errno, "Failed to unlink %s: %m", filename);
245
246         return 1;
247 }
248
249 static int make_filename(const char *info[_INFO_LEN], char **ret) {
250         _cleanup_free_ char *c = NULL, *u = NULL, *p = NULL, *t = NULL;
251         sd_id128_t boot;
252         int r;
253
254         assert(info);
255
256         c = filename_escape(info[INFO_COMM]);
257         if (!c)
258                 return -ENOMEM;
259
260         u = filename_escape(info[INFO_UID]);
261         if (!u)
262                 return -ENOMEM;
263
264         r = sd_id128_get_boot(&boot);
265         if (r < 0)
266                 return r;
267
268         p = filename_escape(info[INFO_PID]);
269         if (!p)
270                 return -ENOMEM;
271
272         t = filename_escape(info[INFO_TIMESTAMP]);
273         if (!t)
274                 return -ENOMEM;
275
276         if (asprintf(ret,
277                      "/var/lib/systemd/coredump/core.%s.%s." SD_ID128_FORMAT_STR ".%s.%s000000",
278                      c,
279                      u,
280                      SD_ID128_FORMAT_VAL(boot),
281                      p,
282                      t) < 0)
283                 return -ENOMEM;
284
285         return 0;
286 }
287
288 static int save_external_coredump(
289                 const char *info[_INFO_LEN],
290                 uid_t uid,
291                 char **ret_filename,
292                 int *ret_fd,
293                 off_t *ret_size) {
294
295         _cleanup_free_ char *fn = NULL, *tmp = NULL;
296         _cleanup_close_ int fd = -1;
297         struct stat st;
298         int r;
299
300         assert(info);
301         assert(ret_filename);
302         assert(ret_fd);
303         assert(ret_size);
304
305         r = make_filename(info, &fn);
306         if (r < 0)
307                 return log_error_errno(r, "Failed to determine coredump file name: %m");
308
309         r = tempfn_random(fn, &tmp);
310         if (r < 0)
311                 return log_error_errno(r, "Failed to determine temporary file name: %m");
312
313         mkdir_p_label("/var/lib/systemd/coredump", 0755);
314
315         fd = open(tmp, O_CREAT|O_EXCL|O_RDWR|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0640);
316         if (fd < 0)
317                 return log_error_errno(errno, "Failed to create coredump file %s: %m", tmp);
318
319         r = copy_bytes(STDIN_FILENO, fd, arg_process_size_max);
320         if (r == -EFBIG) {
321                 log_error("Coredump of %s (%s) is larger than configured processing limit, refusing.", info[INFO_PID], info[INFO_COMM]);
322                 goto fail;
323         } else if (IN_SET(r, -EDQUOT, -ENOSPC)) {
324                 log_error("Not enough disk space for coredump of %s (%s), refusing.", info[INFO_PID], info[INFO_COMM]);
325                 goto fail;
326         } else if (r < 0) {
327                 log_error_errno(r, "Failed to dump coredump to file: %m");
328                 goto fail;
329         }
330
331         if (fstat(fd, &st) < 0) {
332                 log_error_errno(errno, "Failed to fstat coredump %s: %m", tmp);
333                 goto fail;
334         }
335
336         if (lseek(fd, 0, SEEK_SET) == (off_t) -1) {
337                 log_error_errno(errno, "Failed to seek on %s: %m", tmp);
338                 goto fail;
339         }
340
341 #if defined(HAVE_XZ) || defined(HAVE_LZ4)
342         /* If we will remove the coredump anyway, do not compress. */
343         if (maybe_remove_external_coredump(NULL, st.st_size) == 0
344             && arg_compress) {
345
346                 _cleanup_free_ char *fn_compressed = NULL, *tmp_compressed = NULL;
347                 _cleanup_close_ int fd_compressed = -1;
348
349                 fn_compressed = strappend(fn, COMPRESSED_EXT);
350                 if (!fn_compressed) {
351                         log_oom();
352                         goto uncompressed;
353                 }
354
355                 r = tempfn_random(fn_compressed, &tmp_compressed);
356                 if (r < 0) {
357                         log_error_errno(r, "Failed to determine temporary file name for %s: %m", fn_compressed);
358                         goto uncompressed;
359                 }
360
361                 fd_compressed = open(tmp_compressed, O_CREAT|O_EXCL|O_RDWR|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0640);
362                 if (fd_compressed < 0) {
363                         log_error_errno(errno, "Failed to create file %s: %m", tmp_compressed);
364                         goto uncompressed;
365                 }
366
367                 r = compress_stream(fd, fd_compressed, -1);
368                 if (r < 0) {
369                         log_error_errno(r, "Failed to compress %s: %m", tmp_compressed);
370                         goto fail_compressed;
371                 }
372
373                 r = fix_permissions(fd_compressed, tmp_compressed, fn_compressed, info, uid);
374                 if (r < 0)
375                         goto fail_compressed;
376
377                 /* OK, this worked, we can get rid of the uncompressed version now */
378                 unlink_noerrno(tmp);
379
380                 *ret_filename = fn_compressed;    /* compressed */
381                 *ret_fd = fd;                     /* uncompressed */
382                 *ret_size = st.st_size;           /* uncompressed */
383
384                 fn_compressed = NULL;
385                 fd = -1;
386
387                 return 0;
388
389         fail_compressed:
390                 unlink_noerrno(tmp_compressed);
391         }
392
393 uncompressed:
394 #endif
395         r = fix_permissions(fd, tmp, fn, info, uid);
396         if (r < 0)
397                 goto fail;
398
399         *ret_filename = fn;
400         *ret_fd = fd;
401         *ret_size = st.st_size;
402
403         fn = NULL;
404         fd = -1;
405
406         return 0;
407
408 fail:
409         unlink_noerrno(tmp);
410         return r;
411 }
412
413 static int allocate_journal_field(int fd, size_t size, char **ret, size_t *ret_size) {
414         _cleanup_free_ char *field = NULL;
415         ssize_t n;
416
417         assert(fd >= 0);
418         assert(ret);
419         assert(ret_size);
420
421         if (lseek(fd, 0, SEEK_SET) == (off_t) -1)
422                 return log_warning_errno(errno, "Failed to seek: %m");
423
424         field = malloc(9 + size);
425         if (!field) {
426                 log_warning("Failed to allocate memory for coredump, coredump will not be stored.");
427                 return -ENOMEM;
428         }
429
430         memcpy(field, "COREDUMP=", 9);
431
432         n = read(fd, field + 9, size);
433         if (n < 0)
434                 return log_error_errno((int) n, "Failed to read core data: %m");
435         if ((size_t) n < size) {
436                 log_error("Core data too short.");
437                 return -EIO;
438         }
439
440         *ret = field;
441         *ret_size = size + 9;
442
443         field = NULL;
444
445         return 0;
446 }
447
448 /* Joins /proc/[pid]/fd/ and /proc/[pid]/fdinfo/ into the following lines:
449  * 0:/dev/pts/23
450  * pos:    0
451  * flags:  0100002
452  *
453  * 1:/dev/pts/23
454  * pos:    0
455  * flags:  0100002
456  *
457  * 2:/dev/pts/23
458  * pos:    0
459  * flags:  0100002
460  * EOF
461  */
462 static int compose_open_fds(pid_t pid, char **open_fds) {
463         _cleanup_closedir_ DIR *proc_fd_dir = NULL;
464         _cleanup_close_ int proc_fdinfo_fd = -1;
465         _cleanup_free_ char *buffer = NULL;
466         _cleanup_fclose_ FILE *stream = NULL;
467         const char *fddelim = "", *path;
468         struct dirent *dent = NULL;
469         size_t size = 0;
470         int r = 0;
471
472         assert(pid >= 0);
473         assert(open_fds != NULL);
474
475         path = procfs_file_alloca(pid, "fd");
476         proc_fd_dir = opendir(path);
477         if (!proc_fd_dir)
478                 return -errno;
479
480         proc_fdinfo_fd = openat(dirfd(proc_fd_dir), "../fdinfo", O_DIRECTORY|O_NOFOLLOW|O_CLOEXEC|O_PATH);
481         if (proc_fdinfo_fd < 0)
482                 return -errno;
483
484         stream = open_memstream(&buffer, &size);
485         if (!stream)
486                 return -ENOMEM;
487
488         FOREACH_DIRENT(dent, proc_fd_dir, return -errno) {
489                 _cleanup_fclose_ FILE *fdinfo = NULL;
490                 _cleanup_free_ char *fdname = NULL;
491                 char line[LINE_MAX];
492                 int fd;
493
494                 r = readlinkat_malloc(dirfd(proc_fd_dir), dent->d_name, &fdname);
495                 if (r < 0)
496                         return r;
497
498                 fprintf(stream, "%s%s:%s\n", fddelim, dent->d_name, fdname);
499                 fddelim = "\n";
500
501                 /* Use the directory entry from /proc/[pid]/fd with /proc/[pid]/fdinfo */
502                 fd = openat(proc_fdinfo_fd, dent->d_name, O_NOFOLLOW|O_CLOEXEC|O_RDONLY);
503                 if (fd < 0)
504                         continue;
505
506                 fdinfo = fdopen(fd, "re");
507                 if (fdinfo == NULL) {
508                         close(fd);
509                         continue;
510                 }
511
512                 FOREACH_LINE(line, fdinfo, break) {
513                         fputs(line, stream);
514                         if (!endswith(line, "\n"))
515                                 fputc('\n', stream);
516                 }
517         }
518
519         errno = 0;
520         fclose(stream);
521         stream = NULL;
522
523         if (errno != 0)
524                 return -errno;
525
526         *open_fds = buffer;
527         buffer = NULL;
528
529         return 0;
530 }
531
532 int main(int argc, char* argv[]) {
533
534         /* The small core field we allocate on the stack, to keep things simple */
535         char
536                 *core_pid = NULL, *core_uid = NULL, *core_gid = NULL, *core_signal = NULL,
537                 *core_session = NULL, *core_exe = NULL, *core_comm = NULL, *core_cmdline = NULL,
538                 *core_cgroup = NULL, *core_cwd = NULL, *core_root = NULL, *core_unit = NULL,
539                 *core_slice = NULL;
540
541         /* The larger ones we allocate on the heap */
542         _cleanup_free_ char
543                 *core_timestamp = NULL,  *core_message = NULL, *coredump_data = NULL, *core_owner_uid = NULL,
544                 *core_open_fds = NULL, *core_proc_status = NULL, *core_proc_maps = NULL, *core_proc_limits = NULL,
545                 *core_proc_cgroup = NULL, *core_environ = NULL;
546
547         _cleanup_free_ char *exe = NULL, *comm = NULL, *filename = NULL;
548         const char *info[_INFO_LEN];
549
550         _cleanup_close_ int coredump_fd = -1;
551
552         struct iovec iovec[26];
553         off_t coredump_size;
554         int r, j = 0;
555         uid_t uid, owner_uid;
556         gid_t gid;
557         pid_t pid;
558         char *t;
559         const char *p;
560
561         /* Make sure we never enter a loop */
562         prctl(PR_SET_DUMPABLE, 0);
563
564         /* First, log to a safe place, since we don't know what
565          * crashed and it might be journald which we'd rather not log
566          * to then. */
567         log_set_target(LOG_TARGET_KMSG);
568         log_open();
569
570         if (argc < INFO_COMM + 1) {
571                 log_error("Not enough arguments passed from kernel (%d, expected %d).",
572                           argc - 1, INFO_COMM + 1 - 1);
573                 r = -EINVAL;
574                 goto finish;
575         }
576
577         /* Ignore all parse errors */
578         parse_config();
579
580         log_debug("Selected storage '%s'.", coredump_storage_to_string(arg_storage));
581         log_debug("Selected compression %s.", yes_no(arg_compress));
582
583         r = parse_uid(argv[INFO_UID + 1], &uid);
584         if (r < 0) {
585                 log_error("Failed to parse UID.");
586                 goto finish;
587         }
588
589         r = parse_pid(argv[INFO_PID + 1], &pid);
590         if (r < 0) {
591                 log_error("Failed to parse PID.");
592                 goto finish;
593         }
594
595         r = parse_gid(argv[INFO_GID + 1], &gid);
596         if (r < 0) {
597                 log_error("Failed to parse GID.");
598                 goto finish;
599         }
600
601         if (get_process_comm(pid, &comm) < 0) {
602                 log_warning("Failed to get COMM, falling back to the command line.");
603                 comm = strv_join(argv + INFO_COMM + 1, " ");
604         }
605
606         if (get_process_exe(pid, &exe) < 0)
607                 log_warning("Failed to get EXE.");
608
609         info[INFO_PID] = argv[INFO_PID + 1];
610         info[INFO_UID] = argv[INFO_UID + 1];
611         info[INFO_GID] = argv[INFO_GID + 1];
612         info[INFO_SIGNAL] = argv[INFO_SIGNAL + 1];
613         info[INFO_TIMESTAMP] = argv[INFO_TIMESTAMP + 1];
614         info[INFO_COMM] = comm;
615         info[INFO_EXE] = exe;
616
617         if (cg_pid_get_unit(pid, &t) >= 0) {
618
619                 if (streq(t, SPECIAL_JOURNALD_SERVICE)) {
620                         free(t);
621
622                         /* If we are journald, we cut things short,
623                          * don't write to the journal, but still
624                          * create a coredump. */
625
626                         if (arg_storage != COREDUMP_STORAGE_NONE)
627                                 arg_storage = COREDUMP_STORAGE_EXTERNAL;
628
629                         r = save_external_coredump(info, uid, &filename, &coredump_fd, &coredump_size);
630                         if (r < 0)
631                                 goto finish;
632
633                         r = maybe_remove_external_coredump(filename, coredump_size);
634                         if (r < 0)
635                                 goto finish;
636
637                         log_info("Detected coredump of the journal daemon itself, diverted to %s.", filename);
638                         goto finish;
639                 }
640
641                 core_unit = strappenda("COREDUMP_UNIT=", t);
642                 free(t);
643
644         } else if (cg_pid_get_user_unit(pid, &t) >= 0) {
645                 core_unit = strappenda("COREDUMP_USER_UNIT=", t);
646                 free(t);
647         }
648
649         if (core_unit)
650                 IOVEC_SET_STRING(iovec[j++], core_unit);
651
652         /* OK, now we know it's not the journal, hence we can make use
653          * of it now. */
654         log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
655         log_open();
656
657         core_pid = strappenda("COREDUMP_PID=", info[INFO_PID]);
658         IOVEC_SET_STRING(iovec[j++], core_pid);
659
660         core_uid = strappenda("COREDUMP_UID=", info[INFO_UID]);
661         IOVEC_SET_STRING(iovec[j++], core_uid);
662
663         core_gid = strappenda("COREDUMP_GID=", info[INFO_GID]);
664         IOVEC_SET_STRING(iovec[j++], core_gid);
665
666         core_signal = strappenda("COREDUMP_SIGNAL=", info[INFO_SIGNAL]);
667         IOVEC_SET_STRING(iovec[j++], core_signal);
668
669         if (sd_pid_get_session(pid, &t) >= 0) {
670                 core_session = strappenda("COREDUMP_SESSION=", t);
671                 free(t);
672
673                 IOVEC_SET_STRING(iovec[j++], core_session);
674         }
675
676         if (sd_pid_get_owner_uid(pid, &owner_uid) >= 0) {
677                 r = asprintf(&core_owner_uid,
678                              "COREDUMP_OWNER_UID=" UID_FMT, owner_uid);
679                 if (r > 0)
680                         IOVEC_SET_STRING(iovec[j++], core_owner_uid);
681         }
682
683         if (sd_pid_get_slice(pid, &t) >= 0) {
684                 core_slice = strappenda("COREDUMP_SLICE=", t);
685                 free(t);
686
687                 IOVEC_SET_STRING(iovec[j++], core_slice);
688         }
689
690         if (comm) {
691                 core_comm = strappenda("COREDUMP_COMM=", comm);
692                 IOVEC_SET_STRING(iovec[j++], core_comm);
693         }
694
695         if (exe) {
696                 core_exe = strappenda("COREDUMP_EXE=", exe);
697                 IOVEC_SET_STRING(iovec[j++], core_exe);
698         }
699
700         if (get_process_cmdline(pid, 0, false, &t) >= 0) {
701                 core_cmdline = strappenda("COREDUMP_CMDLINE=", t);
702                 free(t);
703
704                 IOVEC_SET_STRING(iovec[j++], core_cmdline);
705         }
706
707         if (cg_pid_get_path_shifted(pid, NULL, &t) >= 0) {
708                 core_cgroup = strappenda("COREDUMP_CGROUP=", t);
709                 free(t);
710
711                 IOVEC_SET_STRING(iovec[j++], core_cgroup);
712         }
713
714         if (compose_open_fds(pid, &t) >= 0) {
715                 core_open_fds = strappend("COREDUMP_OPEN_FDS=", t);
716                 free(t);
717
718                 if (core_open_fds)
719                         IOVEC_SET_STRING(iovec[j++], core_open_fds);
720         }
721
722         p = procfs_file_alloca(pid, "status");
723         if (read_full_file(p, &t, NULL) >= 0) {
724                 core_proc_status = strappend("COREDUMP_PROC_STATUS=", t);
725                 free(t);
726
727                 if (core_proc_status)
728                         IOVEC_SET_STRING(iovec[j++], core_proc_status);
729         }
730
731         p = procfs_file_alloca(pid, "maps");
732         if (read_full_file(p, &t, NULL) >= 0) {
733                 core_proc_maps = strappend("COREDUMP_PROC_MAPS=", t);
734                 free(t);
735
736                 if (core_proc_maps)
737                         IOVEC_SET_STRING(iovec[j++], core_proc_maps);
738         }
739
740         p = procfs_file_alloca(pid, "limits");
741         if (read_full_file(p, &t, NULL) >= 0) {
742                 core_proc_limits = strappend("COREDUMP_PROC_LIMITS=", t);
743                 free(t);
744
745                 if (core_proc_limits)
746                         IOVEC_SET_STRING(iovec[j++], core_proc_limits);
747         }
748
749         p = procfs_file_alloca(pid, "cgroup");
750         if (read_full_file(p, &t, NULL) >=0) {
751                 core_proc_cgroup = strappend("COREDUMP_PROC_CGROUP=", t);
752                 free(t);
753
754                 if (core_proc_cgroup)
755                         IOVEC_SET_STRING(iovec[j++], core_proc_cgroup);
756         }
757
758         if (get_process_cwd(pid, &t) >= 0) {
759                 core_cwd = strappenda("COREDUMP_CWD=", t);
760                 free(t);
761
762                 IOVEC_SET_STRING(iovec[j++], core_cwd);
763         }
764
765         if (get_process_root(pid, &t) >= 0) {
766                 core_root = strappenda("COREDUMP_ROOT=", t);
767                 free(t);
768
769                 IOVEC_SET_STRING(iovec[j++], core_root);
770         }
771
772         if (get_process_environ(pid, &t) >= 0) {
773                 core_environ = strappend("COREDUMP_ENVIRON=", t);
774                 free(t);
775
776                 if (core_environ)
777                         IOVEC_SET_STRING(iovec[j++], core_environ);
778         }
779
780         core_timestamp = strjoin("COREDUMP_TIMESTAMP=", info[INFO_TIMESTAMP], "000000", NULL);
781         if (core_timestamp)
782                 IOVEC_SET_STRING(iovec[j++], core_timestamp);
783
784         IOVEC_SET_STRING(iovec[j++], "MESSAGE_ID=fc2e22bc6ee647b6b90729ab34a250b1");
785         IOVEC_SET_STRING(iovec[j++], "PRIORITY=2");
786
787         /* Vacuum before we write anything again */
788         coredump_vacuum(-1, arg_keep_free, arg_max_use);
789
790         /* Always stream the coredump to disk, if that's possible */
791         r = save_external_coredump(info, uid, &filename, &coredump_fd, &coredump_size);
792         if (r < 0)
793                 /* skip whole core dumping part */
794                 goto log;
795
796         /* If we don't want to keep the coredump on disk, remove it
797          * now, as later on we will lack the privileges for
798          * it. However, we keep the fd to it, so that we can still
799          * process it and log it. */
800         r = maybe_remove_external_coredump(filename, coredump_size);
801         if (r < 0)
802                 goto finish;
803         if (r == 0) {
804                 const char *coredump_filename;
805
806                 coredump_filename = strappenda("COREDUMP_FILENAME=", filename);
807                 IOVEC_SET_STRING(iovec[j++], coredump_filename);
808         }
809
810         /* Vacuum again, but exclude the coredump we just created */
811         coredump_vacuum(coredump_fd, arg_keep_free, arg_max_use);
812
813         /* Now, let's drop privileges to become the user who owns the
814          * segfaulted process and allocate the coredump memory under
815          * the user's uid. This also ensures that the credentials
816          * journald will see are the ones of the coredumping user,
817          * thus making sure the user gets access to the core dump. */
818         if (setresgid(gid, gid, gid) < 0 ||
819             setresuid(uid, uid, uid) < 0) {
820                 log_error_errno(errno, "Failed to drop privileges: %m");
821                 r = -errno;
822                 goto finish;
823         }
824
825 #ifdef HAVE_ELFUTILS
826         /* Try to get a strack trace if we can */
827         if (coredump_size <= arg_process_size_max) {
828                 _cleanup_free_ char *stacktrace = NULL;
829
830                 r = coredump_make_stack_trace(coredump_fd, exe, &stacktrace);
831                 if (r >= 0)
832                         core_message = strjoin("MESSAGE=Process ", info[INFO_PID], " (", comm, ") of user ", info[INFO_UID], " dumped core.\n\n", stacktrace, NULL);
833                 else if (r == -EINVAL)
834                         log_warning("Failed to generate stack trace: %s", dwfl_errmsg(dwfl_errno()));
835                 else
836                         log_warning_errno(r, "Failed to generate stack trace: %m");
837         }
838
839         if (!core_message)
840 #endif
841 log:
842         core_message = strjoin("MESSAGE=Process ", info[INFO_PID], " (", comm, ") of user ", info[INFO_UID], " dumped core.", NULL);
843         if (core_message)
844                 IOVEC_SET_STRING(iovec[j++], core_message);
845
846         /* Optionally store the entire coredump in the journal */
847         if (IN_SET(arg_storage, COREDUMP_STORAGE_JOURNAL, COREDUMP_STORAGE_BOTH) &&
848             coredump_size <= (off_t) arg_journal_size_max) {
849                 size_t sz;
850
851                 /* Store the coredump itself in the journal */
852
853                 r = allocate_journal_field(coredump_fd, (size_t) coredump_size, &coredump_data, &sz);
854                 if (r >= 0) {
855                         iovec[j].iov_base = coredump_data;
856                         iovec[j].iov_len = sz;
857                         j++;
858                 }
859         }
860
861         r = sd_journal_sendv(iovec, j);
862         if (r < 0)
863                 log_error_errno(r, "Failed to log coredump: %m");
864
865 finish:
866         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
867 }