src/coredump/coredumpctl.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2012 Zbigniew Jędrzejewski-Szmek
   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 <fcntl.h>
  21 #include <getopt.h>
  22 #include <locale.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26
  27 #include "sd-journal.h"
  28
  29 #include "alloc-util.h"
  30 #include "compress.h"
  31 #include "fd-util.h"
  32 #include "fileio.h"
  33 #include "fs-util.h"
  34 #include "journal-internal.h"
  35 #include "log.h"
  36 #include "macro.h"
  37 #include "pager.h"
  38 #include "parse-util.h"
  39 #include "path-util.h"
  40 #include "process-util.h"
  41 #include "set.h"
  42 #include "sigbus.h"
  43 #include "signal-util.h"
  44 #include "string-util.h"
  45 #include "terminal-util.h"
  46 #include "user-util.h"
  47 #include "util.h"
  48
  49 static enum {
  50         ACTION_NONE,
  51         ACTION_INFO,
  52         ACTION_LIST,
  53         ACTION_DUMP,
  54         ACTION_GDB,
  55 } arg_action = ACTION_LIST;
  56 static const char* arg_field = NULL;
  57 static const char *arg_directory = NULL;
  58 static bool arg_no_pager = false;
  59 static int arg_no_legend = false;
  60 static int arg_one = false;
  61 static FILE* arg_output = NULL;
  62
  63 static Set *new_matches(void) {
  64         Set *set;
  65         char *tmp;
  66         int r;
  67
  68         set = set_new(NULL);
  69         if (!set) {
  70                 log_oom();
  71                 return NULL;
  72         }
  73
  74         tmp = strdup("MESSAGE_ID=fc2e22bc6ee647b6b90729ab34a250b1");
  75         if (!tmp) {
  76                 log_oom();
  77                 set_free(set);
  78                 return NULL;
  79         }
  80
  81         r = set_consume(set, tmp);
  82         if (r < 0) {
  83                 log_error_errno(r, "failed to add to set: %m");
  84                 set_free(set);
  85                 return NULL;
  86         }
  87
  88         return set;
  89 }
  90
  91 static int add_match(Set *set, const char *match) {
  92         _cleanup_free_ char *p = NULL;
  93         char *pattern = NULL;
  94         const char* prefix;
  95         pid_t pid;
  96         int r;
  97
  98         if (strchr(match, '='))
  99                 prefix = "";
 100         else if (strchr(match, '/')) {
 101                 r = path_make_absolute_cwd(match, &p);
 102                 if (r < 0)
 103                         goto fail;
 104                 match = p;
 105                 prefix = "COREDUMP_EXE=";
 106         } else if (parse_pid(match, &pid) >= 0)
 107                 prefix = "COREDUMP_PID=";
 108         else
 109                 prefix = "COREDUMP_COMM=";
 110
 111         pattern = strjoin(prefix, match, NULL);
 112         if (!pattern) {
 113                 r = -ENOMEM;
 114                 goto fail;
 115         }
 116
 117         log_debug("Adding pattern: %s", pattern);
 118         r = set_consume(set, pattern);
 119         if (r < 0)
 120                 goto fail;
 121
 122         return 0;
 123 fail:
 124         return log_error_errno(r, "Failed to add match: %m");
 125 }
 126
 127 static void help(void) {
 128         printf("%s [OPTIONS...]\n\n"
 129                "List or retrieve coredumps from the journal.\n\n"
 130                "Flags:\n"
 131                "  -h --help          Show this help\n"
 132                "     --version       Print version string\n"
 133                "     --no-pager      Do not pipe output into a pager\n"
 134                "     --no-legend     Do not print the column headers.\n"
 135                "  -1                 Show information about most recent entry only\n"
 136                "  -F --field=FIELD   List all values a certain field takes\n"
 137                "  -o --output=FILE   Write output to FILE\n\n"
 138                "  -D --directory=DIR Use journal files from directory\n\n"
 139
 140                "Commands:\n"
 141                "  list [MATCHES...]  List available coredumps (default)\n"
 142                "  info [MATCHES...]  Show detailed information about one or more coredumps\n"
 143                "  dump [MATCHES...]  Print first matching coredump to stdout\n"
 144                "  gdb [MATCHES...]   Start gdb for the first matching coredump\n"
 145                , program_invocation_short_name);
 146 }
 147
 148 static int parse_argv(int argc, char *argv[], Set *matches) {
 149         enum {
 150                 ARG_VERSION = 0x100,
 151                 ARG_NO_PAGER,
 152                 ARG_NO_LEGEND,
 153         };
 154
 155         int r, c;
 156
 157         static const struct option options[] = {
 158                 { "help",         no_argument,       NULL, 'h'           },
 159                 { "version" ,     no_argument,       NULL, ARG_VERSION   },
 160                 { "no-pager",     no_argument,       NULL, ARG_NO_PAGER  },
 161                 { "no-legend",    no_argument,       NULL, ARG_NO_LEGEND },
 162                 { "output",       required_argument, NULL, 'o'           },
 163                 { "field",        required_argument, NULL, 'F'           },
 164                 { "directory",    required_argument, NULL, 'D'           },
 165                 {}
 166         };
 167
 168         assert(argc >= 0);
 169         assert(argv);
 170
 171         while ((c = getopt_long(argc, argv, "ho:F:1D:", options, NULL)) >= 0)
 172                 switch(c) {
 173
 174                 case 'h':
 175                         arg_action = ACTION_NONE;
 176                         help();
 177                         return 0;
 178
 179                 case ARG_VERSION:
 180                         arg_action = ACTION_NONE;
 181                         return version();
 182
 183                 case ARG_NO_PAGER:
 184                         arg_no_pager = true;
 185                         break;
 186
 187                 case ARG_NO_LEGEND:
 188                         arg_no_legend = true;
 189                         break;
 190
 191                 case 'o':
 192                         if (arg_output) {
 193                                 log_error("cannot set output more than once");
 194                                 return -EINVAL;
 195                         }
 196
 197                         arg_output = fopen(optarg, "we");
 198                         if (!arg_output)
 199                                 return log_error_errno(errno, "writing to '%s': %m", optarg);
 200
 201                         break;
 202
 203                 case 'F':
 204                         if (arg_field) {
 205                                 log_error("cannot use --field/-F more than once");
 206                                 return -EINVAL;
 207                         }
 208                         arg_field = optarg;
 209                         break;
 210
 211                 case '1':
 212                         arg_one = true;
 213                         break;
 214
 215                 case 'D':
 216                         arg_directory = optarg;
 217                         break;
 218
 219                 case '?':
 220                         return -EINVAL;
 221
 222                 default:
 223                         assert_not_reached("Unhandled option");
 224                 }
 225
 226         if (optind < argc) {
 227                 const char *cmd = argv[optind++];
 228                 if (streq(cmd, "list"))
 229                         arg_action = ACTION_LIST;
 230                 else if (streq(cmd, "dump"))
 231                         arg_action = ACTION_DUMP;
 232                 else if (streq(cmd, "gdb"))
 233                         arg_action = ACTION_GDB;
 234                 else if (streq(cmd, "info"))
 235                         arg_action = ACTION_INFO;
 236                 else {
 237                         log_error("Unknown action '%s'", cmd);
 238                         return -EINVAL;
 239                 }
 240         }
 241
 242         if (arg_field && arg_action != ACTION_LIST) {
 243                 log_error("Option --field/-F only makes sense with list");
 244                 return -EINVAL;
 245         }
 246
 247         while (optind < argc) {
 248                 r = add_match(matches, argv[optind]);
 249                 if (r != 0)
 250                         return r;
 251                 optind++;
 252         }
 253
 254         return 0;
 255 }
 256
 257 static int retrieve(const void *data,
 258                     size_t len,
 259                     const char *name,
 260                     char **var) {
 261
 262         size_t ident;
 263         char *v;
 264
 265         ident = strlen(name) + 1; /* name + "=" */
 266
 267         if (len < ident)
 268                 return 0;
 269
 270         if (memcmp(data, name, ident - 1) != 0)
 271                 return 0;
 272
 273         if (((const char*) data)[ident - 1] != '=')
 274                 return 0;
 275
 276         v = strndup((const char*)data + ident, len - ident);
 277         if (!v)
 278                 return log_oom();
 279
 280         free(*var);
 281         *var = v;
 282
 283         return 1;
 284 }
 285
 286 static int print_field(FILE* file, sd_journal *j) {
 287         const void *d;
 288         size_t l;
 289
 290         assert(file);
 291         assert(j);
 292
 293         assert(arg_field);
 294
 295         /* A (user-specified) field may appear more than once for a given entry.
 296          * We will print all of the occurences.
 297          * This is different below for fields that systemd-coredump uses,
 298          * because they cannot meaningfully appear more than once.
 299          */
 300         SD_JOURNAL_FOREACH_DATA(j, d, l) {
 301                 _cleanup_free_ char *value = NULL;
 302                 int r;
 303
 304                 r = retrieve(d, l, arg_field, &value);
 305                 if (r < 0)
 306                         return r;
 307                 if (r > 0)
 308                         fprintf(file, "%s\n", value);
 309         }
 310
 311         return 0;
 312 }
 313
 314 #define RETRIEVE(d, l, name, arg)                    \
 315         {                                            \
 316                 int _r = retrieve(d, l, name, &arg); \
 317                 if (_r < 0)                          \
 318                         return _r;                   \
 319                 if (_r > 0)                          \
 320                         continue;                    \
 321         }
 322
 323 static int print_list(FILE* file, sd_journal *j, int had_legend) {
 324         _cleanup_free_ char
 325                 *pid = NULL, *uid = NULL, *gid = NULL,
 326                 *sgnl = NULL, *exe = NULL, *comm = NULL, *cmdline = NULL,
 327                 *filename = NULL, *coredump = NULL;
 328         const void *d;
 329         size_t l;
 330         usec_t t;
 331         char buf[FORMAT_TIMESTAMP_MAX];
 332         int r;
 333         const char *present;
 334
 335         assert(file);
 336         assert(j);
 337
 338         SD_JOURNAL_FOREACH_DATA(j, d, l) {
 339                 RETRIEVE(d, l, "COREDUMP_PID", pid);
 340                 RETRIEVE(d, l, "COREDUMP_UID", uid);
 341                 RETRIEVE(d, l, "COREDUMP_GID", gid);
 342                 RETRIEVE(d, l, "COREDUMP_SIGNAL", sgnl);
 343                 RETRIEVE(d, l, "COREDUMP_EXE", exe);
 344                 RETRIEVE(d, l, "COREDUMP_COMM", comm);
 345                 RETRIEVE(d, l, "COREDUMP_CMDLINE", cmdline);
 346                 RETRIEVE(d, l, "COREDUMP_FILENAME", filename);
 347                 RETRIEVE(d, l, "COREDUMP", coredump);
 348         }
 349
 350         if (!pid && !uid && !gid && !sgnl && !exe && !comm && !cmdline && !filename) {
 351                 log_warning("Empty coredump log entry");
 352                 return -EINVAL;
 353         }
 354
 355         r = sd_journal_get_realtime_usec(j, &t);
 356         if (r < 0)
 357                 return log_error_errno(r, "Failed to get realtime timestamp: %m");
 358
 359         format_timestamp(buf, sizeof(buf), t);
 360
 361         if (!had_legend && !arg_no_legend)
 362                 fprintf(file, "%-*s %*s %*s %*s %*s %*s %s\n",
 363                         FORMAT_TIMESTAMP_WIDTH, "TIME",
 364                         6, "PID",
 365                         5, "UID",
 366                         5, "GID",
 367                         3, "SIG",
 368                         8, "COREFILE",
 369                            "EXE");
 370
 371         if (filename)
 372                 if (access(filename, R_OK) == 0)
 373                         present = "present";
 374                 else if (errno == ENOENT)
 375                         present = "missing";
 376                 else
 377                         present = "error";
 378         else if (coredump)
 379                 present = "journal";
 380         else
 381                 present = "none";
 382
 383         fprintf(file, "%-*s %*s %*s %*s %*s %-*s %s\n",
 384                 FORMAT_TIMESTAMP_WIDTH, buf,
 385                 6, strna(pid),
 386                 5, strna(uid),
 387                 5, strna(gid),
 388                 3, strna(sgnl),
 389                 8, present,
 390                 strna(exe ?: (comm ?: cmdline)));
 391
 392         return 0;
 393 }
 394
 395 static int print_info(FILE *file, sd_journal *j, bool need_space) {
 396         _cleanup_free_ char
 397                 *pid = NULL, *uid = NULL, *gid = NULL,
 398                 *sgnl = NULL, *exe = NULL, *comm = NULL, *cmdline = NULL,
 399                 *unit = NULL, *user_unit = NULL, *session = NULL,
 400                 *boot_id = NULL, *machine_id = NULL, *hostname = NULL,
 401                 *slice = NULL, *cgroup = NULL, *owner_uid = NULL,
 402                 *message = NULL, *timestamp = NULL, *filename = NULL,
 403                 *coredump = NULL;
 404         const void *d;
 405         size_t l;
 406         int r;
 407
 408         assert(file);
 409         assert(j);
 410
 411         SD_JOURNAL_FOREACH_DATA(j, d, l) {
 412                 RETRIEVE(d, l, "COREDUMP_PID", pid);
 413                 RETRIEVE(d, l, "COREDUMP_UID", uid);
 414                 RETRIEVE(d, l, "COREDUMP_GID", gid);
 415                 RETRIEVE(d, l, "COREDUMP_SIGNAL", sgnl);
 416                 RETRIEVE(d, l, "COREDUMP_EXE", exe);
 417                 RETRIEVE(d, l, "COREDUMP_COMM", comm);
 418                 RETRIEVE(d, l, "COREDUMP_CMDLINE", cmdline);
 419                 RETRIEVE(d, l, "COREDUMP_UNIT", unit);
 420                 RETRIEVE(d, l, "COREDUMP_USER_UNIT", user_unit);
 421                 RETRIEVE(d, l, "COREDUMP_SESSION", session);
 422                 RETRIEVE(d, l, "COREDUMP_OWNER_UID", owner_uid);
 423                 RETRIEVE(d, l, "COREDUMP_SLICE", slice);
 424                 RETRIEVE(d, l, "COREDUMP_CGROUP", cgroup);
 425                 RETRIEVE(d, l, "COREDUMP_TIMESTAMP", timestamp);
 426                 RETRIEVE(d, l, "COREDUMP_FILENAME", filename);
 427                 RETRIEVE(d, l, "COREDUMP", coredump);
 428                 RETRIEVE(d, l, "_BOOT_ID", boot_id);
 429                 RETRIEVE(d, l, "_MACHINE_ID", machine_id);
 430                 RETRIEVE(d, l, "_HOSTNAME", hostname);
 431                 RETRIEVE(d, l, "MESSAGE", message);
 432         }
 433
 434         if (need_space)
 435                 fputs("\n", file);
 436
 437         if (comm)
 438                 fprintf(file,
 439                         "           PID: %s%s%s (%s)\n",
 440                         ansi_highlight(), strna(pid), ansi_normal(), comm);
 441         else
 442                 fprintf(file,
 443                         "           PID: %s%s%s\n",
 444                         ansi_highlight(), strna(pid), ansi_normal());
 445
 446         if (uid) {
 447                 uid_t n;
 448
 449                 if (parse_uid(uid, &n) >= 0) {
 450                         _cleanup_free_ char *u = NULL;
 451
 452                         u = uid_to_name(n);
 453                         fprintf(file,
 454                                 "           UID: %s (%s)\n",
 455                                 uid, u);
 456                 } else {
 457                         fprintf(file,
 458                                 "           UID: %s\n",
 459                                 uid);
 460                 }
 461         }
 462
 463         if (gid) {
 464                 gid_t n;
 465
 466                 if (parse_gid(gid, &n) >= 0) {
 467                         _cleanup_free_ char *g = NULL;
 468
 469                         g = gid_to_name(n);
 470                         fprintf(file,
 471                                 "           GID: %s (%s)\n",
 472                                 gid, g);
 473                 } else {
 474                         fprintf(file,
 475                                 "           GID: %s\n",
 476                                 gid);
 477                 }
 478         }
 479
 480         if (sgnl) {
 481                 int sig;
 482
 483                 if (safe_atoi(sgnl, &sig) >= 0)
 484                         fprintf(file, "        Signal: %s (%s)\n", sgnl, signal_to_string(sig));
 485                 else
 486                         fprintf(file, "        Signal: %s\n", sgnl);
 487         }
 488
 489         if (timestamp) {
 490                 usec_t u;
 491
 492                 r = safe_atou64(timestamp, &u);
 493                 if (r >= 0) {
 494                         char absolute[FORMAT_TIMESTAMP_MAX], relative[FORMAT_TIMESPAN_MAX];
 495
 496                         fprintf(file,
 497                                 "     Timestamp: %s (%s)\n",
 498                                 format_timestamp(absolute, sizeof(absolute), u),
 499                                 format_timestamp_relative(relative, sizeof(relative), u));
 500
 501                 } else
 502                         fprintf(file, "     Timestamp: %s\n", timestamp);
 503         }
 504
 505         if (cmdline)
 506                 fprintf(file, "  Command Line: %s\n", cmdline);
 507         if (exe)
 508                 fprintf(file, "    Executable: %s%s%s\n", ansi_highlight(), exe, ansi_normal());
 509         if (cgroup)
 510                 fprintf(file, " Control Group: %s\n", cgroup);
 511         if (unit)
 512                 fprintf(file, "          Unit: %s\n", unit);
 513         if (user_unit)
 514                 fprintf(file, "     User Unit: %s\n", user_unit);
 515         if (slice)
 516                 fprintf(file, "         Slice: %s\n", slice);
 517         if (session)
 518                 fprintf(file, "       Session: %s\n", session);
 519         if (owner_uid) {
 520                 uid_t n;
 521
 522                 if (parse_uid(owner_uid, &n) >= 0) {
 523                         _cleanup_free_ char *u = NULL;
 524
 525                         u = uid_to_name(n);
 526                         fprintf(file,
 527                                 "     Owner UID: %s (%s)\n",
 528                                 owner_uid, u);
 529                 } else {
 530                         fprintf(file,
 531                                 "     Owner UID: %s\n",
 532                                 owner_uid);
 533                 }
 534         }
 535         if (boot_id)
 536                 fprintf(file, "       Boot ID: %s\n", boot_id);
 537         if (machine_id)
 538                 fprintf(file, "    Machine ID: %s\n", machine_id);
 539         if (hostname)
 540                 fprintf(file, "      Hostname: %s\n", hostname);
 541
 542         if (filename)
 543                 fprintf(file, "       Storage: %s%s\n", filename,
 544                         access(filename, R_OK) < 0 ? " (inaccessible)" : "");
 545         else if (coredump)
 546                 fprintf(file, "       Storage: journal\n");
 547         else
 548                 fprintf(file, "       Storage: none\n");
 549
 550         if (message) {
 551                 _cleanup_free_ char *m = NULL;
 552
 553                 m = strreplace(message, "\n", "\n                ");
 554
 555                 fprintf(file, "       Message: %s\n", strstrip(m ?: message));
 556         }
 557
 558         return 0;
 559 }
 560
 561 static int focus(sd_journal *j) {
 562         int r;
 563
 564         r = sd_journal_seek_tail(j);
 565         if (r == 0)
 566                 r = sd_journal_previous(j);
 567         if (r < 0)
 568                 return log_error_errno(r, "Failed to search journal: %m");
 569         if (r == 0) {
 570                 log_error("No match found.");
 571                 return -ESRCH;
 572         }
 573         return r;
 574 }
 575
 576 static int print_entry(sd_journal *j, unsigned n_found) {
 577         assert(j);
 578
 579         if (arg_action == ACTION_INFO)
 580                 return print_info(stdout, j, n_found);
 581         else if (arg_field)
 582                 return print_field(stdout, j);
 583         else
 584                 return print_list(stdout, j, n_found);
 585 }
 586
 587 static int dump_list(sd_journal *j) {
 588         unsigned n_found = 0;
 589         int r;
 590
 591         assert(j);
 592
 593         /* The coredumps are likely to compressed, and for just
 594          * listing them we don't need to decompress them, so let's
 595          * pick a fairly low data threshold here */
 596         sd_journal_set_data_threshold(j, 4096);
 597
 598         if (arg_one) {
 599                 r = focus(j);
 600                 if (r < 0)
 601                         return r;
 602
 603                 return print_entry(j, 0);
 604         } else {
 605                 SD_JOURNAL_FOREACH(j) {
 606                         r = print_entry(j, n_found++);
 607                         if (r < 0)
 608                                 return r;
 609                 }
 610
 611                 if (!arg_field && n_found <= 0) {
 612                         log_notice("No coredumps found.");
 613                         return -ESRCH;
 614                 }
 615         }
 616
 617         return 0;
 618 }
 619
 620 static int save_core(sd_journal *j, FILE *file, char **path, bool *unlink_temp) {
 621         const char *data;
 622         _cleanup_free_ char *filename = NULL;
 623         size_t len;
 624         int r, fd;
 625         _cleanup_close_ int fdt = -1;
 626         char *temp = NULL;
 627
 628         assert(!(file && path));         /* At most one can be specified */
 629         assert(!!path == !!unlink_temp); /* Those must be specified together */
 630
 631         /* Look for a coredump on disk first. */
 632         r = sd_journal_get_data(j, "COREDUMP_FILENAME", (const void**) &data, &len);
 633         if (r == 0)
 634                 retrieve(data, len, "COREDUMP_FILENAME", &filename);
 635         else {
 636                 if (r != -ENOENT)
 637                         return log_error_errno(r, "Failed to retrieve COREDUMP_FILENAME field: %m");
 638                 /* Check that we can have a COREDUMP field. We still haven't set a high
 639                  * data threshold, so we'll get a few kilobytes at most.
 640                  */
 641
 642                 r = sd_journal_get_data(j, "COREDUMP", (const void**) &data, &len);
 643                 if (r == -ENOENT)
 644                         return log_error_errno(r, "Coredump entry has no core attached (neither internally in the journal nor externally on disk).");
 645                 if (r < 0)
 646                         return log_error_errno(r, "Failed to retrieve COREDUMP field: %m");
 647         }
 648
 649         if (filename) {
 650                 if (access(filename, R_OK) < 0)
 651                         return log_error_errno(errno, "File \"%s\" is not readable: %m", filename);
 652
 653                 if (path && !endswith(filename, ".xz") && !endswith(filename, ".lz4")) {
 654                         *path = filename;
 655                         filename = NULL;
 656
 657                         return 0;
 658                 }
 659         }
 660
 661         if (path) {
 662                 const char *vt;
 663
 664                 /* Create a temporary file to write the uncompressed core to. */
 665
 666                 r = var_tmp_dir(&vt);
 667                 if (r < 0)
 668                         return log_error_errno(r, "Failed to acquire temporary directory path: %m");
 669
 670                 temp = strjoin(vt, "/coredump-XXXXXX", NULL);
 671                 if (!temp)
 672                         return log_oom();
 673
 674                 fdt = mkostemp_safe(temp);
 675                 if (fdt < 0)
 676                         return log_error_errno(fdt, "Failed to create temporary file: %m");
 677                 log_debug("Created temporary file %s", temp);
 678
 679                 fd = fdt;
 680         } else {
 681                 /* If neither path or file are specified, we will write to stdout. Let's now check
 682                  * if stdout is connected to a tty. We checked that the file exists, or that the
 683                  * core might be stored in the journal. In this second case, if we found the entry,
 684                  * in all likelyhood we will be able to access the COREDUMP= field.  In either case,
 685                  * we stop before doing any "real" work, i.e. before starting decompression or
 686                  * reading from the file or creating temporary files.
 687                  */
 688                 if (!file) {
 689                         if (on_tty())
 690                                 return log_error_errno(ENOTTY, "Refusing to dump core to tty"
 691                                                        " (use shell redirection or specify --output).");
 692                         file = stdout;
 693                 }
 694
 695                 fd = fileno(file);
 696         }
 697
 698         if (filename) {
 699 #if defined(HAVE_XZ) || defined(HAVE_LZ4)
 700                 _cleanup_close_ int fdf;
 701
 702                 fdf = open(filename, O_RDONLY | O_CLOEXEC);
 703                 if (fdf < 0) {
 704                         r = log_error_errno(errno, "Failed to open %s: %m", filename);
 705                         goto error;
 706                 }
 707
 708                 r = decompress_stream(filename, fdf, fd, -1);
 709                 if (r < 0) {
 710                         log_error_errno(r, "Failed to decompress %s: %m", filename);
 711                         goto error;
 712                 }
 713 #else
 714                 log_error("Cannot decompress file. Compiled without compression support.");
 715                 r = -EOPNOTSUPP;
 716                 goto error;
 717 #endif
 718         } else {
 719                 ssize_t sz;
 720
 721                 /* We want full data, nothing truncated. */
 722                 sd_journal_set_data_threshold(j, 0);
 723
 724                 r = sd_journal_get_data(j, "COREDUMP", (const void**) &data, &len);
 725                 if (r < 0)
 726                         return log_error_errno(r, "Failed to retrieve COREDUMP field: %m");
 727
 728                 assert(len >= 9);
 729                 data += 9;
 730                 len -= 9;
 731
 732                 sz = write(fd, data, len);
 733                 if (sz < 0) {
 734                         r = log_error_errno(errno, "Failed to write output: %m");
 735                         goto error;
 736                 }
 737                 if (sz != (ssize_t) len) {
 738                         log_error("Short write to output.");
 739                         r = -EIO;
 740                         goto error;
 741                 }
 742         }
 743
 744         if (temp) {
 745                 *path = temp;
 746                 *unlink_temp = true;
 747         }
 748         return 0;
 749
 750 error:
 751         if (temp) {
 752                 unlink(temp);
 753                 log_debug("Removed temporary file %s", temp);
 754         }
 755         return r;
 756 }
 757
 758 static int dump_core(sd_journal* j) {
 759         int r;
 760
 761         assert(j);
 762
 763         r = focus(j);
 764         if (r < 0)
 765                 return r;
 766
 767         print_info(arg_output ? stdout : stderr, j, false);
 768
 769         r = save_core(j, arg_output, NULL, NULL);
 770         if (r < 0)
 771                 return r;
 772
 773         r = sd_journal_previous(j);
 774         if (r > 0)
 775                 log_warning("More than one entry matches, ignoring rest.");
 776
 777         return 0;
 778 }
 779
 780 static int run_gdb(sd_journal *j) {
 781         _cleanup_free_ char *exe = NULL, *path = NULL;
 782         bool unlink_path = false;
 783         const char *data;
 784         siginfo_t st;
 785         size_t len;
 786         pid_t pid;
 787         int r;
 788
 789         assert(j);
 790
 791         r = focus(j);
 792         if (r < 0)
 793                 return r;
 794
 795         print_info(stdout, j, false);
 796         fputs("\n", stdout);
 797
 798         r = sd_journal_get_data(j, "COREDUMP_EXE", (const void**) &data, &len);
 799         if (r < 0)
 800                 return log_error_errno(r, "Failed to retrieve COREDUMP_EXE field: %m");
 801
 802         assert(len > strlen("COREDUMP_EXE="));
 803         data += strlen("COREDUMP_EXE=");
 804         len -= strlen("COREDUMP_EXE=");
 805
 806         exe = strndup(data, len);
 807         if (!exe)
 808                 return log_oom();
 809
 810         if (endswith(exe, " (deleted)")) {
 811                 log_error("Binary already deleted.");
 812                 return -ENOENT;
 813         }
 814
 815         if (!path_is_absolute(exe)) {
 816                 log_error("Binary is not an absolute path.");
 817                 return -ENOENT;
 818         }
 819
 820         r = save_core(j, NULL, &path, &unlink_path);
 821         if (r < 0)
 822                 return r;
 823
 824         pid = fork();
 825         if (pid < 0) {
 826                 r = log_error_errno(errno, "Failed to fork(): %m");
 827                 goto finish;
 828         }
 829         if (pid == 0) {
 830                 (void) reset_all_signal_handlers();
 831                 (void) reset_signal_mask();
 832
 833                 execlp("gdb", "gdb", exe, path, NULL);
 834
 835                 log_error_errno(errno, "Failed to invoke gdb: %m");
 836                 _exit(1);
 837         }
 838
 839         r = wait_for_terminate(pid, &st);
 840         if (r < 0) {
 841                 log_error_errno(r, "Failed to wait for gdb: %m");
 842                 goto finish;
 843         }
 844
 845         r = st.si_code == CLD_EXITED ? st.si_status : 255;
 846
 847 finish:
 848         if (unlink_path) {
 849                 log_debug("Removed temporary file %s", path);
 850                 unlink(path);
 851         }
 852
 853         return r;
 854 }
 855
 856 int main(int argc, char *argv[]) {
 857         _cleanup_(sd_journal_closep) sd_journal*j = NULL;
 858         const char* match;
 859         Iterator it;
 860         int r = 0;
 861         _cleanup_set_free_free_ Set *matches = NULL;
 862
 863         setlocale(LC_ALL, "");
 864         log_parse_environment();
 865         log_open();
 866
 867         matches = new_matches();
 868         if (!matches) {
 869                 r = -ENOMEM;
 870                 goto end;
 871         }
 872
 873         r = parse_argv(argc, argv, matches);
 874         if (r < 0)
 875                 goto end;
 876
 877         if (arg_action == ACTION_NONE)
 878                 goto end;
 879
 880         sigbus_install();
 881
 882         if (arg_directory) {
 883                 r = sd_journal_open_directory(&j, arg_directory, 0);
 884                 if (r < 0) {
 885                         log_error_errno(r, "Failed to open journals in directory: %s: %m", arg_directory);
 886                         goto end;
 887                 }
 888         } else {
 889                 r = sd_journal_open(&j, SD_JOURNAL_LOCAL_ONLY);
 890                 if (r < 0) {
 891                         log_error_errno(r, "Failed to open journal: %m");
 892                         goto end;
 893                 }
 894         }
 895
 896         SET_FOREACH(match, matches, it) {
 897                 r = sd_journal_add_match(j, match, strlen(match));
 898                 if (r != 0) {
 899                         log_error_errno(r, "Failed to add match '%s': %m",
 900                                         match);
 901                         goto end;
 902                 }
 903         }
 904
 905         if (_unlikely_(log_get_max_level() >= LOG_DEBUG)) {
 906                 _cleanup_free_ char *filter;
 907
 908                 filter = journal_make_match_string(j);
 909                 log_debug("Journal filter: %s", filter);
 910         }
 911
 912         switch(arg_action) {
 913
 914         case ACTION_LIST:
 915         case ACTION_INFO:
 916                 pager_open(arg_no_pager, false);
 917                 r = dump_list(j);
 918                 break;
 919
 920         case ACTION_DUMP:
 921                 r = dump_core(j);
 922                 break;
 923
 924         case  ACTION_GDB:
 925                 r = run_gdb(j);
 926                 break;
 927
 928         default:
 929                 assert_not_reached("Shouldn't be here");
 930         }
 931
 932 end:
 933         pager_close();
 934
 935         if (arg_output)
 936                 fclose(arg_output);
 937
 938         return r >= 0 ? r : EXIT_FAILURE;
 939 }