]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/journal/journalctl.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
tree-wide: use memstream-util
[thirdparty/systemd.git] / src / journal / journalctl.c
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include <errno.h>
4 #include <fcntl.h>
5 #include <fnmatch.h>
6 #include <getopt.h>
7 #include <linux/fs.h>
8 #include <signal.h>
9 #include <stddef.h>
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <sys/inotify.h>
13 #include <sys/stat.h>
14 #include <unistd.h>
15
16 #include "sd-bus.h"
17 #include "sd-device.h"
18 #include "sd-journal.h"
19
20 #include "acl-util.h"
21 #include "alloc-util.h"
22 #include "build.h"
23 #include "bus-error.h"
24 #include "bus-locator.h"
25 #include "bus-util.h"
26 #include "catalog.h"
27 #include "chase.h"
28 #include "chattr-util.h"
29 #include "constants.h"
30 #include "devnum-util.h"
31 #include "dissect-image.h"
32 #include "fd-util.h"
33 #include "fileio.h"
34 #include "format-table.h"
35 #include "format-util.h"
36 #include "fs-util.h"
37 #include "fsprg.h"
38 #include "glob-util.h"
39 #include "hostname-util.h"
40 #include "id128-print.h"
41 #include "io-util.h"
42 #include "journal-def.h"
43 #include "journal-internal.h"
44 #include "journal-util.h"
45 #include "journal-vacuum.h"
46 #include "journal-verify.h"
47 #include "locale-util.h"
48 #include "log.h"
49 #include "logs-show.h"
50 #include "main-func.h"
51 #include "memory-util.h"
52 #include "memstream-util.h"
53 #include "missing_sched.h"
54 #include "mkdir.h"
55 #include "mount-util.h"
56 #include "mountpoint-util.h"
57 #include "nulstr-util.h"
58 #include "pager.h"
59 #include "parse-argument.h"
60 #include "parse-util.h"
61 #include "path-util.h"
62 #include "pcre2-util.h"
63 #include "pretty-print.h"
64 #include "qrcode-util.h"
65 #include "random-util.h"
66 #include "rlimit-util.h"
67 #include "set.h"
68 #include "sigbus.h"
69 #include "signal-util.h"
70 #include "static-destruct.h"
71 #include "stdio-util.h"
72 #include "string-table.h"
73 #include "strv.h"
74 #include "syslog-util.h"
75 #include "terminal-util.h"
76 #include "tmpfile-util.h"
77 #include "unit-name.h"
78 #include "user-util.h"
79 #include "varlink.h"
80
81 #define DEFAULT_FSS_INTERVAL_USEC (15*USEC_PER_MINUTE)
82 #define PROCESS_INOTIFY_INTERVAL 1024 /* Every 1,024 messages processed */
83
84 enum {
85 /* Special values for arg_lines */
86 ARG_LINES_DEFAULT = -2,
87 ARG_LINES_ALL = -1,
88 };
89
90 static OutputMode arg_output = OUTPUT_SHORT;
91 static JsonFormatFlags arg_json_format_flags = JSON_FORMAT_OFF;
92 static bool arg_utc = false;
93 static bool arg_follow = false;
94 static bool arg_full = true;
95 static bool arg_all = false;
96 static PagerFlags arg_pager_flags = 0;
97 static int arg_lines = ARG_LINES_DEFAULT;
98 static bool arg_no_tail = false;
99 static bool arg_quiet = false;
100 static bool arg_merge = false;
101 static bool arg_boot = false;
102 static sd_id128_t arg_boot_id = {};
103 static int arg_boot_offset = 0;
104 static bool arg_dmesg = false;
105 static bool arg_no_hostname = false;
106 static const char *arg_cursor = NULL;
107 static const char *arg_cursor_file = NULL;
108 static const char *arg_after_cursor = NULL;
109 static bool arg_show_cursor = false;
110 static const char *arg_directory = NULL;
111 static char **arg_file = NULL;
112 static bool arg_file_stdin = false;
113 static int arg_priorities = 0xFF;
114 static Set *arg_facilities = NULL;
115 static char *arg_verify_key = NULL;
116 #if HAVE_GCRYPT
117 static usec_t arg_interval = DEFAULT_FSS_INTERVAL_USEC;
118 static bool arg_force = false;
119 #endif
120 static usec_t arg_since = 0, arg_until = 0;
121 static bool arg_since_set = false, arg_until_set = false;
122 static char **arg_syslog_identifier = NULL;
123 static char **arg_system_units = NULL;
124 static char **arg_user_units = NULL;
125 static const char *arg_field = NULL;
126 static bool arg_catalog = false;
127 static bool arg_reverse = false;
128 static int arg_journal_type = 0;
129 static int arg_namespace_flags = 0;
130 static char *arg_root = NULL;
131 static char *arg_image = NULL;
132 static const char *arg_machine = NULL;
133 static const char *arg_namespace = NULL;
134 static uint64_t arg_vacuum_size = 0;
135 static uint64_t arg_vacuum_n_files = 0;
136 static usec_t arg_vacuum_time = 0;
137 static Set *arg_output_fields = NULL;
138 static const char *arg_pattern = NULL;
139 static pcre2_code *arg_compiled_pattern = NULL;
140 static PatternCompileCase arg_case = PATTERN_COMPILE_CASE_AUTO;
141 ImagePolicy *arg_image_policy = NULL;
142
143 STATIC_DESTRUCTOR_REGISTER(arg_file, strv_freep);
144 STATIC_DESTRUCTOR_REGISTER(arg_facilities, set_freep);
145 STATIC_DESTRUCTOR_REGISTER(arg_verify_key, freep);
146 STATIC_DESTRUCTOR_REGISTER(arg_syslog_identifier, strv_freep);
147 STATIC_DESTRUCTOR_REGISTER(arg_system_units, strv_freep);
148 STATIC_DESTRUCTOR_REGISTER(arg_user_units, strv_freep);
149 STATIC_DESTRUCTOR_REGISTER(arg_root, freep);
150 STATIC_DESTRUCTOR_REGISTER(arg_image, freep);
151 STATIC_DESTRUCTOR_REGISTER(arg_output_fields, set_freep);
152 STATIC_DESTRUCTOR_REGISTER(arg_compiled_pattern, pattern_freep);
153 STATIC_DESTRUCTOR_REGISTER(arg_image_policy, image_policy_freep);
154
155 static enum {
156 ACTION_SHOW,
157 ACTION_NEW_ID128,
158 ACTION_PRINT_HEADER,
159 ACTION_SETUP_KEYS,
160 ACTION_VERIFY,
161 ACTION_DISK_USAGE,
162 ACTION_LIST_CATALOG,
163 ACTION_DUMP_CATALOG,
164 ACTION_UPDATE_CATALOG,
165 ACTION_LIST_BOOTS,
166 ACTION_FLUSH,
167 ACTION_RELINQUISH_VAR,
168 ACTION_SYNC,
169 ACTION_ROTATE,
170 ACTION_VACUUM,
171 ACTION_ROTATE_AND_VACUUM,
172 ACTION_LIST_FIELDS,
173 ACTION_LIST_FIELD_NAMES,
174 } arg_action = ACTION_SHOW;
175
176 typedef struct BootId {
177 sd_id128_t id;
178 usec_t first_usec;
179 usec_t last_usec;
180 } BootId;
181
182 static int add_matches_for_device(sd_journal *j, const char *devpath) {
183 _cleanup_(sd_device_unrefp) sd_device *device = NULL;
184 sd_device *d = NULL;
185 struct stat st;
186 int r;
187
188 assert(j);
189 assert(devpath);
190
191 if (!path_startswith(devpath, "/dev/"))
192 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
193 "Devpath does not start with /dev/");
194
195 if (stat(devpath, &st) < 0)
196 return log_error_errno(errno, "Couldn't stat file: %m");
197
198 r = sd_device_new_from_stat_rdev(&device, &st);
199 if (r < 0)
200 return log_error_errno(r, "Failed to get device from devnum " DEVNUM_FORMAT_STR ": %m", DEVNUM_FORMAT_VAL(st.st_rdev));
201
202 for (d = device; d; ) {
203 _cleanup_free_ char *match = NULL;
204 const char *subsys, *sysname, *devnode;
205 sd_device *parent;
206
207 r = sd_device_get_subsystem(d, &subsys);
208 if (r < 0)
209 goto get_parent;
210
211 r = sd_device_get_sysname(d, &sysname);
212 if (r < 0)
213 goto get_parent;
214
215 match = strjoin("_KERNEL_DEVICE=+", subsys, ":", sysname);
216 if (!match)
217 return log_oom();
218
219 r = sd_journal_add_match(j, match, 0);
220 if (r < 0)
221 return log_error_errno(r, "Failed to add match: %m");
222
223 if (sd_device_get_devname(d, &devnode) >= 0) {
224 _cleanup_free_ char *match1 = NULL;
225
226 r = stat(devnode, &st);
227 if (r < 0)
228 return log_error_errno(r, "Failed to stat() device node \"%s\": %m", devnode);
229
230 r = asprintf(&match1, "_KERNEL_DEVICE=%c" DEVNUM_FORMAT_STR, S_ISBLK(st.st_mode) ? 'b' : 'c', DEVNUM_FORMAT_VAL(st.st_rdev));
231 if (r < 0)
232 return log_oom();
233
234 r = sd_journal_add_match(j, match1, 0);
235 if (r < 0)
236 return log_error_errno(r, "Failed to add match: %m");
237 }
238
239 get_parent:
240 if (sd_device_get_parent(d, &parent) < 0)
241 break;
242
243 d = parent;
244 }
245
246 r = add_match_this_boot(j, arg_machine);
247 if (r < 0)
248 return log_error_errno(r, "Failed to add match for the current boot: %m");
249
250 return 0;
251 }
252
253 static char *format_timestamp_maybe_utc(char *buf, size_t l, usec_t t) {
254
255 if (arg_utc)
256 return format_timestamp_style(buf, l, t, TIMESTAMP_UTC);
257
258 return format_timestamp(buf, l, t);
259 }
260
261 static int parse_boot_descriptor(const char *x, sd_id128_t *boot_id, int *offset) {
262 sd_id128_t id = SD_ID128_NULL;
263 int off = 0, r;
264
265 if (streq(x, "all")) {
266 *boot_id = SD_ID128_NULL;
267 *offset = 0;
268 return 0;
269 } else if (strlen(x) >= SD_ID128_STRING_MAX - 1) {
270 char *t;
271
272 t = strndupa_safe(x, SD_ID128_STRING_MAX - 1);
273 r = sd_id128_from_string(t, &id);
274 if (r >= 0)
275 x += SD_ID128_STRING_MAX - 1;
276
277 if (!IN_SET(*x, 0, '-', '+'))
278 return -EINVAL;
279
280 if (*x != 0) {
281 r = safe_atoi(x, &off);
282 if (r < 0)
283 return r;
284 }
285 } else {
286 r = safe_atoi(x, &off);
287 if (r < 0)
288 return r;
289 }
290
291 if (boot_id)
292 *boot_id = id;
293
294 if (offset)
295 *offset = off;
296
297 return 1;
298 }
299
300 static int help_facilities(void) {
301 if (!arg_quiet)
302 puts("Available facilities:");
303
304 for (int i = 0; i < LOG_NFACILITIES; i++) {
305 _cleanup_free_ char *t = NULL;
306
307 if (log_facility_unshifted_to_string_alloc(i, &t))
308 return log_oom();
309 puts(t);
310 }
311
312 return 0;
313 }
314
315 static int help(void) {
316 _cleanup_free_ char *link = NULL;
317 int r;
318
319 pager_open(arg_pager_flags);
320
321 r = terminal_urlify_man("journalctl", "1", &link);
322 if (r < 0)
323 return log_oom();
324
325 printf("%1$s [OPTIONS...] [MATCHES...]\n\n"
326 "%5$sQuery the journal.%6$s\n\n"
327 "%3$sSource Options:%4$s\n"
328 " --system Show the system journal\n"
329 " --user Show the user journal for the current user\n"
330 " -M --machine=CONTAINER Operate on local container\n"
331 " -m --merge Show entries from all available journals\n"
332 " -D --directory=PATH Show journal files from directory\n"
333 " --file=PATH Show journal file\n"
334 " --root=PATH Operate on an alternate filesystem root\n"
335 " --image=PATH Operate on disk image as filesystem root\n"
336 " --image-policy=POLICY Specify disk image dissection policy\n"
337 " --namespace=NAMESPACE Show journal data from specified journal namespace\n"
338 "\n%3$sFiltering Options:%4$s\n"
339 " -S --since=DATE Show entries not older than the specified date\n"
340 " -U --until=DATE Show entries not newer than the specified date\n"
341 " -c --cursor=CURSOR Show entries starting at the specified cursor\n"
342 " --after-cursor=CURSOR Show entries after the specified cursor\n"
343 " --cursor-file=FILE Show entries after cursor in FILE and update FILE\n"
344 " -b --boot[=ID] Show current boot or the specified boot\n"
345 " -u --unit=UNIT Show logs from the specified unit\n"
346 " --user-unit=UNIT Show logs from the specified user unit\n"
347 " -t --identifier=STRING Show entries with the specified syslog identifier\n"
348 " -p --priority=RANGE Show entries with the specified priority\n"
349 " --facility=FACILITY... Show entries with the specified facilities\n"
350 " -g --grep=PATTERN Show entries with MESSAGE matching PATTERN\n"
351 " --case-sensitive[=BOOL] Force case sensitive or insensitive matching\n"
352 " -k --dmesg Show kernel message log from the current boot\n"
353 "\n%3$sOutput Control Options:%4$s\n"
354 " -o --output=STRING Change journal output mode (short, short-precise,\n"
355 " short-iso, short-iso-precise, short-full,\n"
356 " short-monotonic, short-unix, verbose, export,\n"
357 " json, json-pretty, json-sse, json-seq, cat,\n"
358 " with-unit)\n"
359 " --output-fields=LIST Select fields to print in verbose/export/json modes\n"
360 " -n --lines[=INTEGER] Number of journal entries to show\n"
361 " -r --reverse Show the newest entries first\n"
362 " --show-cursor Print the cursor after all the entries\n"
363 " --utc Express time in Coordinated Universal Time (UTC)\n"
364 " -x --catalog Add message explanations where available\n"
365 " --no-hostname Suppress output of hostname field\n"
366 " --no-full Ellipsize fields\n"
367 " -a --all Show all fields, including long and unprintable\n"
368 " -f --follow Follow the journal\n"
369 " --no-tail Show all lines, even in follow mode\n"
370 " -q --quiet Do not show info messages and privilege warning\n"
371 "\n%3$sPager Control Options:%4$s\n"
372 " --no-pager Do not pipe output into a pager\n"
373 " -e --pager-end Immediately jump to the end in the pager\n"
374 "\n%3$sForward Secure Sealing (FSS) Options:%4$s\n"
375 " --interval=TIME Time interval for changing the FSS sealing key\n"
376 " --verify-key=KEY Specify FSS verification key\n"
377 " --force Override of the FSS key pair with --setup-keys\n"
378 "\n%3$sCommands:%4$s\n"
379 " -h --help Show this help text\n"
380 " --version Show package version\n"
381 " -N --fields List all field names currently used\n"
382 " -F --field=FIELD List all values that a specified field takes\n"
383 " --list-boots Show terse information about recorded boots\n"
384 " --disk-usage Show total disk usage of all journal files\n"
385 " --vacuum-size=BYTES Reduce disk usage below specified size\n"
386 " --vacuum-files=INT Leave only the specified number of journal files\n"
387 " --vacuum-time=TIME Remove journal files older than specified time\n"
388 " --verify Verify journal file consistency\n"
389 " --sync Synchronize unwritten journal messages to disk\n"
390 " --relinquish-var Stop logging to disk, log to temporary file system\n"
391 " --smart-relinquish-var Similar, but NOP if log directory is on root mount\n"
392 " --flush Flush all journal data from /run into /var\n"
393 " --rotate Request immediate rotation of the journal files\n"
394 " --header Show journal header information\n"
395 " --list-catalog Show all message IDs in the catalog\n"
396 " --dump-catalog Show entries in the message catalog\n"
397 " --update-catalog Update the message catalog database\n"
398 " --setup-keys Generate a new FSS key pair\n"
399 "\nSee the %2$s for details.\n",
400 program_invocation_short_name,
401 link,
402 ansi_underline(),
403 ansi_normal(),
404 ansi_highlight(),
405 ansi_normal());
406
407 return 0;
408 }
409
410 static int parse_argv(int argc, char *argv[]) {
411
412 enum {
413 ARG_VERSION = 0x100,
414 ARG_NO_PAGER,
415 ARG_NO_FULL,
416 ARG_NO_TAIL,
417 ARG_NEW_ID128,
418 ARG_THIS_BOOT,
419 ARG_LIST_BOOTS,
420 ARG_USER,
421 ARG_SYSTEM,
422 ARG_ROOT,
423 ARG_IMAGE,
424 ARG_IMAGE_POLICY,
425 ARG_HEADER,
426 ARG_FACILITY,
427 ARG_SETUP_KEYS,
428 ARG_FILE,
429 ARG_INTERVAL,
430 ARG_VERIFY,
431 ARG_VERIFY_KEY,
432 ARG_DISK_USAGE,
433 ARG_AFTER_CURSOR,
434 ARG_CURSOR_FILE,
435 ARG_SHOW_CURSOR,
436 ARG_USER_UNIT,
437 ARG_LIST_CATALOG,
438 ARG_DUMP_CATALOG,
439 ARG_UPDATE_CATALOG,
440 ARG_FORCE,
441 ARG_CASE_SENSITIVE,
442 ARG_UTC,
443 ARG_SYNC,
444 ARG_FLUSH,
445 ARG_RELINQUISH_VAR,
446 ARG_SMART_RELINQUISH_VAR,
447 ARG_ROTATE,
448 ARG_VACUUM_SIZE,
449 ARG_VACUUM_FILES,
450 ARG_VACUUM_TIME,
451 ARG_NO_HOSTNAME,
452 ARG_OUTPUT_FIELDS,
453 ARG_NAMESPACE,
454 };
455
456 static const struct option options[] = {
457 { "help", no_argument, NULL, 'h' },
458 { "version" , no_argument, NULL, ARG_VERSION },
459 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
460 { "pager-end", no_argument, NULL, 'e' },
461 { "follow", no_argument, NULL, 'f' },
462 { "force", no_argument, NULL, ARG_FORCE },
463 { "output", required_argument, NULL, 'o' },
464 { "all", no_argument, NULL, 'a' },
465 { "full", no_argument, NULL, 'l' },
466 { "no-full", no_argument, NULL, ARG_NO_FULL },
467 { "lines", optional_argument, NULL, 'n' },
468 { "no-tail", no_argument, NULL, ARG_NO_TAIL },
469 { "new-id128", no_argument, NULL, ARG_NEW_ID128 }, /* deprecated */
470 { "quiet", no_argument, NULL, 'q' },
471 { "merge", no_argument, NULL, 'm' },
472 { "this-boot", no_argument, NULL, ARG_THIS_BOOT }, /* deprecated */
473 { "boot", optional_argument, NULL, 'b' },
474 { "list-boots", no_argument, NULL, ARG_LIST_BOOTS },
475 { "dmesg", no_argument, NULL, 'k' },
476 { "system", no_argument, NULL, ARG_SYSTEM },
477 { "user", no_argument, NULL, ARG_USER },
478 { "directory", required_argument, NULL, 'D' },
479 { "file", required_argument, NULL, ARG_FILE },
480 { "root", required_argument, NULL, ARG_ROOT },
481 { "image", required_argument, NULL, ARG_IMAGE },
482 { "image-policy", required_argument, NULL, ARG_IMAGE_POLICY },
483 { "header", no_argument, NULL, ARG_HEADER },
484 { "identifier", required_argument, NULL, 't' },
485 { "priority", required_argument, NULL, 'p' },
486 { "facility", required_argument, NULL, ARG_FACILITY },
487 { "grep", required_argument, NULL, 'g' },
488 { "case-sensitive", optional_argument, NULL, ARG_CASE_SENSITIVE },
489 { "setup-keys", no_argument, NULL, ARG_SETUP_KEYS },
490 { "interval", required_argument, NULL, ARG_INTERVAL },
491 { "verify", no_argument, NULL, ARG_VERIFY },
492 { "verify-key", required_argument, NULL, ARG_VERIFY_KEY },
493 { "disk-usage", no_argument, NULL, ARG_DISK_USAGE },
494 { "cursor", required_argument, NULL, 'c' },
495 { "cursor-file", required_argument, NULL, ARG_CURSOR_FILE },
496 { "after-cursor", required_argument, NULL, ARG_AFTER_CURSOR },
497 { "show-cursor", no_argument, NULL, ARG_SHOW_CURSOR },
498 { "since", required_argument, NULL, 'S' },
499 { "until", required_argument, NULL, 'U' },
500 { "unit", required_argument, NULL, 'u' },
501 { "user-unit", required_argument, NULL, ARG_USER_UNIT },
502 { "field", required_argument, NULL, 'F' },
503 { "fields", no_argument, NULL, 'N' },
504 { "catalog", no_argument, NULL, 'x' },
505 { "list-catalog", no_argument, NULL, ARG_LIST_CATALOG },
506 { "dump-catalog", no_argument, NULL, ARG_DUMP_CATALOG },
507 { "update-catalog", no_argument, NULL, ARG_UPDATE_CATALOG },
508 { "reverse", no_argument, NULL, 'r' },
509 { "machine", required_argument, NULL, 'M' },
510 { "utc", no_argument, NULL, ARG_UTC },
511 { "flush", no_argument, NULL, ARG_FLUSH },
512 { "relinquish-var", no_argument, NULL, ARG_RELINQUISH_VAR },
513 { "smart-relinquish-var", no_argument, NULL, ARG_SMART_RELINQUISH_VAR },
514 { "sync", no_argument, NULL, ARG_SYNC },
515 { "rotate", no_argument, NULL, ARG_ROTATE },
516 { "vacuum-size", required_argument, NULL, ARG_VACUUM_SIZE },
517 { "vacuum-files", required_argument, NULL, ARG_VACUUM_FILES },
518 { "vacuum-time", required_argument, NULL, ARG_VACUUM_TIME },
519 { "no-hostname", no_argument, NULL, ARG_NO_HOSTNAME },
520 { "output-fields", required_argument, NULL, ARG_OUTPUT_FIELDS },
521 { "namespace", required_argument, NULL, ARG_NAMESPACE },
522 {}
523 };
524
525 int c, r;
526
527 assert(argc >= 0);
528 assert(argv);
529
530 while ((c = getopt_long(argc, argv, "hefo:aln::qmb::kD:p:g:c:S:U:t:u:NF:xrM:", options, NULL)) >= 0)
531
532 switch (c) {
533
534 case 'h':
535 return help();
536
537 case ARG_VERSION:
538 return version();
539
540 case ARG_NO_PAGER:
541 arg_pager_flags |= PAGER_DISABLE;
542 break;
543
544 case 'e':
545 arg_pager_flags |= PAGER_JUMP_TO_END;
546
547 if (arg_lines == ARG_LINES_DEFAULT)
548 arg_lines = 1000;
549
550 arg_boot = true;
551
552 break;
553
554 case 'f':
555 arg_follow = true;
556 break;
557
558 case 'o':
559 if (streq(optarg, "help")) {
560 DUMP_STRING_TABLE(output_mode, OutputMode, _OUTPUT_MODE_MAX);
561 return 0;
562 }
563
564 arg_output = output_mode_from_string(optarg);
565 if (arg_output < 0)
566 return log_error_errno(arg_output, "Unknown output format '%s'.", optarg);
567
568 if (IN_SET(arg_output, OUTPUT_EXPORT, OUTPUT_JSON, OUTPUT_JSON_PRETTY, OUTPUT_JSON_SSE, OUTPUT_JSON_SEQ, OUTPUT_CAT))
569 arg_quiet = true;
570
571 if (OUTPUT_MODE_IS_JSON(arg_output))
572 arg_json_format_flags = output_mode_to_json_format_flags(arg_output) | JSON_FORMAT_COLOR_AUTO;
573 else
574 arg_json_format_flags = JSON_FORMAT_OFF;
575
576 break;
577
578 case 'l':
579 arg_full = true;
580 break;
581
582 case ARG_NO_FULL:
583 arg_full = false;
584 break;
585
586 case 'a':
587 arg_all = true;
588 break;
589
590 case 'n':
591 if (optarg) {
592 if (streq(optarg, "all"))
593 arg_lines = ARG_LINES_ALL;
594 else {
595 r = safe_atoi(optarg, &arg_lines);
596 if (r < 0 || arg_lines < 0)
597 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse lines '%s'", optarg);
598 }
599 } else {
600 arg_lines = 10;
601
602 /* Hmm, no argument? Maybe the next
603 * word on the command line is
604 * supposed to be the argument? Let's
605 * see if there is one, and is
606 * parsable. */
607 if (optind < argc) {
608 int n;
609 if (streq(argv[optind], "all")) {
610 arg_lines = ARG_LINES_ALL;
611 optind++;
612 } else if (safe_atoi(argv[optind], &n) >= 0 && n >= 0) {
613 arg_lines = n;
614 optind++;
615 }
616 }
617 }
618
619 break;
620
621 case ARG_NO_TAIL:
622 arg_no_tail = true;
623 break;
624
625 case ARG_NEW_ID128:
626 arg_action = ACTION_NEW_ID128;
627 break;
628
629 case 'q':
630 arg_quiet = true;
631 break;
632
633 case 'm':
634 arg_merge = true;
635 break;
636
637 case ARG_THIS_BOOT:
638 arg_boot = true;
639 arg_boot_id = SD_ID128_NULL;
640 arg_boot_offset = 0;
641 break;
642
643 case 'b':
644 arg_boot = true;
645 arg_boot_id = SD_ID128_NULL;
646 arg_boot_offset = 0;
647
648 if (optarg) {
649 r = parse_boot_descriptor(optarg, &arg_boot_id, &arg_boot_offset);
650 if (r < 0)
651 return log_error_errno(r, "Failed to parse boot descriptor '%s'", optarg);
652
653 arg_boot = r;
654
655 /* Hmm, no argument? Maybe the next
656 * word on the command line is
657 * supposed to be the argument? Let's
658 * see if there is one and is parsable
659 * as a boot descriptor... */
660 } else if (optind < argc) {
661 r = parse_boot_descriptor(argv[optind], &arg_boot_id, &arg_boot_offset);
662 if (r >= 0) {
663 arg_boot = r;
664 optind++;
665 }
666 }
667 break;
668
669 case ARG_LIST_BOOTS:
670 arg_action = ACTION_LIST_BOOTS;
671 break;
672
673 case 'k':
674 arg_boot = arg_dmesg = true;
675 break;
676
677 case ARG_SYSTEM:
678 arg_journal_type |= SD_JOURNAL_SYSTEM;
679 break;
680
681 case ARG_USER:
682 arg_journal_type |= SD_JOURNAL_CURRENT_USER;
683 break;
684
685 case 'M':
686 arg_machine = optarg;
687 break;
688
689 case ARG_NAMESPACE:
690 if (streq(optarg, "*")) {
691 arg_namespace_flags = SD_JOURNAL_ALL_NAMESPACES;
692 arg_namespace = NULL;
693 } else if (startswith(optarg, "+")) {
694 arg_namespace_flags = SD_JOURNAL_INCLUDE_DEFAULT_NAMESPACE;
695 arg_namespace = optarg + 1;
696 } else if (isempty(optarg)) {
697 arg_namespace_flags = 0;
698 arg_namespace = NULL;
699 } else {
700 arg_namespace_flags = 0;
701 arg_namespace = optarg;
702 }
703
704 break;
705
706 case 'D':
707 arg_directory = optarg;
708 break;
709
710 case ARG_FILE:
711 if (streq(optarg, "-"))
712 /* An undocumented feature: we can read journal files from STDIN. We don't document
713 * this though, since after all we only support this for mmap-able, seekable files, and
714 * not for example pipes which are probably the primary usecase for reading things from
715 * STDIN. To avoid confusion we hence don't document this feature. */
716 arg_file_stdin = true;
717 else {
718 r = glob_extend(&arg_file, optarg, GLOB_NOCHECK);
719 if (r < 0)
720 return log_error_errno(r, "Failed to add paths: %m");
721 }
722 break;
723
724 case ARG_ROOT:
725 r = parse_path_argument(optarg, /* suppress_root= */ true, &arg_root);
726 if (r < 0)
727 return r;
728 break;
729
730 case ARG_IMAGE:
731 r = parse_path_argument(optarg, /* suppress_root= */ false, &arg_image);
732 if (r < 0)
733 return r;
734 break;
735
736 case ARG_IMAGE_POLICY:
737 r = parse_image_policy_argument(optarg, &arg_image_policy);
738 if (r < 0)
739 return r;
740 break;
741
742 case 'c':
743 arg_cursor = optarg;
744 break;
745
746 case ARG_CURSOR_FILE:
747 arg_cursor_file = optarg;
748 break;
749
750 case ARG_AFTER_CURSOR:
751 arg_after_cursor = optarg;
752 break;
753
754 case ARG_SHOW_CURSOR:
755 arg_show_cursor = true;
756 break;
757
758 case ARG_HEADER:
759 arg_action = ACTION_PRINT_HEADER;
760 break;
761
762 case ARG_VERIFY:
763 arg_action = ACTION_VERIFY;
764 break;
765
766 case ARG_DISK_USAGE:
767 arg_action = ACTION_DISK_USAGE;
768 break;
769
770 case ARG_VACUUM_SIZE:
771 r = parse_size(optarg, 1024, &arg_vacuum_size);
772 if (r < 0)
773 return log_error_errno(r, "Failed to parse vacuum size: %s", optarg);
774
775 arg_action = arg_action == ACTION_ROTATE ? ACTION_ROTATE_AND_VACUUM : ACTION_VACUUM;
776 break;
777
778 case ARG_VACUUM_FILES:
779 r = safe_atou64(optarg, &arg_vacuum_n_files);
780 if (r < 0)
781 return log_error_errno(r, "Failed to parse vacuum files: %s", optarg);
782
783 arg_action = arg_action == ACTION_ROTATE ? ACTION_ROTATE_AND_VACUUM : ACTION_VACUUM;
784 break;
785
786 case ARG_VACUUM_TIME:
787 r = parse_sec(optarg, &arg_vacuum_time);
788 if (r < 0)
789 return log_error_errno(r, "Failed to parse vacuum time: %s", optarg);
790
791 arg_action = arg_action == ACTION_ROTATE ? ACTION_ROTATE_AND_VACUUM : ACTION_VACUUM;
792 break;
793
794 #if HAVE_GCRYPT
795 case ARG_FORCE:
796 arg_force = true;
797 break;
798
799 case ARG_SETUP_KEYS:
800 arg_action = ACTION_SETUP_KEYS;
801 break;
802
803 case ARG_VERIFY_KEY:
804 r = free_and_strdup(&arg_verify_key, optarg);
805 if (r < 0)
806 return r;
807 /* Use memset not explicit_bzero() or similar so this doesn't look confusing
808 * in ps or htop output. */
809 memset(optarg, 'x', strlen(optarg));
810
811 arg_action = ACTION_VERIFY;
812 arg_merge = false;
813 break;
814
815 case ARG_INTERVAL:
816 r = parse_sec(optarg, &arg_interval);
817 if (r < 0 || arg_interval <= 0)
818 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
819 "Failed to parse sealing key change interval: %s", optarg);
820 break;
821 #else
822 case ARG_SETUP_KEYS:
823 case ARG_VERIFY_KEY:
824 case ARG_INTERVAL:
825 case ARG_FORCE:
826 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
827 "Compiled without forward-secure sealing support.");
828 #endif
829
830 case 'p': {
831 const char *dots;
832
833 dots = strstr(optarg, "..");
834 if (dots) {
835 _cleanup_free_ char *a = NULL;
836 int from, to, i;
837
838 /* a range */
839 a = strndup(optarg, dots - optarg);
840 if (!a)
841 return log_oom();
842
843 from = log_level_from_string(a);
844 to = log_level_from_string(dots + 2);
845
846 if (from < 0 || to < 0)
847 return log_error_errno(from < 0 ? from : to,
848 "Failed to parse log level range %s", optarg);
849
850 arg_priorities = 0;
851
852 if (from < to) {
853 for (i = from; i <= to; i++)
854 arg_priorities |= 1 << i;
855 } else {
856 for (i = to; i <= from; i++)
857 arg_priorities |= 1 << i;
858 }
859
860 } else {
861 int p, i;
862
863 p = log_level_from_string(optarg);
864 if (p < 0)
865 return log_error_errno(p, "Unknown log level %s", optarg);
866
867 arg_priorities = 0;
868
869 for (i = 0; i <= p; i++)
870 arg_priorities |= 1 << i;
871 }
872
873 break;
874 }
875
876 case ARG_FACILITY: {
877 const char *p;
878
879 for (p = optarg;;) {
880 _cleanup_free_ char *fac = NULL;
881 int num;
882
883 r = extract_first_word(&p, &fac, ",", 0);
884 if (r < 0)
885 return log_error_errno(r, "Failed to parse facilities: %s", optarg);
886 if (r == 0)
887 break;
888
889 if (streq(fac, "help")) {
890 help_facilities();
891 return 0;
892 }
893
894 num = log_facility_unshifted_from_string(fac);
895 if (num < 0)
896 return log_error_errno(num, "Bad --facility= argument \"%s\".", fac);
897
898 if (set_ensure_put(&arg_facilities, NULL, INT_TO_PTR(num)) < 0)
899 return log_oom();
900 }
901
902 break;
903 }
904
905 case 'g':
906 arg_pattern = optarg;
907 break;
908
909 case ARG_CASE_SENSITIVE:
910 if (optarg) {
911 r = parse_boolean(optarg);
912 if (r < 0)
913 return log_error_errno(r, "Bad --case-sensitive= argument \"%s\": %m", optarg);
914 arg_case = r ? PATTERN_COMPILE_CASE_SENSITIVE : PATTERN_COMPILE_CASE_INSENSITIVE;
915 } else
916 arg_case = PATTERN_COMPILE_CASE_SENSITIVE;
917
918 break;
919
920 case 'S':
921 r = parse_timestamp(optarg, &arg_since);
922 if (r < 0)
923 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
924 "Failed to parse timestamp: %s", optarg);
925 arg_since_set = true;
926 break;
927
928 case 'U':
929 r = parse_timestamp(optarg, &arg_until);
930 if (r < 0)
931 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
932 "Failed to parse timestamp: %s", optarg);
933 arg_until_set = true;
934 break;
935
936 case 't':
937 r = strv_extend(&arg_syslog_identifier, optarg);
938 if (r < 0)
939 return log_oom();
940 break;
941
942 case 'u':
943 r = strv_extend(&arg_system_units, optarg);
944 if (r < 0)
945 return log_oom();
946 break;
947
948 case ARG_USER_UNIT:
949 r = strv_extend(&arg_user_units, optarg);
950 if (r < 0)
951 return log_oom();
952 break;
953
954 case 'F':
955 arg_action = ACTION_LIST_FIELDS;
956 arg_field = optarg;
957 break;
958
959 case 'N':
960 arg_action = ACTION_LIST_FIELD_NAMES;
961 break;
962
963 case ARG_NO_HOSTNAME:
964 arg_no_hostname = true;
965 break;
966
967 case 'x':
968 arg_catalog = true;
969 break;
970
971 case ARG_LIST_CATALOG:
972 arg_action = ACTION_LIST_CATALOG;
973 break;
974
975 case ARG_DUMP_CATALOG:
976 arg_action = ACTION_DUMP_CATALOG;
977 break;
978
979 case ARG_UPDATE_CATALOG:
980 arg_action = ACTION_UPDATE_CATALOG;
981 break;
982
983 case 'r':
984 arg_reverse = true;
985 break;
986
987 case ARG_UTC:
988 arg_utc = true;
989 break;
990
991 case ARG_FLUSH:
992 arg_action = ACTION_FLUSH;
993 break;
994
995 case ARG_SMART_RELINQUISH_VAR: {
996 int root_mnt_id, log_mnt_id;
997
998 /* Try to be smart about relinquishing access to /var/log/journal/ during shutdown:
999 * if it's on the same mount as the root file system there's no point in
1000 * relinquishing access and we can leave journald write to it until the very last
1001 * moment. */
1002
1003 r = path_get_mnt_id("/", &root_mnt_id);
1004 if (r < 0)
1005 log_debug_errno(r, "Failed to get root mount ID, ignoring: %m");
1006 else {
1007 r = path_get_mnt_id("/var/log/journal/", &log_mnt_id);
1008 if (r < 0)
1009 log_debug_errno(r, "Failed to get journal directory mount ID, ignoring: %m");
1010 else if (root_mnt_id == log_mnt_id) {
1011 log_debug("/var/log/journal/ is on root file system, not relinquishing access to /var.");
1012 return 0;
1013 } else
1014 log_debug("/var/log/journal/ is not on the root file system, relinquishing access to it.");
1015 }
1016
1017 _fallthrough_;
1018 }
1019
1020 case ARG_RELINQUISH_VAR:
1021 arg_action = ACTION_RELINQUISH_VAR;
1022 break;
1023
1024 case ARG_ROTATE:
1025 arg_action = arg_action == ACTION_VACUUM ? ACTION_ROTATE_AND_VACUUM : ACTION_ROTATE;
1026 break;
1027
1028 case ARG_SYNC:
1029 arg_action = ACTION_SYNC;
1030 break;
1031
1032 case ARG_OUTPUT_FIELDS: {
1033 _cleanup_strv_free_ char **v = NULL;
1034
1035 v = strv_split(optarg, ",");
1036 if (!v)
1037 return log_oom();
1038
1039 r = set_put_strdupv(&arg_output_fields, v);
1040 if (r < 0)
1041 return log_oom();
1042
1043 break;
1044 }
1045 case '?':
1046 return -EINVAL;
1047
1048 default:
1049 assert_not_reached();
1050 }
1051
1052 if (arg_no_tail)
1053 arg_lines = ARG_LINES_ALL;
1054
1055 if (arg_follow && !arg_since_set && arg_lines == ARG_LINES_DEFAULT)
1056 arg_lines = 10;
1057
1058 if (arg_follow && !arg_merge && !arg_boot) {
1059 arg_boot = true;
1060 arg_boot_id = SD_ID128_NULL;
1061 arg_boot_offset = 0;
1062 }
1063
1064 if (!!arg_directory + !!arg_file + !!arg_machine + !!arg_root + !!arg_image > 1)
1065 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1066 "Please specify at most one of -D/--directory=, --file=, -M/--machine=, --root=, --image=.");
1067
1068 if (arg_since_set && arg_until_set && arg_since > arg_until)
1069 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1070 "--since= must be before --until=.");
1071
1072 if (!!arg_cursor + !!arg_after_cursor + !!arg_since_set > 1)
1073 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1074 "Please specify only one of --since=, --cursor=, and --after-cursor=.");
1075
1076 if (arg_follow && arg_reverse)
1077 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1078 "Please specify either --reverse= or --follow=, not both.");
1079
1080 if (!IN_SET(arg_action, ACTION_SHOW, ACTION_DUMP_CATALOG, ACTION_LIST_CATALOG) && optind < argc)
1081 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1082 "Extraneous arguments starting with '%s'",
1083 argv[optind]);
1084
1085 if ((arg_boot || arg_action == ACTION_LIST_BOOTS) && arg_merge)
1086 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1087 "Using --boot or --list-boots with --merge is not supported.");
1088
1089 if (!strv_isempty(arg_system_units) && arg_journal_type == SD_JOURNAL_CURRENT_USER) {
1090 /* Specifying --user and --unit= at the same time makes no sense (as the former excludes the user
1091 * journal, but the latter excludes the system journal, thus resulting in empty output). Let's be nice
1092 * to users, and automatically turn --unit= into --user-unit= if combined with --user. */
1093 r = strv_extend_strv(&arg_user_units, arg_system_units, true);
1094 if (r < 0)
1095 return r;
1096
1097 arg_system_units = strv_free(arg_system_units);
1098 }
1099
1100 if (arg_pattern) {
1101 r = pattern_compile_and_log(arg_pattern, arg_case, &arg_compiled_pattern);
1102 if (r < 0)
1103 return r;
1104
1105 /* When --grep is used along with --lines, we don't know how many lines we can print.
1106 * So we search backwards and count until enough lines have been printed or we hit the head.
1107 * An exception is that --follow might set arg_lines, so let's not imply --reverse
1108 * if that is specified. */
1109 if (arg_lines >= 0 && !arg_follow)
1110 arg_reverse = true;
1111 }
1112
1113 return 1;
1114 }
1115
1116 static int add_matches(sd_journal *j, char **args) {
1117 bool have_term = false;
1118
1119 assert(j);
1120
1121 STRV_FOREACH(i, args) {
1122 int r;
1123
1124 if (streq(*i, "+")) {
1125 if (!have_term)
1126 break;
1127 r = sd_journal_add_disjunction(j);
1128 have_term = false;
1129
1130 } else if (path_is_absolute(*i)) {
1131 _cleanup_free_ char *p = NULL, *t = NULL, *t2 = NULL, *interpreter = NULL;
1132 struct stat st;
1133
1134 r = chase(*i, NULL, CHASE_TRAIL_SLASH, &p, NULL);
1135 if (r < 0)
1136 return log_error_errno(r, "Couldn't canonicalize path: %m");
1137
1138 if (lstat(p, &st) < 0)
1139 return log_error_errno(errno, "Couldn't stat file: %m");
1140
1141 if (S_ISREG(st.st_mode) && (0111 & st.st_mode)) {
1142 if (executable_is_script(p, &interpreter) > 0) {
1143 _cleanup_free_ char *comm = NULL;
1144
1145 r = path_extract_filename(p, &comm);
1146 if (r < 0)
1147 return log_error_errno(r, "Failed to extract filename of '%s': %m", p);
1148
1149 t = strjoin("_COMM=", strshorten(comm, TASK_COMM_LEN-1));
1150 if (!t)
1151 return log_oom();
1152
1153 /* Append _EXE only if the interpreter is not a link.
1154 Otherwise, it might be outdated often. */
1155 if (lstat(interpreter, &st) == 0 && !S_ISLNK(st.st_mode)) {
1156 t2 = strjoin("_EXE=", interpreter);
1157 if (!t2)
1158 return log_oom();
1159 }
1160 } else {
1161 t = strjoin("_EXE=", p);
1162 if (!t)
1163 return log_oom();
1164 }
1165
1166 r = sd_journal_add_match(j, t, 0);
1167
1168 if (r >=0 && t2)
1169 r = sd_journal_add_match(j, t2, 0);
1170
1171 } else if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
1172 r = add_matches_for_device(j, p);
1173 if (r < 0)
1174 return r;
1175 } else
1176 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1177 "File is neither a device node, nor regular file, nor executable: %s",
1178 *i);
1179
1180 have_term = true;
1181 } else {
1182 r = sd_journal_add_match(j, *i, 0);
1183 have_term = true;
1184 }
1185
1186 if (r < 0)
1187 return log_error_errno(r, "Failed to add match '%s': %m", *i);
1188 }
1189
1190 if (!strv_isempty(args) && !have_term)
1191 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1192 "\"+\" can only be used between terms");
1193
1194 return 0;
1195 }
1196
1197 static int discover_next_boot(
1198 sd_journal *j,
1199 sd_id128_t previous_boot_id,
1200 bool advance_older,
1201 BootId *ret) {
1202
1203 BootId boot;
1204 int r;
1205
1206 assert(j);
1207 assert(ret);
1208
1209 /* We expect the journal to be on the last position of a boot
1210 * (in relation to the direction we are going), so that the next
1211 * invocation of sd_journal_next/previous will be from a different
1212 * boot. We then collect any information we desire and then jump
1213 * to the last location of the new boot by using a _BOOT_ID match
1214 * coming from the other journal direction. */
1215
1216 /* Make sure we aren't restricted by any _BOOT_ID matches, so that
1217 * we can actually advance to a *different* boot. */
1218 sd_journal_flush_matches(j);
1219
1220 do {
1221 if (advance_older)
1222 r = sd_journal_previous(j);
1223 else
1224 r = sd_journal_next(j);
1225 if (r < 0)
1226 return r;
1227 else if (r == 0) {
1228 *ret = (BootId) {};
1229 return 0; /* End of journal, yay. */
1230 }
1231
1232 r = sd_journal_get_monotonic_usec(j, NULL, &boot.id);
1233 if (r < 0)
1234 return r;
1235
1236 /* We iterate through this in a loop, until the boot ID differs from the previous one. Note that
1237 * normally, this will only require a single iteration, as we seeked to the last entry of the previous
1238 * boot entry already. However, it might happen that the per-journal-field entry arrays are less
1239 * complete than the main entry array, and hence might reference an entry that's not actually the last
1240 * one of the boot ID as last one. Let's hence use the per-field array is initial seek position to
1241 * speed things up, but let's not trust that it is complete, and hence, manually advance as
1242 * necessary. */
1243
1244 } while (sd_id128_equal(boot.id, previous_boot_id));
1245
1246 r = sd_journal_get_realtime_usec(j, &boot.first_usec);
1247 if (r < 0)
1248 return r;
1249
1250 /* Now seek to the last occurrence of this boot ID. */
1251 r = add_match_boot_id(j, boot.id);
1252 if (r < 0)
1253 return r;
1254
1255 if (advance_older)
1256 r = sd_journal_seek_head(j);
1257 else
1258 r = sd_journal_seek_tail(j);
1259 if (r < 0)
1260 return r;
1261
1262 if (advance_older)
1263 r = sd_journal_next(j);
1264 else
1265 r = sd_journal_previous(j);
1266 if (r < 0)
1267 return r;
1268 else if (r == 0)
1269 return log_debug_errno(SYNTHETIC_ERRNO(ENODATA),
1270 "Whoopsie! We found a boot ID but can't read its last entry."); /* This shouldn't happen. We just came from this very boot ID. */
1271
1272 r = sd_journal_get_realtime_usec(j, &boot.last_usec);
1273 if (r < 0)
1274 return r;
1275
1276 sd_journal_flush_matches(j);
1277 *ret = boot;
1278 return 1;
1279 }
1280
1281 static int find_boot_by_id(sd_journal *j) {
1282 int r;
1283
1284 assert(j);
1285
1286 sd_journal_flush_matches(j);
1287
1288 r = add_match_boot_id(j, arg_boot_id);
1289 if (r < 0)
1290 return r;
1291
1292 r = sd_journal_seek_head(j); /* seek to oldest */
1293 if (r < 0)
1294 return r;
1295
1296 r = sd_journal_next(j); /* read the oldest entry */
1297 if (r < 0)
1298 return r;
1299
1300 /* At this point the read pointer is positioned at the oldest occurrence of the reference boot ID.
1301 * After flushing the matches, one more invocation of _previous() will hence place us at the
1302 * following entry, which must then have an older boot ID */
1303
1304 sd_journal_flush_matches(j);
1305 return r > 0;
1306 }
1307
1308 static int find_boot_by_offset(sd_journal *j) {
1309 bool advance_older, skip_once;
1310 int r;
1311
1312 /* Adjust for the asymmetry that offset 0 is the last (and current) boot, while 1 is considered the
1313 * (chronological) first boot in the journal. */
1314 advance_older = skip_once = arg_boot_offset <= 0;
1315
1316 if (advance_older)
1317 r = sd_journal_seek_tail(j); /* seek to newest */
1318 else
1319 r = sd_journal_seek_head(j); /* seek to oldest */
1320 if (r < 0)
1321 return r;
1322
1323 /* No sd_journal_next()/_previous() here.
1324 *
1325 * At this point the read pointer is positioned after the newest/before the oldest entry in the whole
1326 * journal. The next invocation of _previous()/_next() will hence position us at the newest/oldest
1327 * entry we have. */
1328
1329 int offset = arg_boot_offset;
1330 sd_id128_t previous_boot_id = SD_ID128_NULL;
1331 for (;;) {
1332 BootId boot;
1333
1334 r = discover_next_boot(j, previous_boot_id, advance_older, &boot);
1335 if (r <= 0)
1336 return r;
1337
1338 previous_boot_id = boot.id;
1339
1340 if (!skip_once)
1341 offset += advance_older ? 1 : -1;
1342 skip_once = false;
1343
1344 if (offset == 0) {
1345 arg_boot_id = boot.id;
1346 return true;
1347 }
1348 }
1349 }
1350
1351 static int get_boots(sd_journal *j, BootId **ret_boots, size_t *ret_n_boots) {
1352 _cleanup_free_ BootId *boots = NULL;
1353 size_t n_boots = 0;
1354 int r;
1355
1356 assert(j);
1357 assert(ret_boots);
1358 assert(ret_n_boots);
1359
1360 r = sd_journal_seek_head(j); /* seek to oldest */
1361 if (r < 0)
1362 return r;
1363
1364 /* No sd_journal_next()/_previous() here.
1365 *
1366 * At this point the read pointer is positioned before the oldest entry in the whole journal. The
1367 * next invocation of _next() will hence position us at the oldest entry we have. */
1368
1369 sd_id128_t previous_boot_id = SD_ID128_NULL;
1370 for (;;) {
1371 BootId boot;
1372
1373 r = discover_next_boot(j, previous_boot_id, /* advance_older = */ false, &boot);
1374 if (r < 0)
1375 return r;
1376 if (r == 0)
1377 break;
1378
1379 previous_boot_id = boot.id;
1380
1381 FOREACH_ARRAY(i, boots, n_boots)
1382 if (sd_id128_equal(i->id, boot.id))
1383 /* The boot id is already stored, something wrong with the journal files.
1384 * Exiting as otherwise this problem would cause an infinite loop. */
1385 break;
1386
1387 if (!GREEDY_REALLOC(boots, n_boots + 1))
1388 return -ENOMEM;
1389
1390 boots[n_boots++] = boot;
1391 }
1392
1393 *ret_boots = TAKE_PTR(boots);
1394 *ret_n_boots = n_boots;
1395 return n_boots > 0;
1396 }
1397
1398 static int list_boots(sd_journal *j) {
1399 _cleanup_(table_unrefp) Table *table = NULL;
1400 _cleanup_free_ BootId *boots = NULL;
1401 size_t n_boots;
1402 int r;
1403
1404 assert(j);
1405
1406 r = get_boots(j, &boots, &n_boots);
1407 if (r < 0)
1408 return log_error_errno(r, "Failed to determine boots: %m");
1409 if (r == 0)
1410 return 0;
1411
1412 table = table_new("idx", "boot id", "first entry", "last entry");
1413 if (!table)
1414 return log_oom();
1415
1416 if (arg_full)
1417 table_set_width(table, 0);
1418
1419 r = table_set_json_field_name(table, 0, "index");
1420 if (r < 0)
1421 return log_error_errno(r, "Failed to set JSON field name of column 0: %m");
1422
1423 (void) table_set_sort(table, (size_t) 0);
1424 (void) table_set_reverse(table, 0, arg_reverse);
1425
1426 FOREACH_ARRAY(i, boots, n_boots) {
1427 r = table_add_many(table,
1428 TABLE_INT, (int)(i - boots) - (int) n_boots + 1,
1429 TABLE_SET_ALIGN_PERCENT, 100,
1430 TABLE_ID128, i->id,
1431 TABLE_TIMESTAMP, i->first_usec,
1432 TABLE_TIMESTAMP, i->last_usec);
1433 if (r < 0)
1434 return table_log_add_error(r);
1435 }
1436
1437 r = table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, !arg_quiet);
1438 if (r < 0)
1439 return table_log_print_error(r);
1440
1441 return 0;
1442 }
1443
1444 static int add_boot(sd_journal *j) {
1445 int r;
1446
1447 assert(j);
1448
1449 if (!arg_boot)
1450 return 0;
1451
1452 /* Take a shortcut and use the current boot_id, which we can do very quickly.
1453 * We can do this only when we logs are coming from the current machine,
1454 * so take the slow path if log location is specified. */
1455 if (arg_boot_offset == 0 && sd_id128_is_null(arg_boot_id) &&
1456 !arg_directory && !arg_file && !arg_root)
1457 return add_match_this_boot(j, arg_machine);
1458
1459 if (sd_id128_is_null(arg_boot_id)) {
1460 r = find_boot_by_offset(j);
1461 if (r < 0)
1462 return log_error_errno(r, "Failed to find journal entry from the specified boot offset (%+i): %m",
1463 arg_boot_offset);
1464 if (r == 0)
1465 return log_error_errno(SYNTHETIC_ERRNO(ENODATA),
1466 "No journal boot entry found from the specified boot offset (%+i).",
1467 arg_boot_offset);
1468 } else {
1469 r = find_boot_by_id(j);
1470 if (r < 0)
1471 return log_error_errno(r, "Failed to find journal entry from the specified boot ID (%s): %m",
1472 SD_ID128_TO_STRING(arg_boot_id));
1473 if (r == 0)
1474 return log_error_errno(SYNTHETIC_ERRNO(ENODATA),
1475 "No journal boot entry found from the specified boot ID (%s).",
1476 SD_ID128_TO_STRING(arg_boot_id));
1477 }
1478
1479 r = add_match_boot_id(j, arg_boot_id);
1480 if (r < 0)
1481 return log_error_errno(r, "Failed to add match: %m");
1482
1483 r = sd_journal_add_conjunction(j);
1484 if (r < 0)
1485 return log_error_errno(r, "Failed to add conjunction: %m");
1486
1487 return 0;
1488 }
1489
1490 static int add_dmesg(sd_journal *j) {
1491 int r;
1492 assert(j);
1493
1494 if (!arg_dmesg)
1495 return 0;
1496
1497 r = sd_journal_add_match(j, "_TRANSPORT=kernel",
1498 STRLEN("_TRANSPORT=kernel"));
1499 if (r < 0)
1500 return log_error_errno(r, "Failed to add match: %m");
1501
1502 r = sd_journal_add_conjunction(j);
1503 if (r < 0)
1504 return log_error_errno(r, "Failed to add conjunction: %m");
1505
1506 return 0;
1507 }
1508
1509 static int get_possible_units(
1510 sd_journal *j,
1511 const char *fields,
1512 char **patterns,
1513 Set **units) {
1514
1515 _cleanup_set_free_free_ Set *found = NULL;
1516 int r;
1517
1518 found = set_new(&string_hash_ops);
1519 if (!found)
1520 return -ENOMEM;
1521
1522 NULSTR_FOREACH(field, fields) {
1523 const void *data;
1524 size_t size;
1525
1526 r = sd_journal_query_unique(j, field);
1527 if (r < 0)
1528 return r;
1529
1530 SD_JOURNAL_FOREACH_UNIQUE(j, data, size) {
1531 char *eq;
1532 size_t prefix;
1533 _cleanup_free_ char *u = NULL;
1534
1535 eq = memchr(data, '=', size);
1536 if (eq)
1537 prefix = eq - (char*) data + 1;
1538 else
1539 prefix = 0;
1540
1541 u = strndup((char*) data + prefix, size - prefix);
1542 if (!u)
1543 return -ENOMEM;
1544
1545 STRV_FOREACH(pattern, patterns)
1546 if (fnmatch(*pattern, u, FNM_NOESCAPE) == 0) {
1547 log_debug("Matched %s with pattern %s=%s", u, field, *pattern);
1548
1549 r = set_consume(found, u);
1550 u = NULL;
1551 if (r < 0 && r != -EEXIST)
1552 return r;
1553
1554 break;
1555 }
1556 }
1557 }
1558
1559 *units = TAKE_PTR(found);
1560
1561 return 0;
1562 }
1563
1564 /* This list is supposed to return the superset of unit names
1565 * possibly matched by rules added with add_matches_for_unit... */
1566 #define SYSTEM_UNITS \
1567 "_SYSTEMD_UNIT\0" \
1568 "COREDUMP_UNIT\0" \
1569 "UNIT\0" \
1570 "OBJECT_SYSTEMD_UNIT\0" \
1571 "_SYSTEMD_SLICE\0"
1572
1573 /* ... and add_matches_for_user_unit */
1574 #define USER_UNITS \
1575 "_SYSTEMD_USER_UNIT\0" \
1576 "USER_UNIT\0" \
1577 "COREDUMP_USER_UNIT\0" \
1578 "OBJECT_SYSTEMD_USER_UNIT\0" \
1579 "_SYSTEMD_USER_SLICE\0"
1580
1581 static int add_units(sd_journal *j) {
1582 _cleanup_strv_free_ char **patterns = NULL;
1583 int r, count = 0;
1584
1585 assert(j);
1586
1587 STRV_FOREACH(i, arg_system_units) {
1588 _cleanup_free_ char *u = NULL;
1589
1590 r = unit_name_mangle(*i, UNIT_NAME_MANGLE_GLOB | (arg_quiet ? 0 : UNIT_NAME_MANGLE_WARN), &u);
1591 if (r < 0)
1592 return r;
1593
1594 if (string_is_glob(u)) {
1595 r = strv_push(&patterns, u);
1596 if (r < 0)
1597 return r;
1598 u = NULL;
1599 } else {
1600 r = add_matches_for_unit(j, u);
1601 if (r < 0)
1602 return r;
1603 r = sd_journal_add_disjunction(j);
1604 if (r < 0)
1605 return r;
1606 count++;
1607 }
1608 }
1609
1610 if (!strv_isempty(patterns)) {
1611 _cleanup_set_free_free_ Set *units = NULL;
1612 char *u;
1613
1614 r = get_possible_units(j, SYSTEM_UNITS, patterns, &units);
1615 if (r < 0)
1616 return r;
1617
1618 SET_FOREACH(u, units) {
1619 r = add_matches_for_unit(j, u);
1620 if (r < 0)
1621 return r;
1622 r = sd_journal_add_disjunction(j);
1623 if (r < 0)
1624 return r;
1625 count++;
1626 }
1627 }
1628
1629 patterns = strv_free(patterns);
1630
1631 STRV_FOREACH(i, arg_user_units) {
1632 _cleanup_free_ char *u = NULL;
1633
1634 r = unit_name_mangle(*i, UNIT_NAME_MANGLE_GLOB | (arg_quiet ? 0 : UNIT_NAME_MANGLE_WARN), &u);
1635 if (r < 0)
1636 return r;
1637
1638 if (string_is_glob(u)) {
1639 r = strv_push(&patterns, u);
1640 if (r < 0)
1641 return r;
1642 u = NULL;
1643 } else {
1644 r = add_matches_for_user_unit(j, u, getuid());
1645 if (r < 0)
1646 return r;
1647 r = sd_journal_add_disjunction(j);
1648 if (r < 0)
1649 return r;
1650 count++;
1651 }
1652 }
1653
1654 if (!strv_isempty(patterns)) {
1655 _cleanup_set_free_free_ Set *units = NULL;
1656 char *u;
1657
1658 r = get_possible_units(j, USER_UNITS, patterns, &units);
1659 if (r < 0)
1660 return r;
1661
1662 SET_FOREACH(u, units) {
1663 r = add_matches_for_user_unit(j, u, getuid());
1664 if (r < 0)
1665 return r;
1666 r = sd_journal_add_disjunction(j);
1667 if (r < 0)
1668 return r;
1669 count++;
1670 }
1671 }
1672
1673 /* Complain if the user request matches but nothing whatsoever was
1674 * found, since otherwise everything would be matched. */
1675 if (!(strv_isempty(arg_system_units) && strv_isempty(arg_user_units)) && count == 0)
1676 return -ENODATA;
1677
1678 r = sd_journal_add_conjunction(j);
1679 if (r < 0)
1680 return r;
1681
1682 return 0;
1683 }
1684
1685 static int add_priorities(sd_journal *j) {
1686 char match[] = "PRIORITY=0";
1687 int i, r;
1688 assert(j);
1689
1690 if (arg_priorities == 0xFF)
1691 return 0;
1692
1693 for (i = LOG_EMERG; i <= LOG_DEBUG; i++)
1694 if (arg_priorities & (1 << i)) {
1695 match[sizeof(match)-2] = '0' + i;
1696
1697 r = sd_journal_add_match(j, match, strlen(match));
1698 if (r < 0)
1699 return log_error_errno(r, "Failed to add match: %m");
1700 }
1701
1702 r = sd_journal_add_conjunction(j);
1703 if (r < 0)
1704 return log_error_errno(r, "Failed to add conjunction: %m");
1705
1706 return 0;
1707 }
1708
1709 static int add_facilities(sd_journal *j) {
1710 void *p;
1711 int r;
1712
1713 SET_FOREACH(p, arg_facilities) {
1714 char match[STRLEN("SYSLOG_FACILITY=") + DECIMAL_STR_MAX(int)];
1715
1716 xsprintf(match, "SYSLOG_FACILITY=%d", PTR_TO_INT(p));
1717
1718 r = sd_journal_add_match(j, match, strlen(match));
1719 if (r < 0)
1720 return log_error_errno(r, "Failed to add match: %m");
1721 }
1722
1723 return 0;
1724 }
1725
1726 static int add_syslog_identifier(sd_journal *j) {
1727 int r;
1728
1729 assert(j);
1730
1731 STRV_FOREACH(i, arg_syslog_identifier) {
1732 _cleanup_free_ char *u = NULL;
1733
1734 u = strjoin("SYSLOG_IDENTIFIER=", *i);
1735 if (!u)
1736 return -ENOMEM;
1737 r = sd_journal_add_match(j, u, 0);
1738 if (r < 0)
1739 return r;
1740 r = sd_journal_add_disjunction(j);
1741 if (r < 0)
1742 return r;
1743 }
1744
1745 r = sd_journal_add_conjunction(j);
1746 if (r < 0)
1747 return r;
1748
1749 return 0;
1750 }
1751
1752 #if HAVE_GCRYPT
1753 static int format_journal_url(
1754 const void *seed,
1755 size_t seed_size,
1756 uint64_t start,
1757 uint64_t interval,
1758 const char *hn,
1759 sd_id128_t machine,
1760 bool full,
1761 char **ret_url) {
1762
1763 _cleanup_(memstream_done) MemStream m = {};
1764 FILE *f;
1765
1766 assert(seed);
1767 assert(seed_size > 0);
1768
1769 f = memstream_init(&m);
1770 if (!f)
1771 return -ENOMEM;
1772
1773 if (full)
1774 fputs("fss://", f);
1775
1776 for (size_t i = 0; i < seed_size; i++) {
1777 if (i > 0 && i % 3 == 0)
1778 fputc('-', f);
1779 fprintf(f, "%02x", ((uint8_t*) seed)[i]);
1780 }
1781
1782 fprintf(f, "/%"PRIx64"-%"PRIx64, start, interval);
1783
1784 if (full) {
1785 fprintf(f, "?machine=" SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(machine));
1786 if (hn)
1787 fprintf(f, ";hostname=%s", hn);
1788 }
1789
1790 return memstream_finalize(&m, ret_url, NULL);
1791 }
1792 #endif
1793
1794 static int setup_keys(void) {
1795 #if HAVE_GCRYPT
1796 size_t mpk_size, seed_size, state_size;
1797 _cleanup_(unlink_and_freep) char *k = NULL;
1798 _cleanup_free_ char *p = NULL;
1799 uint8_t *mpk, *seed, *state;
1800 _cleanup_close_ int fd = -EBADF;
1801 sd_id128_t machine, boot;
1802 struct stat st;
1803 uint64_t n;
1804 int r;
1805
1806 r = stat("/var/log/journal", &st);
1807 if (r < 0 && !IN_SET(errno, ENOENT, ENOTDIR))
1808 return log_error_errno(errno, "stat(\"%s\") failed: %m", "/var/log/journal");
1809
1810 if (r < 0 || !S_ISDIR(st.st_mode)) {
1811 log_error("%s is not a directory, must be using persistent logging for FSS.",
1812 "/var/log/journal");
1813 return r < 0 ? -errno : -ENOTDIR;
1814 }
1815
1816 r = sd_id128_get_machine(&machine);
1817 if (r < 0)
1818 return log_error_errno(r, "Failed to get machine ID: %m");
1819
1820 r = sd_id128_get_boot(&boot);
1821 if (r < 0)
1822 return log_error_errno(r, "Failed to get boot ID: %m");
1823
1824 if (asprintf(&p, "/var/log/journal/" SD_ID128_FORMAT_STR "/fss",
1825 SD_ID128_FORMAT_VAL(machine)) < 0)
1826 return log_oom();
1827
1828 if (arg_force) {
1829 r = unlink(p);
1830 if (r < 0 && errno != ENOENT)
1831 return log_error_errno(errno, "unlink(\"%s\") failed: %m", p);
1832 } else if (access(p, F_OK) >= 0)
1833 return log_error_errno(SYNTHETIC_ERRNO(EEXIST),
1834 "Sealing key file %s exists already. Use --force to recreate.", p);
1835
1836 if (asprintf(&k, "/var/log/journal/" SD_ID128_FORMAT_STR "/fss.tmp.XXXXXX",
1837 SD_ID128_FORMAT_VAL(machine)) < 0)
1838 return log_oom();
1839
1840 mpk_size = FSPRG_mskinbytes(FSPRG_RECOMMENDED_SECPAR);
1841 mpk = alloca_safe(mpk_size);
1842
1843 seed_size = FSPRG_RECOMMENDED_SEEDLEN;
1844 seed = alloca_safe(seed_size);
1845
1846 state_size = FSPRG_stateinbytes(FSPRG_RECOMMENDED_SECPAR);
1847 state = alloca_safe(state_size);
1848
1849 log_info("Generating seed...");
1850 r = crypto_random_bytes(seed, seed_size);
1851 if (r < 0)
1852 return log_error_errno(r, "Failed to acquire random seed: %m");
1853
1854 log_info("Generating key pair...");
1855 FSPRG_GenMK(NULL, mpk, seed, seed_size, FSPRG_RECOMMENDED_SECPAR);
1856
1857 log_info("Generating sealing key...");
1858 FSPRG_GenState0(state, mpk, seed, seed_size);
1859
1860 assert(arg_interval > 0);
1861
1862 n = now(CLOCK_REALTIME);
1863 n /= arg_interval;
1864
1865 safe_close(fd);
1866 fd = mkostemp_safe(k);
1867 if (fd < 0)
1868 return log_error_errno(fd, "Failed to open %s: %m", k);
1869
1870 r = chattr_secret(fd, CHATTR_WARN_UNSUPPORTED_FLAGS);
1871 if (r < 0)
1872 log_full_errno(ERRNO_IS_NOT_SUPPORTED(r) ? LOG_DEBUG : LOG_WARNING,
1873 r, "Failed to set file attributes on '%s', ignoring: %m", k);
1874
1875 struct FSSHeader h = {
1876 .signature = { 'K', 'S', 'H', 'H', 'R', 'H', 'L', 'P' },
1877 .machine_id = machine,
1878 .boot_id = boot,
1879 .header_size = htole64(sizeof(h)),
1880 .start_usec = htole64(n * arg_interval),
1881 .interval_usec = htole64(arg_interval),
1882 .fsprg_secpar = htole16(FSPRG_RECOMMENDED_SECPAR),
1883 .fsprg_state_size = htole64(state_size),
1884 };
1885
1886 r = loop_write(fd, &h, sizeof(h), false);
1887 if (r < 0)
1888 return log_error_errno(r, "Failed to write header: %m");
1889
1890 r = loop_write(fd, state, state_size, false);
1891 if (r < 0)
1892 return log_error_errno(r, "Failed to write state: %m");
1893
1894 if (rename(k, p) < 0)
1895 return log_error_errno(errno, "Failed to link file: %m");
1896
1897 k = mfree(k);
1898
1899 _cleanup_free_ char *hn = NULL, *key = NULL;
1900
1901 r = format_journal_url(seed, seed_size, n, arg_interval, hn, machine, false, &key);
1902 if (r < 0)
1903 return r;
1904
1905 if (on_tty()) {
1906 hn = gethostname_malloc();
1907 if (hn)
1908 hostname_cleanup(hn);
1909
1910 fprintf(stderr,
1911 "\nNew keys have been generated for host %s%s" SD_ID128_FORMAT_STR ".\n"
1912 "\n"
1913 "The %ssecret sealing key%s has been written to the following local file.\n"
1914 "This key file is automatically updated when the sealing key is advanced.\n"
1915 "It should not be used on multiple hosts.\n"
1916 "\n"
1917 "\t%s\n"
1918 "\n"
1919 "The sealing key is automatically changed every %s.\n"
1920 "\n"
1921 "Please write down the following %ssecret verification key%s. It should be stored\n"
1922 "in a safe location and should not be saved locally on disk.\n"
1923 "\n\t%s",
1924 strempty(hn), hn ? "/" : "",
1925 SD_ID128_FORMAT_VAL(machine),
1926 ansi_highlight(), ansi_normal(),
1927 p,
1928 FORMAT_TIMESPAN(arg_interval, 0),
1929 ansi_highlight(), ansi_normal(),
1930 ansi_highlight_red());
1931 fflush(stderr);
1932 }
1933
1934 puts(key);
1935
1936 if (on_tty()) {
1937 fprintf(stderr, "%s", ansi_normal());
1938 #if HAVE_QRENCODE
1939 _cleanup_free_ char *url = NULL;
1940 r = format_journal_url(seed, seed_size, n, arg_interval, hn, machine, true, &url);
1941 if (r < 0)
1942 return r;
1943
1944 (void) print_qrcode(stderr,
1945 "To transfer the verification key to your phone scan the QR code below",
1946 url);
1947 #endif
1948 }
1949
1950 return 0;
1951 #else
1952 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
1953 "Forward-secure sealing not available.");
1954 #endif
1955 }
1956
1957 static int verify(sd_journal *j, bool verbose) {
1958 int r = 0;
1959 JournalFile *f;
1960
1961 assert(j);
1962
1963 log_show_color(true);
1964
1965 ORDERED_HASHMAP_FOREACH(f, j->files) {
1966 int k;
1967 usec_t first = 0, validated = 0, last = 0;
1968
1969 #if HAVE_GCRYPT
1970 if (!arg_verify_key && JOURNAL_HEADER_SEALED(f->header))
1971 log_notice("Journal file %s has sealing enabled but verification key has not been passed using --verify-key=.", f->path);
1972 #endif
1973
1974 k = journal_file_verify(f, arg_verify_key, &first, &validated, &last, verbose);
1975 if (k == -EINVAL)
1976 /* If the key was invalid give up right-away. */
1977 return k;
1978 else if (k < 0)
1979 r = log_warning_errno(k, "FAIL: %s (%m)", f->path);
1980 else {
1981 char a[FORMAT_TIMESTAMP_MAX], b[FORMAT_TIMESTAMP_MAX];
1982 log_full(verbose ? LOG_INFO : LOG_DEBUG, "PASS: %s", f->path);
1983
1984 if (arg_verify_key && JOURNAL_HEADER_SEALED(f->header)) {
1985 if (validated > 0) {
1986 log_full(verbose ? LOG_INFO : LOG_DEBUG,
1987 "=> Validated from %s to %s, final %s entries not sealed.",
1988 format_timestamp_maybe_utc(a, sizeof(a), first),
1989 format_timestamp_maybe_utc(b, sizeof(b), validated),
1990 FORMAT_TIMESPAN(last > validated ? last - validated : 0, 0));
1991 } else if (last > 0)
1992 log_full(verbose ? LOG_INFO : LOG_DEBUG,
1993 "=> No sealing yet, %s of entries not sealed.",
1994 FORMAT_TIMESPAN(last - first, 0));
1995 else
1996 log_full(verbose ? LOG_INFO : LOG_DEBUG,
1997 "=> No sealing yet, no entries in file.");
1998 }
1999 }
2000 }
2001
2002 return r;
2003 }
2004
2005 static int simple_varlink_call(const char *option, const char *method) {
2006 _cleanup_(varlink_flush_close_unrefp) Varlink *link = NULL;
2007 const char *error, *fn;
2008 int r;
2009
2010 if (arg_machine)
2011 return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "%s is not supported in conjunction with --machine=.", option);
2012
2013 fn = arg_namespace ?
2014 strjoina("/run/systemd/journal.", arg_namespace, "/io.systemd.journal") :
2015 "/run/systemd/journal/io.systemd.journal";
2016
2017 r = varlink_connect_address(&link, fn);
2018 if (r < 0)
2019 return log_error_errno(r, "Failed to connect to %s: %m", fn);
2020
2021 (void) varlink_set_description(link, "journal");
2022 (void) varlink_set_relative_timeout(link, USEC_INFINITY);
2023
2024 r = varlink_call(link, method, NULL, NULL, &error, NULL);
2025 if (r < 0)
2026 return log_error_errno(r, "Failed to execute varlink call: %m");
2027 if (error)
2028 return log_error_errno(SYNTHETIC_ERRNO(ENOANO),
2029 "Failed to execute varlink call: %s", error);
2030
2031 return 0;
2032 }
2033
2034 static int flush_to_var(void) {
2035 if (access("/run/systemd/journal/flushed", F_OK) >= 0)
2036 return 0; /* Already flushed, no need to contact journald */
2037 if (errno != ENOENT)
2038 return log_error_errno(errno, "Unable to check for existence of /run/systemd/journal/flushed: %m");
2039
2040 return simple_varlink_call("--flush", "io.systemd.Journal.FlushToVar");
2041 }
2042
2043 static int relinquish_var(void) {
2044 return simple_varlink_call("--relinquish-var/--smart-relinquish-var", "io.systemd.Journal.RelinquishVar");
2045 }
2046
2047 static int rotate(void) {
2048 return simple_varlink_call("--rotate", "io.systemd.Journal.Rotate");
2049 }
2050
2051 static int sync_journal(void) {
2052 return simple_varlink_call("--sync", "io.systemd.Journal.Synchronize");
2053 }
2054
2055 static int action_list_fields(sd_journal *j) {
2056 const void *data;
2057 size_t size;
2058 int r, n_shown = 0;
2059
2060 assert(arg_field);
2061
2062 r = sd_journal_set_data_threshold(j, 0);
2063 if (r < 0)
2064 return log_error_errno(r, "Failed to unset data size threshold: %m");
2065
2066 r = sd_journal_query_unique(j, arg_field);
2067 if (r < 0)
2068 return log_error_errno(r, "Failed to query unique data objects: %m");
2069
2070 SD_JOURNAL_FOREACH_UNIQUE(j, data, size) {
2071 const void *eq;
2072
2073 if (arg_lines >= 0 && n_shown >= arg_lines)
2074 break;
2075
2076 eq = memchr(data, '=', size);
2077 if (eq)
2078 printf("%.*s\n", (int) (size - ((const uint8_t*) eq - (const uint8_t*) data + 1)), (const char*) eq + 1);
2079 else
2080 printf("%.*s\n", (int) size, (const char*) data);
2081
2082 n_shown++;
2083 }
2084
2085 return 0;
2086 }
2087
2088 static int update_cursor(sd_journal *j) {
2089 _cleanup_free_ char *cursor = NULL;
2090 int r;
2091
2092 assert(j);
2093
2094 if (!arg_show_cursor && !arg_cursor_file)
2095 return 0;
2096
2097 r = sd_journal_get_cursor(j, &cursor);
2098 if (r == -EADDRNOTAVAIL)
2099 return 0;
2100 if (r < 0)
2101 return log_error_errno(r, "Failed to get cursor: %m");
2102
2103 if (arg_show_cursor)
2104 printf("-- cursor: %s\n", cursor);
2105
2106 if (arg_cursor_file) {
2107 r = write_string_file(arg_cursor_file, cursor, WRITE_STRING_FILE_CREATE | WRITE_STRING_FILE_ATOMIC);
2108 if (r < 0)
2109 return log_error_errno(r, "Failed to write new cursor to %s: %m", arg_cursor_file);
2110 }
2111
2112 return 0;
2113 }
2114
2115 typedef struct Context {
2116 sd_journal *journal;
2117 bool need_seek;
2118 bool since_seeked;
2119 bool ellipsized;
2120 bool previous_boot_id_valid;
2121 sd_id128_t previous_boot_id;
2122 sd_id128_t previous_boot_id_output;
2123 dual_timestamp previous_ts_output;
2124 } Context;
2125
2126 static int show(Context *c) {
2127 sd_journal *j;
2128 int r, n_shown = 0;
2129
2130 assert(c);
2131
2132 j = ASSERT_PTR(c->journal);
2133
2134 while (arg_lines < 0 || n_shown < arg_lines || arg_follow) {
2135 int flags;
2136 size_t highlight[2] = {};
2137
2138 if (c->need_seek) {
2139 r = sd_journal_step_one(j, !arg_reverse);
2140 if (r < 0)
2141 return log_error_errno(r, "Failed to iterate through journal: %m");
2142 if (r == 0)
2143 break;
2144 }
2145
2146 if (arg_until_set && !arg_reverse && (arg_lines < 0 || arg_since_set)) {
2147 /* If --lines= is set, we usually rely on the n_shown to tell us
2148 * when to stop. However, if --since= is set too, we may end up
2149 * having less than --lines= to output. In this case let's also
2150 * check if the entry is in range. */
2151
2152 usec_t usec;
2153
2154 r = sd_journal_get_realtime_usec(j, &usec);
2155 if (r < 0)
2156 return log_error_errno(r, "Failed to determine timestamp: %m");
2157 if (usec > arg_until)
2158 break;
2159 }
2160
2161 if (arg_since_set && (arg_reverse || !c->since_seeked)) {
2162 usec_t usec;
2163
2164 r = sd_journal_get_realtime_usec(j, &usec);
2165 if (r < 0)
2166 return log_error_errno(r, "Failed to determine timestamp: %m");
2167
2168 if (usec < arg_since) {
2169 if (arg_reverse)
2170 break; /* Reached the earliest entry */
2171
2172 /* arg_lines >= 0 (!since_seeked):
2173 * We jumped arg_lines back and it seems to be too much */
2174 r = sd_journal_seek_realtime_usec(j, arg_since);
2175 if (r < 0)
2176 return log_error_errno(r, "Failed to seek to date: %m");
2177 c->since_seeked = true;
2178
2179 c->need_seek = true;
2180 continue;
2181 }
2182 c->since_seeked = true; /* We're surely within the range of --since now */
2183 }
2184
2185 if (!arg_merge && !arg_quiet) {
2186 sd_id128_t boot_id;
2187
2188 r = sd_journal_get_monotonic_usec(j, NULL, &boot_id);
2189 if (r >= 0) {
2190 if (c->previous_boot_id_valid &&
2191 !sd_id128_equal(boot_id, c->previous_boot_id))
2192 printf("%s-- Boot "SD_ID128_FORMAT_STR" --%s\n",
2193 ansi_highlight(), SD_ID128_FORMAT_VAL(boot_id), ansi_normal());
2194
2195 c->previous_boot_id = boot_id;
2196 c->previous_boot_id_valid = true;
2197 }
2198 }
2199
2200 if (arg_compiled_pattern) {
2201 const void *message;
2202 size_t len;
2203
2204 r = sd_journal_get_data(j, "MESSAGE", &message, &len);
2205 if (r < 0) {
2206 if (r == -ENOENT) {
2207 c->need_seek = true;
2208 continue;
2209 }
2210
2211 return log_error_errno(r, "Failed to get MESSAGE field: %m");
2212 }
2213
2214 assert_se(message = startswith(message, "MESSAGE="));
2215
2216 r = pattern_matches_and_log(arg_compiled_pattern, message,
2217 len - strlen("MESSAGE="), highlight);
2218 if (r < 0)
2219 return r;
2220 if (r == 0) {
2221 c->need_seek = true;
2222 continue;
2223 }
2224 }
2225
2226 flags =
2227 arg_all * OUTPUT_SHOW_ALL |
2228 arg_full * OUTPUT_FULL_WIDTH |
2229 colors_enabled() * OUTPUT_COLOR |
2230 arg_catalog * OUTPUT_CATALOG |
2231 arg_utc * OUTPUT_UTC |
2232 arg_no_hostname * OUTPUT_NO_HOSTNAME;
2233
2234 r = show_journal_entry(stdout, j, arg_output, 0, flags,
2235 arg_output_fields, highlight, &c->ellipsized,
2236 &c->previous_ts_output, &c->previous_boot_id_output);
2237 c->need_seek = true;
2238 if (r == -EADDRNOTAVAIL)
2239 break;
2240 if (r < 0)
2241 return r;
2242
2243 n_shown++;
2244
2245 /* If journalctl take a long time to process messages, and during that time journal file
2246 * rotation occurs, a journalctl client will keep those rotated files open until it calls
2247 * sd_journal_process(), which typically happens as a result of calling sd_journal_wait() below
2248 * in the "following" case. By periodically calling sd_journal_process() during the processing
2249 * loop we shrink the window of time a client instance has open file descriptors for rotated
2250 * (deleted) journal files. */
2251 if ((n_shown % PROCESS_INOTIFY_INTERVAL) == 0) {
2252 r = sd_journal_process(j);
2253 if (r < 0)
2254 return log_error_errno(r, "Failed to process inotify events: %m");
2255 }
2256 }
2257
2258 return n_shown;
2259 }
2260
2261 static int show_and_fflush(Context *c, sd_event_source *s) {
2262 int r;
2263
2264 assert(c);
2265 assert(s);
2266
2267 r = show(c);
2268 if (r < 0)
2269 return sd_event_exit(sd_event_source_get_event(s), r);
2270
2271 fflush(stdout);
2272 return 0;
2273 }
2274
2275 static int on_journal_event(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
2276 Context *c = ASSERT_PTR(userdata);
2277 int r;
2278
2279 assert(s);
2280
2281 r = sd_journal_process(c->journal);
2282 if (r < 0) {
2283 log_error_errno(r, "Failed to process journal events: %m");
2284 return sd_event_exit(sd_event_source_get_event(s), r);
2285 }
2286
2287 return show_and_fflush(c, s);
2288 }
2289
2290 static int on_first_event(sd_event_source *s, void *userdata) {
2291 return show_and_fflush(userdata, s);
2292 }
2293
2294 static int on_signal(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
2295 assert(s);
2296 assert(si);
2297 assert(IN_SET(si->ssi_signo, SIGTERM, SIGINT));
2298
2299 return sd_event_exit(sd_event_source_get_event(s), si->ssi_signo);
2300 }
2301
2302 static int setup_event(Context *c, int fd, sd_event **ret) {
2303 _cleanup_(sd_event_unrefp) sd_event *e = NULL;
2304 int r;
2305
2306 assert(arg_follow);
2307 assert(c);
2308 assert(fd >= 0);
2309 assert(ret);
2310
2311 r = sd_event_default(&e);
2312 if (r < 0)
2313 return log_error_errno(r, "Failed to allocate sd_event object: %m");
2314
2315 (void) sd_event_add_signal(e, NULL, SIGTERM | SD_EVENT_SIGNAL_PROCMASK, on_signal, NULL);
2316 (void) sd_event_add_signal(e, NULL, SIGINT | SD_EVENT_SIGNAL_PROCMASK, on_signal, NULL);
2317
2318 r = sd_event_add_io(e, NULL, fd, EPOLLIN, &on_journal_event, c);
2319 if (r < 0)
2320 return log_error_errno(r, "Failed to add io event source for journal: %m");
2321
2322 /* Also keeps an eye on STDOUT, and exits as soon as we see a POLLHUP on that, i.e. when it is closed. */
2323 r = sd_event_add_io(e, NULL, STDOUT_FILENO, EPOLLHUP|EPOLLERR, NULL, INT_TO_PTR(-ECANCELED));
2324 if (r < 0)
2325 return log_error_errno(r, "Failed to add io event source for stdout: %m");
2326
2327 if (arg_lines != 0 || arg_since_set) {
2328 r = sd_event_add_defer(e, NULL, on_first_event, c);
2329 if (r < 0)
2330 return log_error_errno(r, "Failed to add defer event source: %m");
2331 }
2332
2333 *ret = TAKE_PTR(e);
2334 return 0;
2335 }
2336
2337 static int run(int argc, char *argv[]) {
2338 bool need_seek = false, since_seeked = false, use_cursor = false, after_cursor = false;
2339 _cleanup_(loop_device_unrefp) LoopDevice *loop_device = NULL;
2340 _cleanup_(umount_and_freep) char *mounted_dir = NULL;
2341 _cleanup_(sd_journal_closep) sd_journal *j = NULL;
2342 _cleanup_close_ int machine_fd = -EBADF;
2343 int n_shown, r, poll_fd = -EBADF;
2344
2345 setlocale(LC_ALL, "");
2346 log_setup();
2347
2348 /* Increase max number of open files if we can, we might needs this when browsing journal files, which might be
2349 * split up into many files. */
2350 (void) rlimit_nofile_bump(HIGH_RLIMIT_NOFILE);
2351
2352 r = parse_argv(argc, argv);
2353 if (r <= 0)
2354 return r;
2355
2356 if (arg_image) {
2357 assert(!arg_root);
2358
2359 r = mount_image_privately_interactively(
2360 arg_image,
2361 arg_image_policy,
2362 DISSECT_IMAGE_GENERIC_ROOT |
2363 DISSECT_IMAGE_REQUIRE_ROOT |
2364 DISSECT_IMAGE_VALIDATE_OS |
2365 DISSECT_IMAGE_RELAX_VAR_CHECK |
2366 (arg_action == ACTION_UPDATE_CATALOG ? DISSECT_IMAGE_FSCK|DISSECT_IMAGE_GROWFS : DISSECT_IMAGE_READ_ONLY),
2367 &mounted_dir,
2368 /* ret_dir_fd= */ NULL,
2369 &loop_device);
2370 if (r < 0)
2371 return r;
2372
2373 arg_root = strdup(mounted_dir);
2374 if (!arg_root)
2375 return log_oom();
2376 }
2377
2378 signal(SIGWINCH, columns_lines_cache_reset);
2379 sigbus_install();
2380
2381 switch (arg_action) {
2382
2383 case ACTION_NEW_ID128:
2384 return id128_print_new(ID128_PRINT_PRETTY);
2385
2386 case ACTION_SETUP_KEYS:
2387 return setup_keys();
2388
2389 case ACTION_LIST_CATALOG:
2390 case ACTION_DUMP_CATALOG:
2391 case ACTION_UPDATE_CATALOG: {
2392 _cleanup_free_ char *database = NULL;
2393
2394 database = path_join(arg_root, CATALOG_DATABASE);
2395 if (!database)
2396 return log_oom();
2397
2398 if (arg_action == ACTION_UPDATE_CATALOG) {
2399 r = catalog_update(database, arg_root, catalog_file_dirs);
2400 if (r < 0)
2401 return log_error_errno(r, "Failed to list catalog: %m");
2402 } else {
2403 bool oneline = arg_action == ACTION_LIST_CATALOG;
2404
2405 pager_open(arg_pager_flags);
2406
2407 if (optind < argc)
2408 r = catalog_list_items(stdout, database, oneline, argv + optind);
2409 else
2410 r = catalog_list(stdout, database, oneline);
2411 if (r < 0)
2412 return log_error_errno(r, "Failed to list catalog: %m");
2413 }
2414
2415 return 0;
2416 }
2417
2418 case ACTION_FLUSH:
2419 return flush_to_var();
2420
2421 case ACTION_RELINQUISH_VAR:
2422 return relinquish_var();
2423
2424 case ACTION_SYNC:
2425 return sync_journal();
2426
2427 case ACTION_ROTATE:
2428 return rotate();
2429
2430 case ACTION_SHOW:
2431 case ACTION_PRINT_HEADER:
2432 case ACTION_VERIFY:
2433 case ACTION_DISK_USAGE:
2434 case ACTION_LIST_BOOTS:
2435 case ACTION_VACUUM:
2436 case ACTION_ROTATE_AND_VACUUM:
2437 case ACTION_LIST_FIELDS:
2438 case ACTION_LIST_FIELD_NAMES:
2439 /* These ones require access to the journal files, continue below. */
2440 break;
2441
2442 default:
2443 assert_not_reached();
2444 }
2445
2446 if (arg_directory)
2447 r = sd_journal_open_directory(&j, arg_directory, arg_journal_type);
2448 else if (arg_root)
2449 r = sd_journal_open_directory(&j, arg_root, arg_journal_type | SD_JOURNAL_OS_ROOT);
2450 else if (arg_file_stdin)
2451 r = sd_journal_open_files_fd(&j, (int[]) { STDIN_FILENO }, 1, 0);
2452 else if (arg_file)
2453 r = sd_journal_open_files(&j, (const char**) arg_file, 0);
2454 else if (arg_machine) {
2455 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2456 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2457 _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
2458 int fd;
2459
2460 if (geteuid() != 0)
2461 /* The file descriptor returned by OpenMachineRootDirectory() will be owned by users/groups of
2462 * the container, thus we need root privileges to override them. */
2463 return log_error_errno(SYNTHETIC_ERRNO(EPERM), "Using the --machine= switch requires root privileges.");
2464
2465 r = sd_bus_open_system(&bus);
2466 if (r < 0)
2467 return log_error_errno(r, "Failed to open system bus: %m");
2468
2469 r = bus_call_method(bus, bus_machine_mgr, "OpenMachineRootDirectory", &error, &reply, "s", arg_machine);
2470 if (r < 0)
2471 return log_error_errno(r, "Failed to open root directory: %s", bus_error_message(&error, r));
2472
2473 r = sd_bus_message_read(reply, "h", &fd);
2474 if (r < 0)
2475 return bus_log_parse_error(r);
2476
2477 machine_fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
2478 if (machine_fd < 0)
2479 return log_error_errno(errno, "Failed to duplicate file descriptor: %m");
2480
2481 r = sd_journal_open_directory_fd(&j, machine_fd, SD_JOURNAL_OS_ROOT);
2482 } else
2483 r = sd_journal_open_namespace(
2484 &j,
2485 arg_namespace,
2486 (arg_merge ? 0 : SD_JOURNAL_LOCAL_ONLY) |
2487 arg_namespace_flags | arg_journal_type);
2488 if (r < 0)
2489 return log_error_errno(r, "Failed to open %s: %m", arg_directory ?: arg_file ? "files" : "journal");
2490
2491 r = journal_access_check_and_warn(j, arg_quiet,
2492 !(arg_journal_type == SD_JOURNAL_CURRENT_USER || arg_user_units));
2493 if (r < 0)
2494 return r;
2495
2496 switch (arg_action) {
2497
2498 case ACTION_NEW_ID128:
2499 case ACTION_SETUP_KEYS:
2500 case ACTION_LIST_CATALOG:
2501 case ACTION_DUMP_CATALOG:
2502 case ACTION_UPDATE_CATALOG:
2503 case ACTION_FLUSH:
2504 case ACTION_SYNC:
2505 case ACTION_ROTATE:
2506 assert_not_reached();
2507
2508 case ACTION_PRINT_HEADER:
2509 journal_print_header(j);
2510 return 0;
2511
2512 case ACTION_VERIFY:
2513 return verify(j, !arg_quiet);
2514
2515 case ACTION_DISK_USAGE: {
2516 uint64_t bytes = 0;
2517
2518 r = sd_journal_get_usage(j, &bytes);
2519 if (r < 0)
2520 return r;
2521
2522 printf("Archived and active journals take up %s in the file system.\n",
2523 FORMAT_BYTES(bytes));
2524
2525 return 0;
2526 }
2527
2528 case ACTION_LIST_BOOTS:
2529 return list_boots(j);
2530
2531 case ACTION_ROTATE_AND_VACUUM:
2532
2533 r = rotate();
2534 if (r < 0)
2535 return r;
2536
2537 _fallthrough_;
2538
2539 case ACTION_VACUUM: {
2540 Directory *d;
2541 int ret = 0;
2542
2543 HASHMAP_FOREACH(d, j->directories_by_path) {
2544 r = journal_directory_vacuum(d->path, arg_vacuum_size, arg_vacuum_n_files, arg_vacuum_time, NULL, !arg_quiet);
2545 if (r < 0) {
2546 log_error_errno(r, "Failed to vacuum %s: %m", d->path);
2547 if (ret >= 0)
2548 ret = r;
2549 }
2550 }
2551
2552 return ret;
2553 }
2554
2555 case ACTION_LIST_FIELD_NAMES: {
2556 const char *field;
2557
2558 SD_JOURNAL_FOREACH_FIELD(j, field)
2559 printf("%s\n", field);
2560
2561 return 0;
2562 }
2563
2564 case ACTION_SHOW:
2565 case ACTION_LIST_FIELDS:
2566 break;
2567
2568 default:
2569 assert_not_reached();
2570 }
2571
2572 if (arg_boot_offset != 0 &&
2573 sd_journal_has_runtime_files(j) > 0 &&
2574 sd_journal_has_persistent_files(j) == 0) {
2575 log_info("Specifying boot ID or boot offset has no effect, no persistent journal was found.");
2576
2577 if (arg_action == ACTION_SHOW && arg_compiled_pattern)
2578 return -ENOENT;
2579
2580 return 0;
2581 }
2582 /* add_boot() must be called first!
2583 * It may need to seek the journal to find parent boot IDs. */
2584 r = add_boot(j);
2585 if (r < 0)
2586 return r;
2587
2588 r = add_dmesg(j);
2589 if (r < 0)
2590 return r;
2591
2592 r = add_units(j);
2593 if (r < 0)
2594 return log_error_errno(r, "Failed to add filter for units: %m");
2595
2596 r = add_syslog_identifier(j);
2597 if (r < 0)
2598 return log_error_errno(r, "Failed to add filter for syslog identifiers: %m");
2599
2600 r = add_priorities(j);
2601 if (r < 0)
2602 return r;
2603
2604 r = add_facilities(j);
2605 if (r < 0)
2606 return r;
2607
2608 r = add_matches(j, argv + optind);
2609 if (r < 0)
2610 return r;
2611
2612 if (DEBUG_LOGGING) {
2613 _cleanup_free_ char *filter = NULL;
2614
2615 filter = journal_make_match_string(j);
2616 if (!filter)
2617 return log_oom();
2618
2619 log_debug("Journal filter: %s", filter);
2620 }
2621
2622 if (arg_action == ACTION_LIST_FIELDS)
2623 return action_list_fields(j);
2624
2625 /* Opening the fd now means the first sd_journal_wait() will actually wait */
2626 if (arg_follow) {
2627 poll_fd = sd_journal_get_fd(j);
2628 if (poll_fd == -EMFILE) {
2629 log_warning_errno(poll_fd, "Insufficient watch descriptors available. Reverting to -n.");
2630 arg_follow = false;
2631 } else if (poll_fd == -EMEDIUMTYPE)
2632 return log_error_errno(poll_fd, "The --follow switch is not supported in conjunction with reading from STDIN.");
2633 else if (poll_fd < 0)
2634 return log_error_errno(poll_fd, "Failed to get journal fd: %m");
2635 }
2636
2637 if (arg_cursor || arg_after_cursor || arg_cursor_file) {
2638 _cleanup_free_ char *cursor_from_file = NULL;
2639 const char *cursor = arg_cursor ?: arg_after_cursor;
2640
2641 if (arg_cursor_file) {
2642 r = read_one_line_file(arg_cursor_file, &cursor_from_file);
2643 if (r < 0 && r != -ENOENT)
2644 return log_error_errno(r, "Failed to read cursor file %s: %m", arg_cursor_file);
2645
2646 if (r > 0) {
2647 cursor = cursor_from_file;
2648 after_cursor = true;
2649 }
2650 } else
2651 after_cursor = arg_after_cursor;
2652
2653 if (cursor) {
2654 r = sd_journal_seek_cursor(j, cursor);
2655 if (r < 0)
2656 return log_error_errno(r, "Failed to seek to cursor: %m");
2657
2658 use_cursor = true;
2659 }
2660 }
2661
2662 if (use_cursor) {
2663 if (!arg_reverse)
2664 r = sd_journal_next_skip(j, 1 + after_cursor);
2665 else
2666 r = sd_journal_previous_skip(j, 1 + after_cursor);
2667
2668 if (after_cursor && r < 2) {
2669 /* We couldn't find the next entry after the cursor. */
2670 if (arg_follow)
2671 need_seek = true;
2672 else
2673 arg_lines = 0;
2674 }
2675
2676 } else if (arg_until_set && (arg_reverse || arg_lines >= 0)) {
2677 /* If both --until and any of --reverse and --lines is specified, things get
2678 * a little tricky. We seek to the place of --until first. If only --reverse or
2679 * --reverse and --lines is specified, we search backwards and let the output
2680 * counter handle --lines for us. If only --lines is used, we just jump backwards
2681 * arg_lines and search afterwards from there. */
2682
2683 r = sd_journal_seek_realtime_usec(j, arg_until);
2684 if (r < 0)
2685 return log_error_errno(r, "Failed to seek to date: %m");
2686
2687 if (arg_reverse)
2688 r = sd_journal_previous(j);
2689 else /* arg_lines >= 0 */
2690 r = sd_journal_previous_skip(j, arg_lines);
2691
2692 } else if (arg_reverse) {
2693 r = sd_journal_seek_tail(j);
2694 if (r < 0)
2695 return log_error_errno(r, "Failed to seek to tail: %m");
2696
2697 r = sd_journal_previous(j);
2698
2699 } else if (arg_lines >= 0) {
2700 r = sd_journal_seek_tail(j);
2701 if (r < 0)
2702 return log_error_errno(r, "Failed to seek to tail: %m");
2703
2704 r = sd_journal_previous_skip(j, arg_lines);
2705
2706 } else if (arg_since_set) {
2707 /* This is placed after arg_reverse and arg_lines. If --since is used without
2708 * both, we seek to the place of --since and search afterwards from there.
2709 * If used with --reverse or --lines, we seek to the tail first and check if
2710 * the entry is within the range of --since later. */
2711
2712 r = sd_journal_seek_realtime_usec(j, arg_since);
2713 if (r < 0)
2714 return log_error_errno(r, "Failed to seek to date: %m");
2715 since_seeked = true;
2716
2717 r = sd_journal_next(j);
2718
2719 } else {
2720 r = sd_journal_seek_head(j);
2721 if (r < 0)
2722 return log_error_errno(r, "Failed to seek to head: %m");
2723
2724 r = sd_journal_next(j);
2725 }
2726 if (r < 0)
2727 return log_error_errno(r, "Failed to iterate through journal: %m");
2728 if (r == 0)
2729 need_seek = true;
2730
2731 if (!arg_follow)
2732 pager_open(arg_pager_flags);
2733
2734 if (!arg_quiet && (arg_lines != 0 || arg_follow) && DEBUG_LOGGING) {
2735 usec_t start, end;
2736 char start_buf[FORMAT_TIMESTAMP_MAX], end_buf[FORMAT_TIMESTAMP_MAX];
2737
2738 r = sd_journal_get_cutoff_realtime_usec(j, &start, &end);
2739 if (r < 0)
2740 return log_error_errno(r, "Failed to get cutoff: %m");
2741 if (r > 0) {
2742 if (arg_follow)
2743 printf("-- Journal begins at %s. --\n",
2744 format_timestamp_maybe_utc(start_buf, sizeof(start_buf), start));
2745 else
2746 printf("-- Journal begins at %s, ends at %s. --\n",
2747 format_timestamp_maybe_utc(start_buf, sizeof(start_buf), start),
2748 format_timestamp_maybe_utc(end_buf, sizeof(end_buf), end));
2749 }
2750 }
2751
2752 Context c = {
2753 .journal = j,
2754 .need_seek = need_seek,
2755 .since_seeked = since_seeked,
2756 };
2757
2758 if (arg_follow) {
2759 _cleanup_(sd_event_unrefp) sd_event *e = NULL;
2760 int sig;
2761
2762 assert(poll_fd >= 0);
2763
2764 r = setup_event(&c, poll_fd, &e);
2765 if (r < 0)
2766 return r;
2767
2768 r = sd_event_loop(e);
2769 if (r < 0)
2770 return r;
2771 sig = r;
2772
2773 /* unref signal event sources. */
2774 e = sd_event_unref(e);
2775
2776 r = update_cursor(j);
2777 if (r < 0)
2778 return r;
2779
2780 /* re-send the original signal. */
2781 assert(SIGNAL_VALID(sig));
2782 if (raise(sig) < 0)
2783 log_error("Failed to raise the original signal SIG%s, ignoring: %m", signal_to_string(sig));
2784
2785 return 0;
2786 }
2787
2788 r = show(&c);
2789 if (r < 0)
2790 return r;
2791 n_shown = r;
2792
2793 if (n_shown == 0 && !arg_quiet)
2794 printf("-- No entries --\n");
2795
2796 r = update_cursor(j);
2797 if (r < 0)
2798 return r;
2799
2800 if (arg_compiled_pattern && n_shown == 0)
2801 /* --grep was used, no error was thrown, but the pattern didn't
2802 * match anything. Let's mimic grep's behavior here and return
2803 * a non-zero exit code, so journalctl --grep can be used
2804 * in scripts and such */
2805 return -ENOENT;
2806
2807 return 0;
2808 }
2809
2810 DEFINE_MAIN_FUNCTION(run);
Unnamed repository; edit this file 'description' to name the repository.