]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/coredump/coredump.c
Merge pull request #4115 from yuwata/completion-fix
[thirdparty/systemd.git] / src / coredump / coredump.c
1 /***
2 This file is part of systemd.
3
4 Copyright 2012 Lennart Poettering
5
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.
10
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.
15
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/>.
18 ***/
19
20 #include <errno.h>
21 #include <stdio.h>
22 #include <sys/prctl.h>
23 #include <sys/xattr.h>
24 #include <unistd.h>
25
26 #ifdef HAVE_ELFUTILS
27 #include <dwarf.h>
28 #include <elfutils/libdwfl.h>
29 #endif
30
31 #include "sd-daemon.h"
32 #include "sd-journal.h"
33 #include "sd-login.h"
34 #include "sd-messages.h"
35
36 #include "acl-util.h"
37 #include "alloc-util.h"
38 #include "capability-util.h"
39 #include "cgroup-util.h"
40 #include "compress.h"
41 #include "conf-parser.h"
42 #include "copy.h"
43 #include "coredump-vacuum.h"
44 #include "dirent-util.h"
45 #include "escape.h"
46 #include "fd-util.h"
47 #include "fileio.h"
48 #include "fs-util.h"
49 #include "io-util.h"
50 #include "journald-native.h"
51 #include "log.h"
52 #include "macro.h"
53 #include "missing.h"
54 #include "mkdir.h"
55 #include "parse-util.h"
56 #include "process-util.h"
57 #include "socket-util.h"
58 #include "special.h"
59 #include "stacktrace.h"
60 #include "string-table.h"
61 #include "string-util.h"
62 #include "strv.h"
63 #include "user-util.h"
64 #include "util.h"
65
66 /* The maximum size up to which we process coredumps */
67 #define PROCESS_SIZE_MAX ((uint64_t) (2LLU*1024LLU*1024LLU*1024LLU))
68
69 /* The maximum size up to which we leave the coredump around on disk */
70 #define EXTERNAL_SIZE_MAX PROCESS_SIZE_MAX
71
72 /* The maximum size up to which we store the coredump in the journal */
73 #define JOURNAL_SIZE_MAX ((size_t) (767LU*1024LU*1024LU))
74
75 /* Make sure to not make this larger than the maximum journal entry
76 * size. See DATA_SIZE_MAX in journald-native.c. */
77 assert_cc(JOURNAL_SIZE_MAX <= DATA_SIZE_MAX);
78
79 enum {
80 /* We use this as array indexes for a couple of special fields we use for naming coredumping files, and
81 * attaching xattrs */
82 CONTEXT_PID,
83 CONTEXT_UID,
84 CONTEXT_GID,
85 CONTEXT_SIGNAL,
86 CONTEXT_TIMESTAMP,
87 CONTEXT_RLIMIT,
88 CONTEXT_COMM,
89 CONTEXT_EXE,
90 _CONTEXT_MAX
91 };
92
93 typedef enum CoredumpStorage {
94 COREDUMP_STORAGE_NONE,
95 COREDUMP_STORAGE_EXTERNAL,
96 COREDUMP_STORAGE_JOURNAL,
97 _COREDUMP_STORAGE_MAX,
98 _COREDUMP_STORAGE_INVALID = -1
99 } CoredumpStorage;
100
101 static const char* const coredump_storage_table[_COREDUMP_STORAGE_MAX] = {
102 [COREDUMP_STORAGE_NONE] = "none",
103 [COREDUMP_STORAGE_EXTERNAL] = "external",
104 [COREDUMP_STORAGE_JOURNAL] = "journal",
105 };
106
107 DEFINE_PRIVATE_STRING_TABLE_LOOKUP(coredump_storage, CoredumpStorage);
108 static DEFINE_CONFIG_PARSE_ENUM(config_parse_coredump_storage, coredump_storage, CoredumpStorage, "Failed to parse storage setting");
109
110 static CoredumpStorage arg_storage = COREDUMP_STORAGE_EXTERNAL;
111 static bool arg_compress = true;
112 static uint64_t arg_process_size_max = PROCESS_SIZE_MAX;
113 static uint64_t arg_external_size_max = EXTERNAL_SIZE_MAX;
114 static size_t arg_journal_size_max = JOURNAL_SIZE_MAX;
115 static uint64_t arg_keep_free = (uint64_t) -1;
116 static uint64_t arg_max_use = (uint64_t) -1;
117
118 static int parse_config(void) {
119 static const ConfigTableItem items[] = {
120 { "Coredump", "Storage", config_parse_coredump_storage, 0, &arg_storage },
121 { "Coredump", "Compress", config_parse_bool, 0, &arg_compress },
122 { "Coredump", "ProcessSizeMax", config_parse_iec_uint64, 0, &arg_process_size_max },
123 { "Coredump", "ExternalSizeMax", config_parse_iec_uint64, 0, &arg_external_size_max },
124 { "Coredump", "JournalSizeMax", config_parse_iec_size, 0, &arg_journal_size_max },
125 { "Coredump", "KeepFree", config_parse_iec_uint64, 0, &arg_keep_free },
126 { "Coredump", "MaxUse", config_parse_iec_uint64, 0, &arg_max_use },
127 {}
128 };
129
130 return config_parse_many_nulstr(PKGSYSCONFDIR "/coredump.conf",
131 CONF_PATHS_NULSTR("systemd/coredump.conf.d"),
132 "Coredump\0",
133 config_item_table_lookup, items,
134 false, NULL);
135 }
136
137 static inline uint64_t storage_size_max(void) {
138 return arg_storage == COREDUMP_STORAGE_EXTERNAL ? arg_external_size_max : arg_journal_size_max;
139 }
140
141 static int fix_acl(int fd, uid_t uid) {
142
143 #ifdef HAVE_ACL
144 _cleanup_(acl_freep) acl_t acl = NULL;
145 acl_entry_t entry;
146 acl_permset_t permset;
147 int r;
148
149 assert(fd >= 0);
150
151 if (uid <= SYSTEM_UID_MAX)
152 return 0;
153
154 /* Make sure normal users can read (but not write or delete)
155 * their own coredumps */
156
157 acl = acl_get_fd(fd);
158 if (!acl)
159 return log_error_errno(errno, "Failed to get ACL: %m");
160
161 if (acl_create_entry(&acl, &entry) < 0 ||
162 acl_set_tag_type(entry, ACL_USER) < 0 ||
163 acl_set_qualifier(entry, &uid) < 0)
164 return log_error_errno(errno, "Failed to patch ACL: %m");
165
166 if (acl_get_permset(entry, &permset) < 0 ||
167 acl_add_perm(permset, ACL_READ) < 0)
168 return log_warning_errno(errno, "Failed to patch ACL: %m");
169
170 r = calc_acl_mask_if_needed(&acl);
171 if (r < 0)
172 return log_warning_errno(r, "Failed to patch ACL: %m");
173
174 if (acl_set_fd(fd, acl) < 0)
175 return log_error_errno(errno, "Failed to apply ACL: %m");
176 #endif
177
178 return 0;
179 }
180
181 static int fix_xattr(int fd, const char *context[_CONTEXT_MAX]) {
182
183 static const char * const xattrs[_CONTEXT_MAX] = {
184 [CONTEXT_PID] = "user.coredump.pid",
185 [CONTEXT_UID] = "user.coredump.uid",
186 [CONTEXT_GID] = "user.coredump.gid",
187 [CONTEXT_SIGNAL] = "user.coredump.signal",
188 [CONTEXT_TIMESTAMP] = "user.coredump.timestamp",
189 [CONTEXT_COMM] = "user.coredump.comm",
190 [CONTEXT_EXE] = "user.coredump.exe",
191 };
192
193 int r = 0;
194 unsigned i;
195
196 assert(fd >= 0);
197
198 /* Attach some metadata to coredumps via extended
199 * attributes. Just because we can. */
200
201 for (i = 0; i < _CONTEXT_MAX; i++) {
202 int k;
203
204 if (isempty(context[i]) || !xattrs[i])
205 continue;
206
207 k = fsetxattr(fd, xattrs[i], context[i], strlen(context[i]), XATTR_CREATE);
208 if (k < 0 && r == 0)
209 r = -errno;
210 }
211
212 return r;
213 }
214
215 #define filename_escape(s) xescape((s), "./ ")
216
217 static inline const char *coredump_tmpfile_name(const char *s) {
218 return s ? s : "(unnamed temporary file)";
219 }
220
221 static int fix_permissions(
222 int fd,
223 const char *filename,
224 const char *target,
225 const char *context[_CONTEXT_MAX],
226 uid_t uid) {
227
228 int r;
229
230 assert(fd >= 0);
231 assert(target);
232 assert(context);
233
234 /* Ignore errors on these */
235 (void) fchmod(fd, 0640);
236 (void) fix_acl(fd, uid);
237 (void) fix_xattr(fd, context);
238
239 if (fsync(fd) < 0)
240 return log_error_errno(errno, "Failed to sync coredump %s: %m", coredump_tmpfile_name(filename));
241
242 r = link_tmpfile(fd, filename, target);
243 if (r < 0)
244 return log_error_errno(r, "Failed to move coredump %s into place: %m", target);
245
246 return 0;
247 }
248
249 static int maybe_remove_external_coredump(const char *filename, uint64_t size) {
250
251 /* Returns 1 if might remove, 0 if will not remove, < 0 on error. */
252
253 if (arg_storage == COREDUMP_STORAGE_EXTERNAL &&
254 size <= arg_external_size_max)
255 return 0;
256
257 if (!filename)
258 return 1;
259
260 if (unlink(filename) < 0 && errno != ENOENT)
261 return log_error_errno(errno, "Failed to unlink %s: %m", filename);
262
263 return 1;
264 }
265
266 static int make_filename(const char *context[_CONTEXT_MAX], char **ret) {
267 _cleanup_free_ char *c = NULL, *u = NULL, *p = NULL, *t = NULL;
268 sd_id128_t boot = {};
269 int r;
270
271 assert(context);
272
273 c = filename_escape(context[CONTEXT_COMM]);
274 if (!c)
275 return -ENOMEM;
276
277 u = filename_escape(context[CONTEXT_UID]);
278 if (!u)
279 return -ENOMEM;
280
281 r = sd_id128_get_boot(&boot);
282 if (r < 0)
283 return r;
284
285 p = filename_escape(context[CONTEXT_PID]);
286 if (!p)
287 return -ENOMEM;
288
289 t = filename_escape(context[CONTEXT_TIMESTAMP]);
290 if (!t)
291 return -ENOMEM;
292
293 if (asprintf(ret,
294 "/var/lib/systemd/coredump/core.%s.%s." SD_ID128_FORMAT_STR ".%s.%s000000",
295 c,
296 u,
297 SD_ID128_FORMAT_VAL(boot),
298 p,
299 t) < 0)
300 return -ENOMEM;
301
302 return 0;
303 }
304
305 static int save_external_coredump(
306 const char *context[_CONTEXT_MAX],
307 int input_fd,
308 char **ret_filename,
309 int *ret_node_fd,
310 int *ret_data_fd,
311 uint64_t *ret_size) {
312
313 _cleanup_free_ char *fn = NULL, *tmp = NULL;
314 _cleanup_close_ int fd = -1;
315 uint64_t rlimit, max_size;
316 struct stat st;
317 uid_t uid;
318 int r;
319
320 assert(context);
321 assert(ret_filename);
322 assert(ret_node_fd);
323 assert(ret_data_fd);
324 assert(ret_size);
325
326 r = parse_uid(context[CONTEXT_UID], &uid);
327 if (r < 0)
328 return log_error_errno(r, "Failed to parse UID: %m");
329
330 r = safe_atou64(context[CONTEXT_RLIMIT], &rlimit);
331 if (r < 0)
332 return log_error_errno(r, "Failed to parse resource limit: %s", context[CONTEXT_RLIMIT]);
333 if (rlimit < page_size()) {
334 /* Is coredumping disabled? Then don't bother saving/processing the coredump.
335 * Anything below PAGE_SIZE cannot give a readable coredump (the kernel uses
336 * ELF_EXEC_PAGESIZE which is not easily accessible, but is usually the same as PAGE_SIZE. */
337 log_info("Resource limits disable core dumping for process %s (%s).",
338 context[CONTEXT_PID], context[CONTEXT_COMM]);
339 return -EBADSLT;
340 }
341
342 /* Never store more than the process configured, or than we actually shall keep or process */
343 max_size = MIN(rlimit, MAX(arg_process_size_max, storage_size_max()));
344
345 r = make_filename(context, &fn);
346 if (r < 0)
347 return log_error_errno(r, "Failed to determine coredump file name: %m");
348
349 mkdir_p_label("/var/lib/systemd/coredump", 0755);
350
351 fd = open_tmpfile_linkable(fn, O_RDWR|O_CLOEXEC, &tmp);
352 if (fd < 0)
353 return log_error_errno(fd, "Failed to create temporary file for coredump %s: %m", fn);
354
355 r = copy_bytes(input_fd, fd, max_size, false);
356 if (r < 0) {
357 log_error_errno(r, "Cannot store coredump of %s (%s): %m", context[CONTEXT_PID], context[CONTEXT_COMM]);
358 goto fail;
359 } else if (r == 1)
360 log_struct(LOG_INFO,
361 LOG_MESSAGE("Core file was truncated to %zu bytes.", max_size),
362 "SIZE_LIMIT=%zu", max_size,
363 LOG_MESSAGE_ID(SD_MESSAGE_TRUNCATED_CORE),
364 NULL);
365
366 if (fstat(fd, &st) < 0) {
367 log_error_errno(errno, "Failed to fstat core file %s: %m", coredump_tmpfile_name(tmp));
368 goto fail;
369 }
370
371 if (lseek(fd, 0, SEEK_SET) == (off_t) -1) {
372 log_error_errno(errno, "Failed to seek on %s: %m", coredump_tmpfile_name(tmp));
373 goto fail;
374 }
375
376 #if defined(HAVE_XZ) || defined(HAVE_LZ4)
377 /* If we will remove the coredump anyway, do not compress. */
378 if (arg_compress && !maybe_remove_external_coredump(NULL, st.st_size)) {
379
380 _cleanup_free_ char *fn_compressed = NULL, *tmp_compressed = NULL;
381 _cleanup_close_ int fd_compressed = -1;
382
383 fn_compressed = strappend(fn, COMPRESSED_EXT);
384 if (!fn_compressed) {
385 log_oom();
386 goto uncompressed;
387 }
388
389 fd_compressed = open_tmpfile_linkable(fn_compressed, O_RDWR|O_CLOEXEC, &tmp_compressed);
390 if (fd_compressed < 0) {
391 log_error_errno(fd_compressed, "Failed to create temporary file for coredump %s: %m", fn_compressed);
392 goto uncompressed;
393 }
394
395 r = compress_stream(fd, fd_compressed, -1);
396 if (r < 0) {
397 log_error_errno(r, "Failed to compress %s: %m", coredump_tmpfile_name(tmp_compressed));
398 goto fail_compressed;
399 }
400
401 r = fix_permissions(fd_compressed, tmp_compressed, fn_compressed, context, uid);
402 if (r < 0)
403 goto fail_compressed;
404
405 /* OK, this worked, we can get rid of the uncompressed version now */
406 if (tmp)
407 unlink_noerrno(tmp);
408
409 *ret_filename = fn_compressed; /* compressed */
410 *ret_node_fd = fd_compressed; /* compressed */
411 *ret_data_fd = fd; /* uncompressed */
412 *ret_size = (uint64_t) st.st_size; /* uncompressed */
413
414 fn_compressed = NULL;
415 fd = fd_compressed = -1;
416
417 return 0;
418
419 fail_compressed:
420 if (tmp_compressed)
421 (void) unlink(tmp_compressed);
422 }
423
424 uncompressed:
425 #endif
426
427 r = fix_permissions(fd, tmp, fn, context, uid);
428 if (r < 0)
429 goto fail;
430
431 *ret_filename = fn;
432 *ret_data_fd = fd;
433 *ret_node_fd = -1;
434 *ret_size = (uint64_t) st.st_size;
435
436 fn = NULL;
437 fd = -1;
438
439 return 0;
440
441 fail:
442 if (tmp)
443 (void) unlink(tmp);
444 return r;
445 }
446
447 static int allocate_journal_field(int fd, size_t size, char **ret, size_t *ret_size) {
448 _cleanup_free_ char *field = NULL;
449 ssize_t n;
450
451 assert(fd >= 0);
452 assert(ret);
453 assert(ret_size);
454
455 if (lseek(fd, 0, SEEK_SET) == (off_t) -1)
456 return log_warning_errno(errno, "Failed to seek: %m");
457
458 field = malloc(9 + size);
459 if (!field) {
460 log_warning("Failed to allocate memory for coredump, coredump will not be stored.");
461 return -ENOMEM;
462 }
463
464 memcpy(field, "COREDUMP=", 9);
465
466 n = read(fd, field + 9, size);
467 if (n < 0)
468 return log_error_errno((int) n, "Failed to read core data: %m");
469 if ((size_t) n < size) {
470 log_error("Core data too short.");
471 return -EIO;
472 }
473
474 *ret = field;
475 *ret_size = size + 9;
476
477 field = NULL;
478
479 return 0;
480 }
481
482 /* Joins /proc/[pid]/fd/ and /proc/[pid]/fdinfo/ into the following lines:
483 * 0:/dev/pts/23
484 * pos: 0
485 * flags: 0100002
486 *
487 * 1:/dev/pts/23
488 * pos: 0
489 * flags: 0100002
490 *
491 * 2:/dev/pts/23
492 * pos: 0
493 * flags: 0100002
494 * EOF
495 */
496 static int compose_open_fds(pid_t pid, char **open_fds) {
497 _cleanup_closedir_ DIR *proc_fd_dir = NULL;
498 _cleanup_close_ int proc_fdinfo_fd = -1;
499 _cleanup_free_ char *buffer = NULL;
500 _cleanup_fclose_ FILE *stream = NULL;
501 const char *fddelim = "", *path;
502 struct dirent *dent = NULL;
503 size_t size = 0;
504 int r = 0;
505
506 assert(pid >= 0);
507 assert(open_fds != NULL);
508
509 path = procfs_file_alloca(pid, "fd");
510 proc_fd_dir = opendir(path);
511 if (!proc_fd_dir)
512 return -errno;
513
514 proc_fdinfo_fd = openat(dirfd(proc_fd_dir), "../fdinfo", O_DIRECTORY|O_NOFOLLOW|O_CLOEXEC|O_PATH);
515 if (proc_fdinfo_fd < 0)
516 return -errno;
517
518 stream = open_memstream(&buffer, &size);
519 if (!stream)
520 return -ENOMEM;
521
522 FOREACH_DIRENT(dent, proc_fd_dir, return -errno) {
523 _cleanup_fclose_ FILE *fdinfo = NULL;
524 _cleanup_free_ char *fdname = NULL;
525 char line[LINE_MAX];
526 int fd;
527
528 r = readlinkat_malloc(dirfd(proc_fd_dir), dent->d_name, &fdname);
529 if (r < 0)
530 return r;
531
532 fprintf(stream, "%s%s:%s\n", fddelim, dent->d_name, fdname);
533 fddelim = "\n";
534
535 /* Use the directory entry from /proc/[pid]/fd with /proc/[pid]/fdinfo */
536 fd = openat(proc_fdinfo_fd, dent->d_name, O_NOFOLLOW|O_CLOEXEC|O_RDONLY);
537 if (fd < 0)
538 continue;
539
540 fdinfo = fdopen(fd, "re");
541 if (fdinfo == NULL) {
542 close(fd);
543 continue;
544 }
545
546 FOREACH_LINE(line, fdinfo, break) {
547 fputs(line, stream);
548 if (!endswith(line, "\n"))
549 fputc('\n', stream);
550 }
551 }
552
553 errno = 0;
554 stream = safe_fclose(stream);
555
556 if (errno > 0)
557 return -errno;
558
559 *open_fds = buffer;
560 buffer = NULL;
561
562 return 0;
563 }
564
565 static int get_process_ns(pid_t pid, const char *namespace, ino_t *ns) {
566 const char *p;
567 struct stat stbuf;
568 _cleanup_close_ int proc_ns_dir_fd;
569
570 p = procfs_file_alloca(pid, "ns");
571
572 proc_ns_dir_fd = open(p, O_DIRECTORY | O_CLOEXEC | O_RDONLY);
573 if (proc_ns_dir_fd < 0)
574 return -errno;
575
576 if (fstatat(proc_ns_dir_fd, namespace, &stbuf, /* flags */0) < 0)
577 return -errno;
578
579 *ns = stbuf.st_ino;
580 return 0;
581 }
582
583 static int get_mount_namespace_leader(pid_t pid, pid_t *container_pid) {
584 pid_t cpid = pid, ppid = 0;
585 ino_t proc_mntns;
586 int r = 0;
587
588 r = get_process_ns(pid, "mnt", &proc_mntns);
589 if (r < 0)
590 return r;
591
592 while (1) {
593 ino_t parent_mntns;
594
595 r = get_process_ppid(cpid, &ppid);
596 if (r < 0)
597 return r;
598
599 r = get_process_ns(ppid, "mnt", &parent_mntns);
600 if (r < 0)
601 return r;
602
603 if (proc_mntns != parent_mntns)
604 break;
605
606 if (ppid == 1)
607 return -ENOENT;
608
609 cpid = ppid;
610 }
611
612 *container_pid = ppid;
613 return 0;
614 }
615
616 /* Returns 1 if the parent was found.
617 * Returns 0 if there is not a process we can call the pid's
618 * container parent (the pid's process isn't 'containerized').
619 * Returns a negative number on errors.
620 */
621 static int get_process_container_parent_cmdline(pid_t pid, char** cmdline) {
622 int r = 0;
623 pid_t container_pid;
624 const char *proc_root_path;
625 struct stat root_stat, proc_root_stat;
626
627 /* To compare inodes of / and /proc/[pid]/root */
628 if (stat("/", &root_stat) < 0)
629 return -errno;
630
631 proc_root_path = procfs_file_alloca(pid, "root");
632 if (stat(proc_root_path, &proc_root_stat) < 0)
633 return -errno;
634
635 /* The process uses system root. */
636 if (proc_root_stat.st_ino == root_stat.st_ino) {
637 *cmdline = NULL;
638 return 0;
639 }
640
641 r = get_mount_namespace_leader(pid, &container_pid);
642 if (r < 0)
643 return r;
644
645 return get_process_cmdline(container_pid, 0, false, cmdline);
646 }
647
648 static int change_uid_gid(const char *context[]) {
649 uid_t uid;
650 gid_t gid;
651 int r;
652
653 r = parse_uid(context[CONTEXT_UID], &uid);
654 if (r < 0)
655 return r;
656
657 if (uid <= SYSTEM_UID_MAX) {
658 const char *user = "systemd-coredump";
659
660 r = get_user_creds(&user, &uid, &gid, NULL, NULL);
661 if (r < 0) {
662 log_warning_errno(r, "Cannot resolve %s user. Proceeding to dump core as root: %m", user);
663 uid = gid = 0;
664 }
665 } else {
666 r = parse_gid(context[CONTEXT_GID], &gid);
667 if (r < 0)
668 return r;
669 }
670
671 return drop_privileges(uid, gid, 0);
672 }
673
674 static int submit_coredump(
675 const char *context[_CONTEXT_MAX],
676 struct iovec *iovec,
677 size_t n_iovec_allocated,
678 size_t n_iovec,
679 int input_fd) {
680
681 _cleanup_close_ int coredump_fd = -1, coredump_node_fd = -1;
682 _cleanup_free_ char *core_message = NULL, *filename = NULL, *coredump_data = NULL;
683 uint64_t coredump_size = UINT64_MAX;
684 int r;
685
686 assert(context);
687 assert(iovec);
688 assert(n_iovec_allocated >= n_iovec + 3);
689 assert(input_fd >= 0);
690
691 /* Vacuum before we write anything again */
692 (void) coredump_vacuum(-1, arg_keep_free, arg_max_use);
693
694 /* Always stream the coredump to disk, if that's possible */
695 r = save_external_coredump(context, input_fd, &filename, &coredump_node_fd, &coredump_fd, &coredump_size);
696 if (r < 0)
697 /* Skip whole core dumping part */
698 goto log;
699
700 /* If we don't want to keep the coredump on disk, remove it now, as later on we will lack the privileges for
701 * it. However, we keep the fd to it, so that we can still process it and log it. */
702 r = maybe_remove_external_coredump(filename, coredump_size);
703 if (r < 0)
704 return r;
705 if (r == 0) {
706 const char *coredump_filename;
707
708 coredump_filename = strjoina("COREDUMP_FILENAME=", filename);
709 IOVEC_SET_STRING(iovec[n_iovec++], coredump_filename);
710 } else if (arg_storage == COREDUMP_STORAGE_EXTERNAL)
711 log_info("The core will not be stored: size %zu is greater than %zu (the configured maximum)",
712 coredump_size, arg_external_size_max);
713
714 /* Vacuum again, but exclude the coredump we just created */
715 (void) coredump_vacuum(coredump_node_fd >= 0 ? coredump_node_fd : coredump_fd, arg_keep_free, arg_max_use);
716
717 /* Now, let's drop privileges to become the user who owns the segfaulted process and allocate the coredump
718 * memory under the user's uid. This also ensures that the credentials journald will see are the ones of the
719 * coredumping user, thus making sure the user gets access to the core dump. Let's also get rid of all
720 * capabilities, if we run as root, we won't need them anymore. */
721 r = change_uid_gid(context);
722 if (r < 0)
723 return log_error_errno(r, "Failed to drop privileges: %m");
724
725 #ifdef HAVE_ELFUTILS
726 /* Try to get a strack trace if we can */
727 if (coredump_size <= arg_process_size_max) {
728 _cleanup_free_ char *stacktrace = NULL;
729
730 r = coredump_make_stack_trace(coredump_fd, context[CONTEXT_EXE], &stacktrace);
731 if (r >= 0)
732 core_message = strjoin("MESSAGE=Process ", context[CONTEXT_PID], " (", context[CONTEXT_COMM], ") of user ", context[CONTEXT_UID], " dumped core.\n\n", stacktrace, NULL);
733 else if (r == -EINVAL)
734 log_warning("Failed to generate stack trace: %s", dwfl_errmsg(dwfl_errno()));
735 else
736 log_warning_errno(r, "Failed to generate stack trace: %m");
737 } else
738 log_debug("Not generating stack trace: core size %zu is greater than %zu (the configured maximum)",
739 coredump_size, arg_process_size_max);
740
741 if (!core_message)
742 #endif
743 log:
744 core_message = strjoin("MESSAGE=Process ", context[CONTEXT_PID], " (", context[CONTEXT_COMM], ") of user ", context[CONTEXT_UID], " dumped core.", NULL);
745 if (core_message)
746 IOVEC_SET_STRING(iovec[n_iovec++], core_message);
747
748 /* Optionally store the entire coredump in the journal */
749 if (arg_storage == COREDUMP_STORAGE_JOURNAL) {
750 if (coredump_size <= arg_journal_size_max) {
751 size_t sz = 0;
752
753 /* Store the coredump itself in the journal */
754
755 r = allocate_journal_field(coredump_fd, (size_t) coredump_size, &coredump_data, &sz);
756 if (r >= 0) {
757 iovec[n_iovec].iov_base = coredump_data;
758 iovec[n_iovec].iov_len = sz;
759 n_iovec++;
760 } else
761 log_warning_errno(r, "Failed to attach the core to the journal entry: %m");
762 } else
763 log_info("The core will not be stored: size %zu is greater than %zu (the configured maximum)",
764 coredump_size, arg_journal_size_max);
765 }
766
767 assert(n_iovec <= n_iovec_allocated);
768
769 r = sd_journal_sendv(iovec, n_iovec);
770 if (r < 0)
771 return log_error_errno(r, "Failed to log coredump: %m");
772
773 return 0;
774 }
775
776 static void map_context_fields(const struct iovec *iovec, const char *context[]) {
777
778 static const char * const context_field_names[_CONTEXT_MAX] = {
779 [CONTEXT_PID] = "COREDUMP_PID=",
780 [CONTEXT_UID] = "COREDUMP_UID=",
781 [CONTEXT_GID] = "COREDUMP_GID=",
782 [CONTEXT_SIGNAL] = "COREDUMP_SIGNAL=",
783 [CONTEXT_TIMESTAMP] = "COREDUMP_TIMESTAMP=",
784 [CONTEXT_COMM] = "COREDUMP_COMM=",
785 [CONTEXT_EXE] = "COREDUMP_EXE=",
786 [CONTEXT_RLIMIT] = "COREDUMP_RLIMIT=",
787 };
788
789 unsigned i;
790
791 assert(iovec);
792 assert(context);
793
794 for (i = 0; i < _CONTEXT_MAX; i++) {
795 size_t l;
796
797 l = strlen(context_field_names[i]);
798 if (iovec->iov_len < l)
799 continue;
800
801 if (memcmp(iovec->iov_base, context_field_names[i], l) != 0)
802 continue;
803
804 /* Note that these strings are NUL terminated, because we made sure that a trailing NUL byte is in the
805 * buffer, though not included in the iov_len count. (see below) */
806 context[i] = (char*) iovec->iov_base + l;
807 break;
808 }
809 }
810
811 static int process_socket(int fd) {
812 _cleanup_close_ int coredump_fd = -1;
813 struct iovec *iovec = NULL;
814 size_t n_iovec = 0, n_iovec_allocated = 0, i;
815 const char *context[_CONTEXT_MAX] = {};
816 int r;
817
818 assert(fd >= 0);
819
820 log_set_target(LOG_TARGET_AUTO);
821 log_parse_environment();
822 log_open();
823
824 for (;;) {
825 union {
826 struct cmsghdr cmsghdr;
827 uint8_t buf[CMSG_SPACE(sizeof(int))];
828 } control = {};
829 struct msghdr mh = {
830 .msg_control = &control,
831 .msg_controllen = sizeof(control),
832 .msg_iovlen = 1,
833 };
834 ssize_t n;
835 ssize_t l;
836
837 if (!GREEDY_REALLOC(iovec, n_iovec_allocated, n_iovec + 3)) {
838 r = log_oom();
839 goto finish;
840 }
841
842 l = next_datagram_size_fd(fd);
843 if (l < 0) {
844 r = log_error_errno(l, "Failed to determine datagram size to read: %m");
845 goto finish;
846 }
847
848 assert(l >= 0);
849
850 iovec[n_iovec].iov_len = l;
851 iovec[n_iovec].iov_base = malloc(l + 1);
852 if (!iovec[n_iovec].iov_base) {
853 r = log_oom();
854 goto finish;
855 }
856
857 mh.msg_iov = iovec + n_iovec;
858
859 n = recvmsg(fd, &mh, MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
860 if (n < 0) {
861 free(iovec[n_iovec].iov_base);
862 r = log_error_errno(errno, "Failed to receive datagram: %m");
863 goto finish;
864 }
865
866 if (n == 0) {
867 struct cmsghdr *cmsg, *found = NULL;
868 /* The final zero-length datagram carries the file descriptor and tells us that we're done. */
869
870 free(iovec[n_iovec].iov_base);
871
872 CMSG_FOREACH(cmsg, &mh) {
873 if (cmsg->cmsg_level == SOL_SOCKET &&
874 cmsg->cmsg_type == SCM_RIGHTS &&
875 cmsg->cmsg_len == CMSG_LEN(sizeof(int))) {
876 assert(!found);
877 found = cmsg;
878 }
879 }
880
881 if (!found) {
882 log_error("Coredump file descriptor missing.");
883 r = -EBADMSG;
884 goto finish;
885 }
886
887 assert(coredump_fd < 0);
888 coredump_fd = *(int*) CMSG_DATA(found);
889 break;
890 }
891
892 /* Add trailing NUL byte, in case these are strings */
893 ((char*) iovec[n_iovec].iov_base)[n] = 0;
894 iovec[n_iovec].iov_len = (size_t) n;
895
896 cmsg_close_all(&mh);
897 map_context_fields(iovec + n_iovec, context);
898 n_iovec++;
899 }
900
901 if (!GREEDY_REALLOC(iovec, n_iovec_allocated, n_iovec + 3)) {
902 r = log_oom();
903 goto finish;
904 }
905
906 /* Make sure we got all data we really need */
907 assert(context[CONTEXT_PID]);
908 assert(context[CONTEXT_UID]);
909 assert(context[CONTEXT_GID]);
910 assert(context[CONTEXT_SIGNAL]);
911 assert(context[CONTEXT_TIMESTAMP]);
912 assert(context[CONTEXT_RLIMIT]);
913 assert(context[CONTEXT_COMM]);
914 assert(coredump_fd >= 0);
915
916 r = submit_coredump(context, iovec, n_iovec_allocated, n_iovec, coredump_fd);
917
918 finish:
919 for (i = 0; i < n_iovec; i++)
920 free(iovec[i].iov_base);
921 free(iovec);
922
923 return r;
924 }
925
926 static int send_iovec(const struct iovec iovec[], size_t n_iovec, int input_fd) {
927
928 static const union sockaddr_union sa = {
929 .un.sun_family = AF_UNIX,
930 .un.sun_path = "/run/systemd/coredump",
931 };
932 _cleanup_close_ int fd = -1;
933 size_t i;
934 int r;
935
936 assert(iovec || n_iovec <= 0);
937 assert(input_fd >= 0);
938
939 fd = socket(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0);
940 if (fd < 0)
941 return log_error_errno(errno, "Failed to create coredump socket: %m");
942
943 if (connect(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0)
944 return log_error_errno(errno, "Failed to connect to coredump service: %m");
945
946 for (i = 0; i < n_iovec; i++) {
947 struct msghdr mh = {
948 .msg_iov = (struct iovec*) iovec + i,
949 .msg_iovlen = 1,
950 };
951 struct iovec copy[2];
952
953 for (;;) {
954 if (sendmsg(fd, &mh, MSG_NOSIGNAL) >= 0)
955 break;
956
957 if (errno == EMSGSIZE && mh.msg_iov[0].iov_len > 0) {
958 /* This field didn't fit? That's a pity. Given that this is just metadata,
959 * let's truncate the field at half, and try again. We append three dots, in
960 * order to show that this is truncated. */
961
962 if (mh.msg_iov != copy) {
963 /* We don't want to modify the caller's iovec, hence let's create our
964 * own array, consisting of two new iovecs, where the first is a
965 * (truncated) copy of what we want to send, and the second one
966 * contains the trailing dots. */
967 copy[0] = iovec[i];
968 copy[1] = (struct iovec) {
969 .iov_base = (char[]) { '.', '.', '.' },
970 .iov_len = 3,
971 };
972
973 mh.msg_iov = copy;
974 mh.msg_iovlen = 2;
975 }
976
977 copy[0].iov_len /= 2; /* halve it, and try again */
978 continue;
979 }
980
981 return log_error_errno(errno, "Failed to send coredump datagram: %m");
982 }
983 }
984
985 r = send_one_fd(fd, input_fd, 0);
986 if (r < 0)
987 return log_error_errno(r, "Failed to send coredump fd: %m");
988
989 return 0;
990 }
991
992 static int process_special_crash(const char *context[], int input_fd) {
993 _cleanup_close_ int coredump_fd = -1, coredump_node_fd = -1;
994 _cleanup_free_ char *filename = NULL;
995 uint64_t coredump_size;
996 int r;
997
998 assert(context);
999 assert(input_fd >= 0);
1000
1001 /* If we are pid1 or journald, we cut things short, don't write to the journal, but still create a coredump. */
1002
1003 if (arg_storage != COREDUMP_STORAGE_NONE)
1004 arg_storage = COREDUMP_STORAGE_EXTERNAL;
1005
1006 r = save_external_coredump(context, input_fd, &filename, &coredump_node_fd, &coredump_fd, &coredump_size);
1007 if (r < 0)
1008 return r;
1009
1010 r = maybe_remove_external_coredump(filename, coredump_size);
1011 if (r < 0)
1012 return r;
1013
1014 log_notice("Detected coredump of the journal daemon or PID 1, diverted to %s.", filename);
1015
1016 return 0;
1017 }
1018
1019 static int process_kernel(int argc, char* argv[]) {
1020
1021 /* The small core field we allocate on the stack, to keep things simple */
1022 char
1023 *core_pid = NULL, *core_uid = NULL, *core_gid = NULL, *core_signal = NULL,
1024 *core_session = NULL, *core_exe = NULL, *core_comm = NULL, *core_cmdline = NULL,
1025 *core_cgroup = NULL, *core_cwd = NULL, *core_root = NULL, *core_unit = NULL,
1026 *core_user_unit = NULL, *core_slice = NULL, *core_timestamp = NULL, *core_rlimit = NULL;
1027
1028 /* The larger ones we allocate on the heap */
1029 _cleanup_free_ char
1030 *core_owner_uid = NULL, *core_open_fds = NULL, *core_proc_status = NULL,
1031 *core_proc_maps = NULL, *core_proc_limits = NULL, *core_proc_cgroup = NULL, *core_environ = NULL,
1032 *core_proc_mountinfo = NULL, *core_container_cmdline = NULL;
1033
1034 _cleanup_free_ char *exe = NULL, *comm = NULL;
1035 const char *context[_CONTEXT_MAX];
1036 bool proc_self_root_is_slash;
1037 struct iovec iovec[27];
1038 size_t n_iovec = 0;
1039 uid_t owner_uid;
1040 const char *p;
1041 pid_t pid;
1042 char *t;
1043 int r;
1044
1045 if (argc < CONTEXT_COMM + 1) {
1046 log_error("Not enough arguments passed from kernel (%i, expected %i).", argc - 1, CONTEXT_COMM + 1 - 1);
1047 return -EINVAL;
1048 }
1049
1050 r = parse_pid(argv[CONTEXT_PID + 1], &pid);
1051 if (r < 0)
1052 return log_error_errno(r, "Failed to parse PID.");
1053
1054 r = get_process_comm(pid, &comm);
1055 if (r < 0) {
1056 log_warning_errno(r, "Failed to get COMM, falling back to the command line: %m");
1057 comm = strv_join(argv + CONTEXT_COMM + 1, " ");
1058 if (!comm)
1059 return log_oom();
1060 }
1061
1062 r = get_process_exe(pid, &exe);
1063 if (r < 0)
1064 log_warning_errno(r, "Failed to get EXE, ignoring: %m");
1065
1066 context[CONTEXT_PID] = argv[CONTEXT_PID + 1];
1067 context[CONTEXT_UID] = argv[CONTEXT_UID + 1];
1068 context[CONTEXT_GID] = argv[CONTEXT_GID + 1];
1069 context[CONTEXT_SIGNAL] = argv[CONTEXT_SIGNAL + 1];
1070 context[CONTEXT_TIMESTAMP] = argv[CONTEXT_TIMESTAMP + 1];
1071 context[CONTEXT_RLIMIT] = argv[CONTEXT_RLIMIT + 1];
1072 context[CONTEXT_COMM] = comm;
1073 context[CONTEXT_EXE] = exe;
1074
1075 if (cg_pid_get_unit(pid, &t) >= 0) {
1076
1077 /* If this is PID 1 disable coredump collection, we'll unlikely be able to process it later on. */
1078 if (streq(t, SPECIAL_INIT_SCOPE)) {
1079 log_notice("Due to PID 1 having crashed coredump collection will now be turned off.");
1080 (void) write_string_file("/proc/sys/kernel/core_pattern", "|/bin/false", 0);
1081 }
1082
1083 /* Let's avoid dead-locks when processing journald and init crashes, as socket activation and logging
1084 * are unlikely to work then. */
1085 if (STR_IN_SET(t, SPECIAL_JOURNALD_SERVICE, SPECIAL_INIT_SCOPE)) {
1086 free(t);
1087 return process_special_crash(context, STDIN_FILENO);
1088 }
1089
1090 core_unit = strjoina("COREDUMP_UNIT=", t);
1091 free(t);
1092
1093 IOVEC_SET_STRING(iovec[n_iovec++], core_unit);
1094 }
1095
1096 /* OK, now we know it's not the journal, hence we can make use of it now. */
1097 log_set_target(LOG_TARGET_JOURNAL_OR_KMSG);
1098 log_open();
1099
1100 if (cg_pid_get_user_unit(pid, &t) >= 0) {
1101 core_user_unit = strjoina("COREDUMP_USER_UNIT=", t);
1102 free(t);
1103
1104 IOVEC_SET_STRING(iovec[n_iovec++], core_user_unit);
1105 }
1106
1107 core_pid = strjoina("COREDUMP_PID=", context[CONTEXT_PID]);
1108 IOVEC_SET_STRING(iovec[n_iovec++], core_pid);
1109
1110 core_uid = strjoina("COREDUMP_UID=", context[CONTEXT_UID]);
1111 IOVEC_SET_STRING(iovec[n_iovec++], core_uid);
1112
1113 core_gid = strjoina("COREDUMP_GID=", context[CONTEXT_GID]);
1114 IOVEC_SET_STRING(iovec[n_iovec++], core_gid);
1115
1116 core_signal = strjoina("COREDUMP_SIGNAL=", context[CONTEXT_SIGNAL]);
1117 IOVEC_SET_STRING(iovec[n_iovec++], core_signal);
1118
1119 core_rlimit = strjoina("COREDUMP_RLIMIT=", context[CONTEXT_RLIMIT]);
1120 IOVEC_SET_STRING(iovec[n_iovec++], core_rlimit);
1121
1122 if (sd_pid_get_session(pid, &t) >= 0) {
1123 core_session = strjoina("COREDUMP_SESSION=", t);
1124 free(t);
1125
1126 IOVEC_SET_STRING(iovec[n_iovec++], core_session);
1127 }
1128
1129 if (sd_pid_get_owner_uid(pid, &owner_uid) >= 0) {
1130 r = asprintf(&core_owner_uid, "COREDUMP_OWNER_UID=" UID_FMT, owner_uid);
1131 if (r > 0)
1132 IOVEC_SET_STRING(iovec[n_iovec++], core_owner_uid);
1133 }
1134
1135 if (sd_pid_get_slice(pid, &t) >= 0) {
1136 core_slice = strjoina("COREDUMP_SLICE=", t);
1137 free(t);
1138
1139 IOVEC_SET_STRING(iovec[n_iovec++], core_slice);
1140 }
1141
1142 if (comm) {
1143 core_comm = strjoina("COREDUMP_COMM=", comm);
1144 IOVEC_SET_STRING(iovec[n_iovec++], core_comm);
1145 }
1146
1147 if (exe) {
1148 core_exe = strjoina("COREDUMP_EXE=", exe);
1149 IOVEC_SET_STRING(iovec[n_iovec++], core_exe);
1150 }
1151
1152 if (get_process_cmdline(pid, 0, false, &t) >= 0) {
1153 core_cmdline = strjoina("COREDUMP_CMDLINE=", t);
1154 free(t);
1155
1156 IOVEC_SET_STRING(iovec[n_iovec++], core_cmdline);
1157 }
1158
1159 if (cg_pid_get_path_shifted(pid, NULL, &t) >= 0) {
1160 core_cgroup = strjoina("COREDUMP_CGROUP=", t);
1161 free(t);
1162
1163 IOVEC_SET_STRING(iovec[n_iovec++], core_cgroup);
1164 }
1165
1166 if (compose_open_fds(pid, &t) >= 0) {
1167 core_open_fds = strappend("COREDUMP_OPEN_FDS=", t);
1168 free(t);
1169
1170 if (core_open_fds)
1171 IOVEC_SET_STRING(iovec[n_iovec++], core_open_fds);
1172 }
1173
1174 p = procfs_file_alloca(pid, "status");
1175 if (read_full_file(p, &t, NULL) >= 0) {
1176 core_proc_status = strappend("COREDUMP_PROC_STATUS=", t);
1177 free(t);
1178
1179 if (core_proc_status)
1180 IOVEC_SET_STRING(iovec[n_iovec++], core_proc_status);
1181 }
1182
1183 p = procfs_file_alloca(pid, "maps");
1184 if (read_full_file(p, &t, NULL) >= 0) {
1185 core_proc_maps = strappend("COREDUMP_PROC_MAPS=", t);
1186 free(t);
1187
1188 if (core_proc_maps)
1189 IOVEC_SET_STRING(iovec[n_iovec++], core_proc_maps);
1190 }
1191
1192 p = procfs_file_alloca(pid, "limits");
1193 if (read_full_file(p, &t, NULL) >= 0) {
1194 core_proc_limits = strappend("COREDUMP_PROC_LIMITS=", t);
1195 free(t);
1196
1197 if (core_proc_limits)
1198 IOVEC_SET_STRING(iovec[n_iovec++], core_proc_limits);
1199 }
1200
1201 p = procfs_file_alloca(pid, "cgroup");
1202 if (read_full_file(p, &t, NULL) >=0) {
1203 core_proc_cgroup = strappend("COREDUMP_PROC_CGROUP=", t);
1204 free(t);
1205
1206 if (core_proc_cgroup)
1207 IOVEC_SET_STRING(iovec[n_iovec++], core_proc_cgroup);
1208 }
1209
1210 p = procfs_file_alloca(pid, "mountinfo");
1211 if (read_full_file(p, &t, NULL) >=0) {
1212 core_proc_mountinfo = strappend("COREDUMP_PROC_MOUNTINFO=", t);
1213 free(t);
1214
1215 if (core_proc_mountinfo)
1216 IOVEC_SET_STRING(iovec[n_iovec++], core_proc_mountinfo);
1217 }
1218
1219 if (get_process_cwd(pid, &t) >= 0) {
1220 core_cwd = strjoina("COREDUMP_CWD=", t);
1221 free(t);
1222
1223 IOVEC_SET_STRING(iovec[n_iovec++], core_cwd);
1224 }
1225
1226 if (get_process_root(pid, &t) >= 0) {
1227 core_root = strjoina("COREDUMP_ROOT=", t);
1228
1229 IOVEC_SET_STRING(iovec[n_iovec++], core_root);
1230
1231 /* If the process' root is "/", then there is a chance it has
1232 * mounted own root and hence being containerized. */
1233 proc_self_root_is_slash = strcmp(t, "/") == 0;
1234 free(t);
1235 if (proc_self_root_is_slash && get_process_container_parent_cmdline(pid, &t) > 0) {
1236 core_container_cmdline = strappend("COREDUMP_CONTAINER_CMDLINE=", t);
1237 free(t);
1238
1239 if (core_container_cmdline)
1240 IOVEC_SET_STRING(iovec[n_iovec++], core_container_cmdline);
1241 }
1242 }
1243
1244 if (get_process_environ(pid, &t) >= 0) {
1245 core_environ = strappend("COREDUMP_ENVIRON=", t);
1246 free(t);
1247
1248 if (core_environ)
1249 IOVEC_SET_STRING(iovec[n_iovec++], core_environ);
1250 }
1251
1252 core_timestamp = strjoina("COREDUMP_TIMESTAMP=", context[CONTEXT_TIMESTAMP], "000000");
1253 IOVEC_SET_STRING(iovec[n_iovec++], core_timestamp);
1254
1255 IOVEC_SET_STRING(iovec[n_iovec++], "MESSAGE_ID=fc2e22bc6ee647b6b90729ab34a250b1");
1256
1257 assert_cc(2 == LOG_CRIT);
1258 IOVEC_SET_STRING(iovec[n_iovec++], "PRIORITY=2");
1259
1260 assert(n_iovec <= ELEMENTSOF(iovec));
1261
1262 return send_iovec(iovec, n_iovec, STDIN_FILENO);
1263 }
1264
1265 int main(int argc, char *argv[]) {
1266 int r;
1267
1268 /* First, log to a safe place, since we don't know what crashed and it might be journald which we'd rather not
1269 * log to then. */
1270
1271 log_set_target(LOG_TARGET_KMSG);
1272 log_open();
1273
1274 /* Make sure we never enter a loop */
1275 (void) prctl(PR_SET_DUMPABLE, 0);
1276
1277 /* Ignore all parse errors */
1278 (void) parse_config();
1279
1280 log_debug("Selected storage '%s'.", coredump_storage_to_string(arg_storage));
1281 log_debug("Selected compression %s.", yes_no(arg_compress));
1282
1283 r = sd_listen_fds(false);
1284 if (r < 0) {
1285 log_error_errno(r, "Failed to determine number of file descriptor: %m");
1286 goto finish;
1287 }
1288
1289 /* If we got an fd passed, we are running in coredumpd mode. Otherwise we are invoked from the kernel as
1290 * coredump handler */
1291 if (r == 0)
1292 r = process_kernel(argc, argv);
1293 else if (r == 1)
1294 r = process_socket(SD_LISTEN_FDS_START);
1295 else {
1296 log_error("Received unexpected number of file descriptors.");
1297 r = -EINVAL;
1298 }
1299
1300 finish:
1301 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1302 }