]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/journal/sd-journal.c
projects / thirdparty / systemd.git / blob
? search:


7587211506f5f02d5503dc1c730201ebf88450aa
[thirdparty/systemd.git] / src / journal / sd-journal.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2011 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <stddef.h>
25 #include <unistd.h>
26 #include <sys/inotify.h>
27 #include <sys/poll.h>
28 #include <sys/vfs.h>
29 #include <linux/magic.h>
30
31 #include "sd-journal.h"
32 #include "journal-def.h"
33 #include "journal-file.h"
34 #include "hashmap.h"
35 #include "list.h"
36 #include "strv.h"
37 #include "path-util.h"
38 #include "lookup3.h"
39 #include "compress.h"
40 #include "journal-internal.h"
41 #include "missing.h"
42 #include "catalog.h"
43 #include "replace-var.h"
44 #include "fileio.h"
45
46 #define JOURNAL_FILES_MAX 1024
47
48 #define JOURNAL_FILES_RECHECK_USEC (2 * USEC_PER_SEC)
49
50 #define REPLACE_VAR_MAX 256
51
52 #define DEFAULT_DATA_THRESHOLD (64*1024)
53
54 static void remove_file_real(sd_journal *j, JournalFile *f);
55
56 static bool journal_pid_changed(sd_journal *j) {
57 assert(j);
58
59 /* We don't support people creating a journal object and
60 * keeping it around over a fork(). Let's complain. */
61
62 return j->original_pid != getpid();
63 }
64
65 /* We return an error here only if we didn't manage to
66 memorize the real error. */
67 static int set_put_error(sd_journal *j, int r) {
68 int k;
69
70 if (r >= 0)
71 return r;
72
73 k = set_ensure_allocated(&j->errors, trivial_hash_func, trivial_compare_func);
74 if (k < 0)
75 return k;
76
77 return set_put(j->errors, INT_TO_PTR(r));
78 }
79
80 static void detach_location(sd_journal *j) {
81 Iterator i;
82 JournalFile *f;
83
84 assert(j);
85
86 j->current_file = NULL;
87 j->current_field = 0;
88
89 HASHMAP_FOREACH(f, j->files, i)
90 f->current_offset = 0;
91 }
92
93 static void reset_location(sd_journal *j) {
94 assert(j);
95
96 detach_location(j);
97 zero(j->current_location);
98 }
99
100 static void init_location(Location *l, LocationType type, JournalFile *f, Object *o) {
101 assert(l);
102 assert(type == LOCATION_DISCRETE || type == LOCATION_SEEK);
103 assert(f);
104 assert(o->object.type == OBJECT_ENTRY);
105
106 l->type = type;
107 l->seqnum = le64toh(o->entry.seqnum);
108 l->seqnum_id = f->header->seqnum_id;
109 l->realtime = le64toh(o->entry.realtime);
110 l->monotonic = le64toh(o->entry.monotonic);
111 l->boot_id = o->entry.boot_id;
112 l->xor_hash = le64toh(o->entry.xor_hash);
113
114 l->seqnum_set = l->realtime_set = l->monotonic_set = l->xor_hash_set = true;
115 }
116
117 static void set_location(sd_journal *j, LocationType type, JournalFile *f, Object *o,
118 direction_t direction, uint64_t offset) {
119 assert(j);
120 assert(type == LOCATION_DISCRETE || type == LOCATION_SEEK);
121 assert(f);
122 assert(o);
123
124 init_location(&j->current_location, type, f, o);
125
126 j->current_file = f;
127 j->current_field = 0;
128
129 f->last_direction = direction;
130 f->current_offset = offset;
131 }
132
133 static int match_is_valid(const void *data, size_t size) {
134 const char *b, *p;
135
136 assert(data);
137
138 if (size < 2)
139 return false;
140
141 if (startswith(data, "__"))
142 return false;
143
144 b = data;
145 for (p = b; p < b + size; p++) {
146
147 if (*p == '=')
148 return p > b;
149
150 if (*p == '_')
151 continue;
152
153 if (*p >= 'A' && *p <= 'Z')
154 continue;
155
156 if (*p >= '0' && *p <= '9')
157 continue;
158
159 return false;
160 }
161
162 return false;
163 }
164
165 static bool same_field(const void *_a, size_t s, const void *_b, size_t t) {
166 const uint8_t *a = _a, *b = _b;
167 size_t j;
168
169 for (j = 0; j < s && j < t; j++) {
170
171 if (a[j] != b[j])
172 return false;
173
174 if (a[j] == '=')
175 return true;
176 }
177
178 assert_not_reached("\"=\" not found");
179 }
180
181 static Match *match_new(Match *p, MatchType t) {
182 Match *m;
183
184 m = new0(Match, 1);
185 if (!m)
186 return NULL;
187
188 m->type = t;
189
190 if (p) {
191 m->parent = p;
192 LIST_PREPEND(matches, p->matches, m);
193 }
194
195 return m;
196 }
197
198 static void match_free(Match *m) {
199 assert(m);
200
201 while (m->matches)
202 match_free(m->matches);
203
204 if (m->parent)
205 LIST_REMOVE(matches, m->parent->matches, m);
206
207 free(m->data);
208 free(m);
209 }
210
211 static void match_free_if_empty(Match *m) {
212 if (!m || m->matches)
213 return;
214
215 match_free(m);
216 }
217
218 _public_ int sd_journal_add_match(sd_journal *j, const void *data, size_t size) {
219 Match *l3, *l4, *add_here = NULL, *m;
220 le64_t le_hash;
221
222 assert_return(j, -EINVAL);
223 assert_return(!journal_pid_changed(j), -ECHILD);
224 assert_return(data, -EINVAL);
225
226 if (size == 0)
227 size = strlen(data);
228
229 assert_return(match_is_valid(data, size), -EINVAL);
230
231 /* level 0: AND term
232 * level 1: OR terms
233 * level 2: AND terms
234 * level 3: OR terms
235 * level 4: concrete matches */
236
237 if (!j->level0) {
238 j->level0 = match_new(NULL, MATCH_AND_TERM);
239 if (!j->level0)
240 return -ENOMEM;
241 }
242
243 if (!j->level1) {
244 j->level1 = match_new(j->level0, MATCH_OR_TERM);
245 if (!j->level1)
246 return -ENOMEM;
247 }
248
249 if (!j->level2) {
250 j->level2 = match_new(j->level1, MATCH_AND_TERM);
251 if (!j->level2)
252 return -ENOMEM;
253 }
254
255 assert(j->level0->type == MATCH_AND_TERM);
256 assert(j->level1->type == MATCH_OR_TERM);
257 assert(j->level2->type == MATCH_AND_TERM);
258
259 le_hash = htole64(hash64(data, size));
260
261 LIST_FOREACH(matches, l3, j->level2->matches) {
262 assert(l3->type == MATCH_OR_TERM);
263
264 LIST_FOREACH(matches, l4, l3->matches) {
265 assert(l4->type == MATCH_DISCRETE);
266
267 /* Exactly the same match already? Then ignore
268 * this addition */
269 if (l4->le_hash == le_hash &&
270 l4->size == size &&
271 memcmp(l4->data, data, size) == 0)
272 return 0;
273
274 /* Same field? Then let's add this to this OR term */
275 if (same_field(data, size, l4->data, l4->size)) {
276 add_here = l3;
277 break;
278 }
279 }
280
281 if (add_here)
282 break;
283 }
284
285 if (!add_here) {
286 add_here = match_new(j->level2, MATCH_OR_TERM);
287 if (!add_here)
288 goto fail;
289 }
290
291 m = match_new(add_here, MATCH_DISCRETE);
292 if (!m)
293 goto fail;
294
295 m->le_hash = le_hash;
296 m->size = size;
297 m->data = memdup(data, size);
298 if (!m->data)
299 goto fail;
300
301 detach_location(j);
302
303 return 0;
304
305 fail:
306 match_free_if_empty(add_here);
307 match_free_if_empty(j->level2);
308 match_free_if_empty(j->level1);
309 match_free_if_empty(j->level0);
310
311 return -ENOMEM;
312 }
313
314 _public_ int sd_journal_add_conjunction(sd_journal *j) {
315 assert_return(j, -EINVAL);
316 assert_return(!journal_pid_changed(j), -ECHILD);
317
318 if (!j->level0)
319 return 0;
320
321 if (!j->level1)
322 return 0;
323
324 if (!j->level1->matches)
325 return 0;
326
327 j->level1 = NULL;
328 j->level2 = NULL;
329
330 return 0;
331 }
332
333 _public_ int sd_journal_add_disjunction(sd_journal *j) {
334 assert_return(j, -EINVAL);
335 assert_return(!journal_pid_changed(j), -ECHILD);
336
337 if (!j->level0)
338 return 0;
339
340 if (!j->level1)
341 return 0;
342
343 if (!j->level2)
344 return 0;
345
346 if (!j->level2->matches)
347 return 0;
348
349 j->level2 = NULL;
350 return 0;
351 }
352
353 static char *match_make_string(Match *m) {
354 char *p, *r;
355 Match *i;
356 bool enclose = false;
357
358 if (!m)
359 return strdup("none");
360
361 if (m->type == MATCH_DISCRETE)
362 return strndup(m->data, m->size);
363
364 p = NULL;
365 LIST_FOREACH(matches, i, m->matches) {
366 char *t, *k;
367
368 t = match_make_string(i);
369 if (!t) {
370 free(p);
371 return NULL;
372 }
373
374 if (p) {
375 k = strjoin(p, m->type == MATCH_OR_TERM ? " OR " : " AND ", t, NULL);
376 free(p);
377 free(t);
378
379 if (!k)
380 return NULL;
381
382 p = k;
383
384 enclose = true;
385 } else
386 p = t;
387 }
388
389 if (enclose) {
390 r = strjoin("(", p, ")", NULL);
391 free(p);
392 return r;
393 }
394
395 return p;
396 }
397
398 char *journal_make_match_string(sd_journal *j) {
399 assert(j);
400
401 return match_make_string(j->level0);
402 }
403
404 _public_ void sd_journal_flush_matches(sd_journal *j) {
405 if (!j)
406 return;
407
408 if (j->level0)
409 match_free(j->level0);
410
411 j->level0 = j->level1 = j->level2 = NULL;
412
413 detach_location(j);
414 }
415
416 static int compare_entry_order(JournalFile *af, Object *_ao,
417 JournalFile *bf, uint64_t bp) {
418
419 uint64_t a, b;
420 Object *ao, *bo;
421 int r;
422
423 assert(af);
424 assert(bf);
425 assert(_ao);
426
427 /* The mmap cache might invalidate the object from the first
428 * file if we look at the one from the second file. Hence
429 * temporarily copy the header of the first one, and look at
430 * that only. */
431 ao = alloca(offsetof(EntryObject, items));
432 memcpy(ao, _ao, offsetof(EntryObject, items));
433
434 r = journal_file_move_to_object(bf, OBJECT_ENTRY, bp, &bo);
435 if (r < 0)
436 return strcmp(af->path, bf->path);
437
438 /* We operate on two different files here, hence we can access
439 * two objects at the same time, which we normally can't.
440 *
441 * If contents and timestamps match, these entries are
442 * identical, even if the seqnum does not match */
443
444 if (sd_id128_equal(ao->entry.boot_id, bo->entry.boot_id) &&
445 ao->entry.monotonic == bo->entry.monotonic &&
446 ao->entry.realtime == bo->entry.realtime &&
447 ao->entry.xor_hash == bo->entry.xor_hash)
448 return 0;
449
450 if (sd_id128_equal(af->header->seqnum_id, bf->header->seqnum_id)) {
451
452 /* If this is from the same seqnum source, compare
453 * seqnums */
454 a = le64toh(ao->entry.seqnum);
455 b = le64toh(bo->entry.seqnum);
456
457 if (a < b)
458 return -1;
459 if (a > b)
460 return 1;
461
462 /* Wow! This is weird, different data but the same
463 * seqnums? Something is borked, but let's make the
464 * best of it and compare by time. */
465 }
466
467 if (sd_id128_equal(ao->entry.boot_id, bo->entry.boot_id)) {
468
469 /* If the boot id matches, compare monotonic time */
470 a = le64toh(ao->entry.monotonic);
471 b = le64toh(bo->entry.monotonic);
472
473 if (a < b)
474 return -1;
475 if (a > b)
476 return 1;
477 }
478
479 /* Otherwise, compare UTC time */
480 a = le64toh(ao->entry.realtime);
481 b = le64toh(bo->entry.realtime);
482
483 if (a < b)
484 return -1;
485 if (a > b)
486 return 1;
487
488 /* Finally, compare by contents */
489 a = le64toh(ao->entry.xor_hash);
490 b = le64toh(bo->entry.xor_hash);
491
492 if (a < b)
493 return -1;
494 if (a > b)
495 return 1;
496
497 return 0;
498 }
499
500 _pure_ static int compare_with_location(JournalFile *af, Object *ao, Location *l) {
501 uint64_t a;
502
503 assert(af);
504 assert(ao);
505 assert(l);
506 assert(l->type == LOCATION_DISCRETE || l->type == LOCATION_SEEK);
507
508 if (l->monotonic_set &&
509 sd_id128_equal(ao->entry.boot_id, l->boot_id) &&
510 l->realtime_set &&
511 le64toh(ao->entry.realtime) == l->realtime &&
512 l->xor_hash_set &&
513 le64toh(ao->entry.xor_hash) == l->xor_hash)
514 return 0;
515
516 if (l->seqnum_set &&
517 sd_id128_equal(af->header->seqnum_id, l->seqnum_id)) {
518
519 a = le64toh(ao->entry.seqnum);
520
521 if (a < l->seqnum)
522 return -1;
523 if (a > l->seqnum)
524 return 1;
525 }
526
527 if (l->monotonic_set &&
528 sd_id128_equal(ao->entry.boot_id, l->boot_id)) {
529
530 a = le64toh(ao->entry.monotonic);
531
532 if (a < l->monotonic)
533 return -1;
534 if (a > l->monotonic)
535 return 1;
536 }
537
538 if (l->realtime_set) {
539
540 a = le64toh(ao->entry.realtime);
541
542 if (a < l->realtime)
543 return -1;
544 if (a > l->realtime)
545 return 1;
546 }
547
548 if (l->xor_hash_set) {
549 a = le64toh(ao->entry.xor_hash);
550
551 if (a < l->xor_hash)
552 return -1;
553 if (a > l->xor_hash)
554 return 1;
555 }
556
557 return 0;
558 }
559
560 static int next_for_match(
561 sd_journal *j,
562 Match *m,
563 JournalFile *f,
564 uint64_t after_offset,
565 direction_t direction,
566 Object **ret,
567 uint64_t *offset) {
568
569 int r;
570 uint64_t np = 0;
571 Object *n;
572
573 assert(j);
574 assert(m);
575 assert(f);
576
577 if (m->type == MATCH_DISCRETE) {
578 uint64_t dp;
579
580 r = journal_file_find_data_object_with_hash(f, m->data, m->size, le64toh(m->le_hash), NULL, &dp);
581 if (r <= 0)
582 return r;
583
584 return journal_file_move_to_entry_by_offset_for_data(f, dp, after_offset, direction, ret, offset);
585
586 } else if (m->type == MATCH_OR_TERM) {
587 Match *i;
588
589 /* Find the earliest match beyond after_offset */
590
591 LIST_FOREACH(matches, i, m->matches) {
592 uint64_t cp;
593
594 r = next_for_match(j, i, f, after_offset, direction, NULL, &cp);
595 if (r < 0)
596 return r;
597 else if (r > 0) {
598 if (np == 0 || (direction == DIRECTION_DOWN ? cp < np : cp > np))
599 np = cp;
600 }
601 }
602
603 if (np == 0)
604 return 0;
605
606 } else if (m->type == MATCH_AND_TERM) {
607 Match *i, *last_moved;
608
609 /* Always jump to the next matching entry and repeat
610 * this until we find an offset that matches for all
611 * matches. */
612
613 if (!m->matches)
614 return 0;
615
616 r = next_for_match(j, m->matches, f, after_offset, direction, NULL, &np);
617 if (r <= 0)
618 return r;
619
620 assert(direction == DIRECTION_DOWN ? np >= after_offset : np <= after_offset);
621 last_moved = m->matches;
622
623 LIST_LOOP_BUT_ONE(matches, i, m->matches, last_moved) {
624 uint64_t cp;
625
626 r = next_for_match(j, i, f, np, direction, NULL, &cp);
627 if (r <= 0)
628 return r;
629
630 assert(direction == DIRECTION_DOWN ? cp >= np : cp <= np);
631 if (direction == DIRECTION_DOWN ? cp > np : cp < np) {
632 np = cp;
633 last_moved = i;
634 }
635 }
636 }
637
638 assert(np > 0);
639
640 r = journal_file_move_to_object(f, OBJECT_ENTRY, np, &n);
641 if (r < 0)
642 return r;
643
644 if (ret)
645 *ret = n;
646 if (offset)
647 *offset = np;
648
649 return 1;
650 }
651
652 static int find_location_for_match(
653 sd_journal *j,
654 Match *m,
655 JournalFile *f,
656 direction_t direction,
657 Object **ret,
658 uint64_t *offset) {
659
660 int r;
661
662 assert(j);
663 assert(m);
664 assert(f);
665
666 if (m->type == MATCH_DISCRETE) {
667 uint64_t dp;
668
669 r = journal_file_find_data_object_with_hash(f, m->data, m->size, le64toh(m->le_hash), NULL, &dp);
670 if (r <= 0)
671 return r;
672
673 /* FIXME: missing: find by monotonic */
674
675 if (j->current_location.type == LOCATION_HEAD)
676 return journal_file_next_entry_for_data(f, NULL, 0, dp, DIRECTION_DOWN, ret, offset);
677 if (j->current_location.type == LOCATION_TAIL)
678 return journal_file_next_entry_for_data(f, NULL, 0, dp, DIRECTION_UP, ret, offset);
679 if (j->current_location.seqnum_set && sd_id128_equal(j->current_location.seqnum_id, f->header->seqnum_id))
680 return journal_file_move_to_entry_by_seqnum_for_data(f, dp, j->current_location.seqnum, direction, ret, offset);
681 if (j->current_location.monotonic_set) {
682 r = journal_file_move_to_entry_by_monotonic_for_data(f, dp, j->current_location.boot_id, j->current_location.monotonic, direction, ret, offset);
683 if (r != -ENOENT)
684 return r;
685 }
686 if (j->current_location.realtime_set)
687 return journal_file_move_to_entry_by_realtime_for_data(f, dp, j->current_location.realtime, direction, ret, offset);
688
689 return journal_file_next_entry_for_data(f, NULL, 0, dp, direction, ret, offset);
690
691 } else if (m->type == MATCH_OR_TERM) {
692 uint64_t np = 0;
693 Object *n;
694 Match *i;
695
696 /* Find the earliest match */
697
698 LIST_FOREACH(matches, i, m->matches) {
699 uint64_t cp;
700
701 r = find_location_for_match(j, i, f, direction, NULL, &cp);
702 if (r < 0)
703 return r;
704 else if (r > 0) {
705 if (np == 0 || (direction == DIRECTION_DOWN ? np > cp : np < cp))
706 np = cp;
707 }
708 }
709
710 if (np == 0)
711 return 0;
712
713 r = journal_file_move_to_object(f, OBJECT_ENTRY, np, &n);
714 if (r < 0)
715 return r;
716
717 if (ret)
718 *ret = n;
719 if (offset)
720 *offset = np;
721
722 return 1;
723
724 } else {
725 Match *i;
726 uint64_t np = 0;
727
728 assert(m->type == MATCH_AND_TERM);
729
730 /* First jump to the last match, and then find the
731 * next one where all matches match */
732
733 if (!m->matches)
734 return 0;
735
736 LIST_FOREACH(matches, i, m->matches) {
737 uint64_t cp;
738
739 r = find_location_for_match(j, i, f, direction, NULL, &cp);
740 if (r <= 0)
741 return r;
742
743 if (np == 0 || (direction == DIRECTION_DOWN ? cp > np : cp < np))
744 np = cp;
745 }
746
747 return next_for_match(j, m, f, np, direction, ret, offset);
748 }
749 }
750
751 static int find_location_with_matches(
752 sd_journal *j,
753 JournalFile *f,
754 direction_t direction,
755 Object **ret,
756 uint64_t *offset) {
757
758 int r;
759
760 assert(j);
761 assert(f);
762 assert(ret);
763 assert(offset);
764
765 if (!j->level0) {
766 /* No matches is simple */
767
768 if (j->current_location.type == LOCATION_HEAD)
769 return journal_file_next_entry(f, NULL, 0, DIRECTION_DOWN, ret, offset);
770 if (j->current_location.type == LOCATION_TAIL)
771 return journal_file_next_entry(f, NULL, 0, DIRECTION_UP, ret, offset);
772 if (j->current_location.seqnum_set && sd_id128_equal(j->current_location.seqnum_id, f->header->seqnum_id))
773 return journal_file_move_to_entry_by_seqnum(f, j->current_location.seqnum, direction, ret, offset);
774 if (j->current_location.monotonic_set) {
775 r = journal_file_move_to_entry_by_monotonic(f, j->current_location.boot_id, j->current_location.monotonic, direction, ret, offset);
776 if (r != -ENOENT)
777 return r;
778 }
779 if (j->current_location.realtime_set)
780 return journal_file_move_to_entry_by_realtime(f, j->current_location.realtime, direction, ret, offset);
781
782 return journal_file_next_entry(f, NULL, 0, direction, ret, offset);
783 } else
784 return find_location_for_match(j, j->level0, f, direction, ret, offset);
785 }
786
787 static int next_with_matches(
788 sd_journal *j,
789 JournalFile *f,
790 direction_t direction,
791 Object **ret,
792 uint64_t *offset) {
793
794 Object *c;
795 uint64_t cp;
796
797 assert(j);
798 assert(f);
799 assert(ret);
800 assert(offset);
801
802 c = *ret;
803 cp = *offset;
804
805 /* No matches is easy. We simple advance the file
806 * pointer by one. */
807 if (!j->level0)
808 return journal_file_next_entry(f, c, cp, direction, ret, offset);
809
810 /* If we have a match then we look for the next matching entry
811 * with an offset at least one step larger */
812 return next_for_match(j, j->level0, f, direction == DIRECTION_DOWN ? cp+1 : cp-1, direction, ret, offset);
813 }
814
815 static int next_beyond_location(sd_journal *j, JournalFile *f, direction_t direction, Object **ret, uint64_t *offset) {
816 Object *c;
817 uint64_t cp;
818 int r;
819
820 assert(j);
821 assert(f);
822
823 if (f->last_direction == direction && f->current_offset > 0) {
824 cp = f->current_offset;
825
826 r = journal_file_move_to_object(f, OBJECT_ENTRY, cp, &c);
827 if (r < 0)
828 return r;
829
830 r = next_with_matches(j, f, direction, &c, &cp);
831 if (r <= 0)
832 return r;
833 } else {
834 r = find_location_with_matches(j, f, direction, &c, &cp);
835 if (r <= 0)
836 return r;
837 }
838
839 /* OK, we found the spot, now let's advance until an entry
840 * that is actually different from what we were previously
841 * looking at. This is necessary to handle entries which exist
842 * in two (or more) journal files, and which shall all be
843 * suppressed but one. */
844
845 for (;;) {
846 bool found;
847
848 if (j->current_location.type == LOCATION_DISCRETE) {
849 int k;
850
851 k = compare_with_location(f, c, &j->current_location);
852 if (direction == DIRECTION_DOWN)
853 found = k > 0;
854 else
855 found = k < 0;
856 } else
857 found = true;
858
859 if (found) {
860 if (ret)
861 *ret = c;
862 if (offset)
863 *offset = cp;
864 return 1;
865 }
866
867 r = next_with_matches(j, f, direction, &c, &cp);
868 if (r <= 0)
869 return r;
870 }
871 }
872
873 static int real_journal_next(sd_journal *j, direction_t direction) {
874 JournalFile *f, *new_file = NULL;
875 uint64_t new_offset = 0;
876 uint64_t p = 0;
877 Iterator i;
878 Object *o;
879 int r;
880
881 assert_return(j, -EINVAL);
882 assert_return(!journal_pid_changed(j), -ECHILD);
883
884 HASHMAP_FOREACH(f, j->files, i) {
885 bool found;
886
887 r = next_beyond_location(j, f, direction, &o, &p);
888 if (r < 0) {
889 log_debug("Can't iterate through %s, ignoring: %s", f->path, strerror(-r));
890 remove_file_real(j, f);
891 continue;
892 } else if (r == 0)
893 continue;
894
895 if (!new_file)
896 found = true;
897 else {
898 int k;
899
900 k = compare_entry_order(f, o, new_file, new_offset);
901
902 found = direction == DIRECTION_DOWN ? k < 0 : k > 0;
903 }
904
905 if (found) {
906 new_file = f;
907 new_offset = p;
908 }
909 }
910
911 if (!new_file)
912 return 0;
913
914 r = journal_file_move_to_object(new_file, OBJECT_ENTRY, new_offset, &o);
915 if (r < 0)
916 return r;
917
918 set_location(j, LOCATION_DISCRETE, new_file, o, direction, new_offset);
919
920 return 1;
921 }
922
923 _public_ int sd_journal_next(sd_journal *j) {
924 return real_journal_next(j, DIRECTION_DOWN);
925 }
926
927 _public_ int sd_journal_previous(sd_journal *j) {
928 return real_journal_next(j, DIRECTION_UP);
929 }
930
931 static int real_journal_next_skip(sd_journal *j, direction_t direction, uint64_t skip) {
932 int c = 0, r;
933
934 assert_return(j, -EINVAL);
935 assert_return(!journal_pid_changed(j), -ECHILD);
936
937 if (skip == 0) {
938 /* If this is not a discrete skip, then at least
939 * resolve the current location */
940 if (j->current_location.type != LOCATION_DISCRETE)
941 return real_journal_next(j, direction);
942
943 return 0;
944 }
945
946 do {
947 r = real_journal_next(j, direction);
948 if (r < 0)
949 return r;
950
951 if (r == 0)
952 return c;
953
954 skip--;
955 c++;
956 } while (skip > 0);
957
958 return c;
959 }
960
961 _public_ int sd_journal_next_skip(sd_journal *j, uint64_t skip) {
962 return real_journal_next_skip(j, DIRECTION_DOWN, skip);
963 }
964
965 _public_ int sd_journal_previous_skip(sd_journal *j, uint64_t skip) {
966 return real_journal_next_skip(j, DIRECTION_UP, skip);
967 }
968
969 _public_ int sd_journal_get_cursor(sd_journal *j, char **cursor) {
970 Object *o;
971 int r;
972 char bid[33], sid[33];
973
974 assert_return(j, -EINVAL);
975 assert_return(!journal_pid_changed(j), -ECHILD);
976 assert_return(cursor, -EINVAL);
977
978 if (!j->current_file || j->current_file->current_offset <= 0)
979 return -EADDRNOTAVAIL;
980
981 r = journal_file_move_to_object(j->current_file, OBJECT_ENTRY, j->current_file->current_offset, &o);
982 if (r < 0)
983 return r;
984
985 sd_id128_to_string(j->current_file->header->seqnum_id, sid);
986 sd_id128_to_string(o->entry.boot_id, bid);
987
988 if (asprintf(cursor,
989 "s=%s;i=%"PRIx64";b=%s;m=%"PRIx64";t=%"PRIx64";x=%"PRIx64,
990 sid, le64toh(o->entry.seqnum),
991 bid, le64toh(o->entry.monotonic),
992 le64toh(o->entry.realtime),
993 le64toh(o->entry.xor_hash)) < 0)
994 return -ENOMEM;
995
996 return 0;
997 }
998
999 _public_ int sd_journal_seek_cursor(sd_journal *j, const char *cursor) {
1000 char *w, *state;
1001 size_t l;
1002 unsigned long long seqnum, monotonic, realtime, xor_hash;
1003 bool
1004 seqnum_id_set = false,
1005 seqnum_set = false,
1006 boot_id_set = false,
1007 monotonic_set = false,
1008 realtime_set = false,
1009 xor_hash_set = false;
1010 sd_id128_t seqnum_id, boot_id;
1011
1012 assert_return(j, -EINVAL);
1013 assert_return(!journal_pid_changed(j), -ECHILD);
1014 assert_return(!isempty(cursor), -EINVAL);
1015
1016 FOREACH_WORD_SEPARATOR(w, l, cursor, ";", state) {
1017 char *item;
1018 int k = 0;
1019
1020 if (l < 2 || w[1] != '=')
1021 return -EINVAL;
1022
1023 item = strndup(w, l);
1024 if (!item)
1025 return -ENOMEM;
1026
1027 switch (w[0]) {
1028
1029 case 's':
1030 seqnum_id_set = true;
1031 k = sd_id128_from_string(item+2, &seqnum_id);
1032 break;
1033
1034 case 'i':
1035 seqnum_set = true;
1036 if (sscanf(item+2, "%llx", &seqnum) != 1)
1037 k = -EINVAL;
1038 break;
1039
1040 case 'b':
1041 boot_id_set = true;
1042 k = sd_id128_from_string(item+2, &boot_id);
1043 break;
1044
1045 case 'm':
1046 monotonic_set = true;
1047 if (sscanf(item+2, "%llx", &monotonic) != 1)
1048 k = -EINVAL;
1049 break;
1050
1051 case 't':
1052 realtime_set = true;
1053 if (sscanf(item+2, "%llx", &realtime) != 1)
1054 k = -EINVAL;
1055 break;
1056
1057 case 'x':
1058 xor_hash_set = true;
1059 if (sscanf(item+2, "%llx", &xor_hash) != 1)
1060 k = -EINVAL;
1061 break;
1062 }
1063
1064 free(item);
1065
1066 if (k < 0)
1067 return k;
1068 }
1069
1070 if ((!seqnum_set || !seqnum_id_set) &&
1071 (!monotonic_set || !boot_id_set) &&
1072 !realtime_set)
1073 return -EINVAL;
1074
1075 reset_location(j);
1076
1077 j->current_location.type = LOCATION_SEEK;
1078
1079 if (realtime_set) {
1080 j->current_location.realtime = (uint64_t) realtime;
1081 j->current_location.realtime_set = true;
1082 }
1083
1084 if (seqnum_set && seqnum_id_set) {
1085 j->current_location.seqnum = (uint64_t) seqnum;
1086 j->current_location.seqnum_id = seqnum_id;
1087 j->current_location.seqnum_set = true;
1088 }
1089
1090 if (monotonic_set && boot_id_set) {
1091 j->current_location.monotonic = (uint64_t) monotonic;
1092 j->current_location.boot_id = boot_id;
1093 j->current_location.monotonic_set = true;
1094 }
1095
1096 if (xor_hash_set) {
1097 j->current_location.xor_hash = (uint64_t) xor_hash;
1098 j->current_location.xor_hash_set = true;
1099 }
1100
1101 return 0;
1102 }
1103
1104 _public_ int sd_journal_test_cursor(sd_journal *j, const char *cursor) {
1105 int r;
1106 char *w, *state;
1107 size_t l;
1108 Object *o;
1109
1110 assert_return(j, -EINVAL);
1111 assert_return(!journal_pid_changed(j), -ECHILD);
1112 assert_return(!isempty(cursor), -EINVAL);
1113
1114 if (!j->current_file || j->current_file->current_offset <= 0)
1115 return -EADDRNOTAVAIL;
1116
1117 r = journal_file_move_to_object(j->current_file, OBJECT_ENTRY, j->current_file->current_offset, &o);
1118 if (r < 0)
1119 return r;
1120
1121 FOREACH_WORD_SEPARATOR(w, l, cursor, ";", state) {
1122 _cleanup_free_ char *item = NULL;
1123 sd_id128_t id;
1124 unsigned long long ll;
1125 int k = 0;
1126
1127 if (l < 2 || w[1] != '=')
1128 return -EINVAL;
1129
1130 item = strndup(w, l);
1131 if (!item)
1132 return -ENOMEM;
1133
1134 switch (w[0]) {
1135
1136 case 's':
1137 k = sd_id128_from_string(item+2, &id);
1138 if (k < 0)
1139 return k;
1140 if (!sd_id128_equal(id, j->current_file->header->seqnum_id))
1141 return 0;
1142 break;
1143
1144 case 'i':
1145 if (sscanf(item+2, "%llx", &ll) != 1)
1146 return -EINVAL;
1147 if (ll != le64toh(o->entry.seqnum))
1148 return 0;
1149 break;
1150
1151 case 'b':
1152 k = sd_id128_from_string(item+2, &id);
1153 if (k < 0)
1154 return k;
1155 if (!sd_id128_equal(id, o->entry.boot_id))
1156 return 0;
1157 break;
1158
1159 case 'm':
1160 if (sscanf(item+2, "%llx", &ll) != 1)
1161 return -EINVAL;
1162 if (ll != le64toh(o->entry.monotonic))
1163 return 0;
1164 break;
1165
1166 case 't':
1167 if (sscanf(item+2, "%llx", &ll) != 1)
1168 return -EINVAL;
1169 if (ll != le64toh(o->entry.realtime))
1170 return 0;
1171 break;
1172
1173 case 'x':
1174 if (sscanf(item+2, "%llx", &ll) != 1)
1175 return -EINVAL;
1176 if (ll != le64toh(o->entry.xor_hash))
1177 return 0;
1178 break;
1179 }
1180 }
1181
1182 return 1;
1183 }
1184
1185
1186 _public_ int sd_journal_seek_monotonic_usec(sd_journal *j, sd_id128_t boot_id, uint64_t usec) {
1187 assert_return(j, -EINVAL);
1188 assert_return(!journal_pid_changed(j), -ECHILD);
1189
1190 reset_location(j);
1191 j->current_location.type = LOCATION_SEEK;
1192 j->current_location.boot_id = boot_id;
1193 j->current_location.monotonic = usec;
1194 j->current_location.monotonic_set = true;
1195
1196 return 0;
1197 }
1198
1199 _public_ int sd_journal_seek_realtime_usec(sd_journal *j, uint64_t usec) {
1200 assert_return(j, -EINVAL);
1201 assert_return(!journal_pid_changed(j), -ECHILD);
1202
1203 reset_location(j);
1204 j->current_location.type = LOCATION_SEEK;
1205 j->current_location.realtime = usec;
1206 j->current_location.realtime_set = true;
1207
1208 return 0;
1209 }
1210
1211 _public_ int sd_journal_seek_head(sd_journal *j) {
1212 assert_return(j, -EINVAL);
1213 assert_return(!journal_pid_changed(j), -ECHILD);
1214
1215 reset_location(j);
1216 j->current_location.type = LOCATION_HEAD;
1217
1218 return 0;
1219 }
1220
1221 _public_ int sd_journal_seek_tail(sd_journal *j) {
1222 assert_return(j, -EINVAL);
1223 assert_return(!journal_pid_changed(j), -ECHILD);
1224
1225 reset_location(j);
1226 j->current_location.type = LOCATION_TAIL;
1227
1228 return 0;
1229 }
1230
1231 static void check_network(sd_journal *j, int fd) {
1232 struct statfs sfs;
1233
1234 assert(j);
1235
1236 if (j->on_network)
1237 return;
1238
1239 if (fstatfs(fd, &sfs) < 0)
1240 return;
1241
1242 j->on_network =
1243 F_TYPE_EQUAL(sfs.f_type, CIFS_MAGIC_NUMBER) ||
1244 F_TYPE_EQUAL(sfs.f_type, CODA_SUPER_MAGIC) ||
1245 F_TYPE_EQUAL(sfs.f_type, NCP_SUPER_MAGIC) ||
1246 F_TYPE_EQUAL(sfs.f_type, NFS_SUPER_MAGIC) ||
1247 F_TYPE_EQUAL(sfs.f_type, SMB_SUPER_MAGIC);
1248 }
1249
1250 static bool file_has_type_prefix(const char *prefix, const char *filename) {
1251 const char *full, *tilded, *atted;
1252
1253 full = strappenda(prefix, ".journal");
1254 tilded = strappenda(full, "~");
1255 atted = strappenda(prefix, "@");
1256
1257 return streq(filename, full) ||
1258 streq(filename, tilded) ||
1259 startswith(filename, atted);
1260 }
1261
1262 static bool file_type_wanted(int flags, const char *filename) {
1263 if (!endswith(filename, ".journal") && !endswith(filename, ".journal~"))
1264 return false;
1265
1266 /* no flags set → every type is OK */
1267 if (!(flags & (SD_JOURNAL_SYSTEM | SD_JOURNAL_CURRENT_USER)))
1268 return true;
1269
1270 if (flags & SD_JOURNAL_SYSTEM && file_has_type_prefix("system", filename))
1271 return true;
1272
1273 if (flags & SD_JOURNAL_CURRENT_USER) {
1274 char prefix[5 + DECIMAL_STR_MAX(uid_t) + 1];
1275
1276 assert_se(snprintf(prefix, sizeof(prefix), "user-%lu", (unsigned long) getuid())
1277 < (int) sizeof(prefix));
1278
1279 if (file_has_type_prefix(prefix, filename))
1280 return true;
1281 }
1282
1283 return false;
1284 }
1285
1286 static int add_any_file(sd_journal *j, const char *path) {
1287 JournalFile *f = NULL;
1288 int r;
1289
1290 assert(j);
1291 assert(path);
1292
1293 if (hashmap_get(j->files, path))
1294 return 0;
1295
1296 if (hashmap_size(j->files) >= JOURNAL_FILES_MAX) {
1297 log_warning("Too many open journal files, not adding %s.", path);
1298 return set_put_error(j, -ETOOMANYREFS);
1299 }
1300
1301 r = journal_file_open(path, O_RDONLY, 0, false, false, NULL, j->mmap, NULL, &f);
1302 if (r < 0)
1303 return r;
1304
1305 /* journal_file_dump(f); */
1306
1307 r = hashmap_put(j->files, f->path, f);
1308 if (r < 0) {
1309 journal_file_close(f);
1310 return r;
1311 }
1312
1313 log_debug("File %s added.", f->path);
1314
1315 check_network(j, f->fd);
1316
1317 j->current_invalidate_counter ++;
1318
1319 return 0;
1320 }
1321
1322 static int add_file(sd_journal *j, const char *prefix, const char *filename) {
1323 _cleanup_free_ char *path = NULL;
1324 int r;
1325
1326 assert(j);
1327 assert(prefix);
1328 assert(filename);
1329
1330 if (j->no_new_files ||
1331 !file_type_wanted(j->flags, filename))
1332 return 0;
1333
1334 path = strjoin(prefix, "/", filename, NULL);
1335 if (!path)
1336 return -ENOMEM;
1337
1338 r = add_any_file(j, path);
1339 if (r == -ENOENT)
1340 return 0;
1341 return 0;
1342 }
1343
1344 static int remove_file(sd_journal *j, const char *prefix, const char *filename) {
1345 _cleanup_free_ char *path;
1346 JournalFile *f;
1347
1348 assert(j);
1349 assert(prefix);
1350 assert(filename);
1351
1352 path = strjoin(prefix, "/", filename, NULL);
1353 if (!path)
1354 return -ENOMEM;
1355
1356 f = hashmap_get(j->files, path);
1357 if (!f)
1358 return 0;
1359
1360 remove_file_real(j, f);
1361 return 0;
1362 }
1363
1364 static void remove_file_real(sd_journal *j, JournalFile *f) {
1365 assert(j);
1366 assert(f);
1367
1368 hashmap_remove(j->files, f->path);
1369
1370 log_debug("File %s removed.", f->path);
1371
1372 if (j->current_file == f) {
1373 j->current_file = NULL;
1374 j->current_field = 0;
1375 }
1376
1377 if (j->unique_file == f) {
1378 j->unique_file = NULL;
1379 j->unique_offset = 0;
1380 }
1381
1382 journal_file_close(f);
1383
1384 j->current_invalidate_counter ++;
1385 }
1386
1387 static int add_directory(sd_journal *j, const char *prefix, const char *dirname) {
1388 _cleanup_free_ char *path = NULL;
1389 int r;
1390 _cleanup_closedir_ DIR *d = NULL;
1391 sd_id128_t id, mid;
1392 Directory *m;
1393
1394 assert(j);
1395 assert(prefix);
1396 assert(dirname);
1397
1398 log_debug("Considering %s/%s.", prefix, dirname);
1399
1400 if ((j->flags & SD_JOURNAL_LOCAL_ONLY) &&
1401 (sd_id128_from_string(dirname, &id) < 0 ||
1402 sd_id128_get_machine(&mid) < 0 ||
1403 !(sd_id128_equal(id, mid) || path_startswith(prefix, "/run"))))
1404 return 0;
1405
1406 path = strjoin(prefix, "/", dirname, NULL);
1407 if (!path)
1408 return -ENOMEM;
1409
1410 d = opendir(path);
1411 if (!d) {
1412 log_debug("Failed to open %s: %m", path);
1413 if (errno == ENOENT)
1414 return 0;
1415 return -errno;
1416 }
1417
1418 m = hashmap_get(j->directories_by_path, path);
1419 if (!m) {
1420 m = new0(Directory, 1);
1421 if (!m)
1422 return -ENOMEM;
1423
1424 m->is_root = false;
1425 m->path = path;
1426
1427 if (hashmap_put(j->directories_by_path, m->path, m) < 0) {
1428 free(m);
1429 return -ENOMEM;
1430 }
1431
1432 path = NULL; /* avoid freeing in cleanup */
1433 j->current_invalidate_counter ++;
1434
1435 log_debug("Directory %s added.", m->path);
1436
1437 } else if (m->is_root)
1438 return 0;
1439
1440 if (m->wd <= 0 && j->inotify_fd >= 0) {
1441
1442 m->wd = inotify_add_watch(j->inotify_fd, m->path,
1443 IN_CREATE|IN_MOVED_TO|IN_MODIFY|IN_ATTRIB|IN_DELETE|
1444 IN_DELETE_SELF|IN_MOVE_SELF|IN_UNMOUNT|IN_MOVED_FROM|
1445 IN_ONLYDIR);
1446
1447 if (m->wd > 0 && hashmap_put(j->directories_by_wd, INT_TO_PTR(m->wd), m) < 0)
1448 inotify_rm_watch(j->inotify_fd, m->wd);
1449 }
1450
1451 for (;;) {
1452 struct dirent *de;
1453
1454 errno = 0;
1455 de = readdir(d);
1456 if (!de && errno != 0) {
1457 r = -errno;
1458 log_debug("Failed to read directory %s: %s",
1459 m->path, strerror(errno));
1460 return r;
1461 }
1462 if (!de)
1463 break;
1464
1465 if (dirent_is_file_with_suffix(de, ".journal") ||
1466 dirent_is_file_with_suffix(de, ".journal~")) {
1467 r = add_file(j, m->path, de->d_name);
1468 if (r < 0) {
1469 log_debug("Failed to add file %s/%s: %s",
1470 m->path, de->d_name, strerror(-r));
1471 r = set_put_error(j, r);
1472 if (r < 0)
1473 return r;
1474 }
1475 }
1476 }
1477
1478 check_network(j, dirfd(d));
1479
1480 return 0;
1481 }
1482
1483 static int add_root_directory(sd_journal *j, const char *p) {
1484 _cleanup_closedir_ DIR *d = NULL;
1485 Directory *m;
1486 int r;
1487
1488 assert(j);
1489 assert(p);
1490
1491 if ((j->flags & SD_JOURNAL_RUNTIME_ONLY) &&
1492 !path_startswith(p, "/run"))
1493 return -EINVAL;
1494
1495 if (j->prefix)
1496 p = strappenda(j->prefix, p);
1497
1498 d = opendir(p);
1499 if (!d)
1500 return -errno;
1501
1502 m = hashmap_get(j->directories_by_path, p);
1503 if (!m) {
1504 m = new0(Directory, 1);
1505 if (!m)
1506 return -ENOMEM;
1507
1508 m->is_root = true;
1509 m->path = strdup(p);
1510 if (!m->path) {
1511 free(m);
1512 return -ENOMEM;
1513 }
1514
1515 if (hashmap_put(j->directories_by_path, m->path, m) < 0) {
1516 free(m->path);
1517 free(m);
1518 return -ENOMEM;
1519 }
1520
1521 j->current_invalidate_counter ++;
1522
1523 log_debug("Root directory %s added.", m->path);
1524
1525 } else if (!m->is_root)
1526 return 0;
1527
1528 if (m->wd <= 0 && j->inotify_fd >= 0) {
1529
1530 m->wd = inotify_add_watch(j->inotify_fd, m->path,
1531 IN_CREATE|IN_MOVED_TO|IN_MODIFY|IN_ATTRIB|IN_DELETE|
1532 IN_ONLYDIR);
1533
1534 if (m->wd > 0 && hashmap_put(j->directories_by_wd, INT_TO_PTR(m->wd), m) < 0)
1535 inotify_rm_watch(j->inotify_fd, m->wd);
1536 }
1537
1538 if (j->no_new_files)
1539 return 0;
1540
1541 for (;;) {
1542 struct dirent *de;
1543 sd_id128_t id;
1544
1545 errno = 0;
1546 de = readdir(d);
1547 if (!de && errno != 0) {
1548 r = -errno;
1549 log_debug("Failed to read directory %s: %s",
1550 m->path, strerror(errno));
1551 return r;
1552 }
1553 if (!de)
1554 break;
1555
1556 if (dirent_is_file_with_suffix(de, ".journal") ||
1557 dirent_is_file_with_suffix(de, ".journal~")) {
1558 r = add_file(j, m->path, de->d_name);
1559 if (r < 0) {
1560 log_debug("Failed to add file %s/%s: %s",
1561 m->path, de->d_name, strerror(-r));
1562 r = set_put_error(j, r);
1563 if (r < 0)
1564 return r;
1565 }
1566 } else if ((de->d_type == DT_DIR || de->d_type == DT_LNK || de->d_type == DT_UNKNOWN) &&
1567 sd_id128_from_string(de->d_name, &id) >= 0) {
1568
1569 r = add_directory(j, m->path, de->d_name);
1570 if (r < 0)
1571 log_debug("Failed to add directory %s/%s: %s", m->path, de->d_name, strerror(-r));
1572 }
1573 }
1574
1575 check_network(j, dirfd(d));
1576
1577 return 0;
1578 }
1579
1580 static int remove_directory(sd_journal *j, Directory *d) {
1581 assert(j);
1582
1583 if (d->wd > 0) {
1584 hashmap_remove(j->directories_by_wd, INT_TO_PTR(d->wd));
1585
1586 if (j->inotify_fd >= 0)
1587 inotify_rm_watch(j->inotify_fd, d->wd);
1588 }
1589
1590 hashmap_remove(j->directories_by_path, d->path);
1591
1592 if (d->is_root)
1593 log_debug("Root directory %s removed.", d->path);
1594 else
1595 log_debug("Directory %s removed.", d->path);
1596
1597 free(d->path);
1598 free(d);
1599
1600 return 0;
1601 }
1602
1603 static int add_search_paths(sd_journal *j) {
1604 int r;
1605 const char search_paths[] =
1606 "/run/log/journal\0"
1607 "/var/log/journal\0";
1608 const char *p;
1609
1610 assert(j);
1611
1612 /* We ignore most errors here, since the idea is to only open
1613 * what's actually accessible, and ignore the rest. */
1614
1615 NULSTR_FOREACH(p, search_paths) {
1616 r = add_root_directory(j, p);
1617 if (r < 0 && r != -ENOENT) {
1618 r = set_put_error(j, r);
1619 if (r < 0)
1620 return r;
1621 }
1622 }
1623
1624 return 0;
1625 }
1626
1627 static int add_current_paths(sd_journal *j) {
1628 Iterator i;
1629 JournalFile *f;
1630
1631 assert(j);
1632 assert(j->no_new_files);
1633
1634 /* Simply adds all directories for files we have open as
1635 * "root" directories. We don't expect errors here, so we
1636 * treat them as fatal. */
1637
1638 HASHMAP_FOREACH(f, j->files, i) {
1639 _cleanup_free_ char *dir;
1640 int r;
1641
1642 dir = dirname_malloc(f->path);
1643 if (!dir)
1644 return -ENOMEM;
1645
1646 r = add_root_directory(j, dir);
1647 if (r < 0) {
1648 set_put_error(j, r);
1649 return r;
1650 }
1651 }
1652
1653 return 0;
1654 }
1655
1656
1657 static int allocate_inotify(sd_journal *j) {
1658 assert(j);
1659
1660 if (j->inotify_fd < 0) {
1661 j->inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
1662 if (j->inotify_fd < 0)
1663 return -errno;
1664 }
1665
1666 if (!j->directories_by_wd) {
1667 j->directories_by_wd = hashmap_new(trivial_hash_func, trivial_compare_func);
1668 if (!j->directories_by_wd)
1669 return -ENOMEM;
1670 }
1671
1672 return 0;
1673 }
1674
1675 static sd_journal *journal_new(int flags, const char *path) {
1676 sd_journal *j;
1677
1678 j = new0(sd_journal, 1);
1679 if (!j)
1680 return NULL;
1681
1682 j->original_pid = getpid();
1683 j->inotify_fd = -1;
1684 j->flags = flags;
1685 j->data_threshold = DEFAULT_DATA_THRESHOLD;
1686
1687 if (path) {
1688 j->path = strdup(path);
1689 if (!j->path)
1690 goto fail;
1691 }
1692
1693 j->files = hashmap_new(string_hash_func, string_compare_func);
1694 j->directories_by_path = hashmap_new(string_hash_func, string_compare_func);
1695 j->mmap = mmap_cache_new();
1696 if (!j->files || !j->directories_by_path || !j->mmap)
1697 goto fail;
1698
1699 return j;
1700
1701 fail:
1702 sd_journal_close(j);
1703 return NULL;
1704 }
1705
1706 _public_ int sd_journal_open(sd_journal **ret, int flags) {
1707 sd_journal *j;
1708 int r;
1709
1710 assert_return(ret, -EINVAL);
1711 assert_return((flags & ~(SD_JOURNAL_LOCAL_ONLY|SD_JOURNAL_RUNTIME_ONLY|SD_JOURNAL_SYSTEM|SD_JOURNAL_CURRENT_USER)) == 0, -EINVAL);
1712
1713 j = journal_new(flags, NULL);
1714 if (!j)
1715 return -ENOMEM;
1716
1717 r = add_search_paths(j);
1718 if (r < 0)
1719 goto fail;
1720
1721 *ret = j;
1722 return 0;
1723
1724 fail:
1725 sd_journal_close(j);
1726
1727 return r;
1728 }
1729
1730 _public_ int sd_journal_open_container(sd_journal **ret, const char *machine, int flags) {
1731 _cleanup_free_ char *root = NULL, *class = NULL;
1732 sd_journal *j;
1733 char *p;
1734 int r;
1735
1736 assert_return(machine, -EINVAL);
1737 assert_return(ret, -EINVAL);
1738 assert_return((flags & ~(SD_JOURNAL_LOCAL_ONLY|SD_JOURNAL_SYSTEM)) == 0, -EINVAL);
1739 assert_return(filename_is_safe(machine), -EINVAL);
1740
1741 p = strappenda("/run/systemd/machines/", machine);
1742 r = parse_env_file(p, NEWLINE, "ROOT", &root, "CLASS", &class, NULL);
1743 if (r == -ENOENT)
1744 return -EHOSTDOWN;
1745 if (r < 0)
1746 return r;
1747 if (!root)
1748 return -ENODATA;
1749
1750 if (!streq_ptr(class, "container"))
1751 return -EIO;
1752
1753 j = journal_new(flags, NULL);
1754 if (!j)
1755 return -ENOMEM;
1756
1757 j->prefix = root;
1758 root = NULL;
1759
1760 r = add_search_paths(j);
1761 if (r < 0)
1762 goto fail;
1763
1764 *ret = j;
1765 return 0;
1766
1767 fail:
1768 sd_journal_close(j);
1769 return r;
1770 }
1771
1772 _public_ int sd_journal_open_directory(sd_journal **ret, const char *path, int flags) {
1773 sd_journal *j;
1774 int r;
1775
1776 assert_return(ret, -EINVAL);
1777 assert_return(path, -EINVAL);
1778 assert_return(flags == 0, -EINVAL);
1779
1780 j = journal_new(flags, path);
1781 if (!j)
1782 return -ENOMEM;
1783
1784 r = add_root_directory(j, path);
1785 if (r < 0) {
1786 set_put_error(j, r);
1787 goto fail;
1788 }
1789
1790 *ret = j;
1791 return 0;
1792
1793 fail:
1794 sd_journal_close(j);
1795
1796 return r;
1797 }
1798
1799 _public_ int sd_journal_open_files(sd_journal **ret, const char **paths, int flags) {
1800 sd_journal *j;
1801 const char **path;
1802 int r;
1803
1804 assert_return(ret, -EINVAL);
1805 assert_return(flags == 0, -EINVAL);
1806
1807 j = journal_new(flags, NULL);
1808 if (!j)
1809 return -ENOMEM;
1810
1811 STRV_FOREACH(path, paths) {
1812 r = add_any_file(j, *path);
1813 if (r < 0) {
1814 log_error("Failed to open %s: %s", *path, strerror(-r));
1815 goto fail;
1816 }
1817 }
1818
1819 j->no_new_files = true;
1820
1821 *ret = j;
1822 return 0;
1823
1824 fail:
1825 sd_journal_close(j);
1826
1827 return r;
1828 }
1829
1830 _public_ void sd_journal_close(sd_journal *j) {
1831 Directory *d;
1832 JournalFile *f;
1833
1834 if (!j)
1835 return;
1836
1837 sd_journal_flush_matches(j);
1838
1839 while ((f = hashmap_steal_first(j->files)))
1840 journal_file_close(f);
1841
1842 hashmap_free(j->files);
1843
1844 while ((d = hashmap_first(j->directories_by_path)))
1845 remove_directory(j, d);
1846
1847 while ((d = hashmap_first(j->directories_by_wd)))
1848 remove_directory(j, d);
1849
1850 hashmap_free(j->directories_by_path);
1851 hashmap_free(j->directories_by_wd);
1852
1853 safe_close(j->inotify_fd);
1854
1855 if (j->mmap) {
1856 log_debug("mmap cache statistics: %u hit, %u miss", mmap_cache_get_hit(j->mmap), mmap_cache_get_missed(j->mmap));
1857 mmap_cache_unref(j->mmap);
1858 }
1859
1860 free(j->path);
1861 free(j->prefix);
1862 free(j->unique_field);
1863 set_free(j->errors);
1864 free(j);
1865 }
1866
1867 _public_ int sd_journal_get_realtime_usec(sd_journal *j, uint64_t *ret) {
1868 Object *o;
1869 JournalFile *f;
1870 int r;
1871
1872 assert_return(j, -EINVAL);
1873 assert_return(!journal_pid_changed(j), -ECHILD);
1874 assert_return(ret, -EINVAL);
1875
1876 f = j->current_file;
1877 if (!f)
1878 return -EADDRNOTAVAIL;
1879
1880 if (f->current_offset <= 0)
1881 return -EADDRNOTAVAIL;
1882
1883 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
1884 if (r < 0)
1885 return r;
1886
1887 *ret = le64toh(o->entry.realtime);
1888 return 0;
1889 }
1890
1891 _public_ int sd_journal_get_monotonic_usec(sd_journal *j, uint64_t *ret, sd_id128_t *ret_boot_id) {
1892 Object *o;
1893 JournalFile *f;
1894 int r;
1895 sd_id128_t id;
1896
1897 assert_return(j, -EINVAL);
1898 assert_return(!journal_pid_changed(j), -ECHILD);
1899
1900 f = j->current_file;
1901 if (!f)
1902 return -EADDRNOTAVAIL;
1903
1904 if (f->current_offset <= 0)
1905 return -EADDRNOTAVAIL;
1906
1907 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
1908 if (r < 0)
1909 return r;
1910
1911 if (ret_boot_id)
1912 *ret_boot_id = o->entry.boot_id;
1913 else {
1914 r = sd_id128_get_boot(&id);
1915 if (r < 0)
1916 return r;
1917
1918 if (!sd_id128_equal(id, o->entry.boot_id))
1919 return -ESTALE;
1920 }
1921
1922 if (ret)
1923 *ret = le64toh(o->entry.monotonic);
1924
1925 return 0;
1926 }
1927
1928 static bool field_is_valid(const char *field) {
1929 const char *p;
1930
1931 assert(field);
1932
1933 if (isempty(field))
1934 return false;
1935
1936 if (startswith(field, "__"))
1937 return false;
1938
1939 for (p = field; *p; p++) {
1940
1941 if (*p == '_')
1942 continue;
1943
1944 if (*p >= 'A' && *p <= 'Z')
1945 continue;
1946
1947 if (*p >= '0' && *p <= '9')
1948 continue;
1949
1950 return false;
1951 }
1952
1953 return true;
1954 }
1955
1956 _public_ int sd_journal_get_data(sd_journal *j, const char *field, const void **data, size_t *size) {
1957 JournalFile *f;
1958 uint64_t i, n;
1959 size_t field_length;
1960 int r;
1961 Object *o;
1962
1963 assert_return(j, -EINVAL);
1964 assert_return(!journal_pid_changed(j), -ECHILD);
1965 assert_return(field, -EINVAL);
1966 assert_return(data, -EINVAL);
1967 assert_return(size, -EINVAL);
1968 assert_return(field_is_valid(field), -EINVAL);
1969
1970 f = j->current_file;
1971 if (!f)
1972 return -EADDRNOTAVAIL;
1973
1974 if (f->current_offset <= 0)
1975 return -EADDRNOTAVAIL;
1976
1977 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
1978 if (r < 0)
1979 return r;
1980
1981 field_length = strlen(field);
1982
1983 n = journal_file_entry_n_items(o);
1984 for (i = 0; i < n; i++) {
1985 uint64_t p, l;
1986 le64_t le_hash;
1987 size_t t;
1988
1989 p = le64toh(o->entry.items[i].object_offset);
1990 le_hash = o->entry.items[i].hash;
1991 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
1992 if (r < 0)
1993 return r;
1994
1995 if (le_hash != o->data.hash)
1996 return -EBADMSG;
1997
1998 l = le64toh(o->object.size) - offsetof(Object, data.payload);
1999
2000 if (o->object.flags & OBJECT_COMPRESSED) {
2001
2002 #ifdef HAVE_XZ
2003 if (uncompress_startswith(o->data.payload, l,
2004 &f->compress_buffer, &f->compress_buffer_size,
2005 field, field_length, '=')) {
2006
2007 uint64_t rsize;
2008
2009 if (!uncompress_blob(o->data.payload, l,
2010 &f->compress_buffer, &f->compress_buffer_size, &rsize,
2011 j->data_threshold))
2012 return -EBADMSG;
2013
2014 *data = f->compress_buffer;
2015 *size = (size_t) rsize;
2016
2017 return 0;
2018 }
2019 #else
2020 return -EPROTONOSUPPORT;
2021 #endif
2022
2023 } else if (l >= field_length+1 &&
2024 memcmp(o->data.payload, field, field_length) == 0 &&
2025 o->data.payload[field_length] == '=') {
2026
2027 t = (size_t) l;
2028
2029 if ((uint64_t) t != l)
2030 return -E2BIG;
2031
2032 *data = o->data.payload;
2033 *size = t;
2034
2035 return 0;
2036 }
2037
2038 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
2039 if (r < 0)
2040 return r;
2041 }
2042
2043 return -ENOENT;
2044 }
2045
2046 static int return_data(sd_journal *j, JournalFile *f, Object *o, const void **data, size_t *size) {
2047 size_t t;
2048 uint64_t l;
2049
2050 l = le64toh(o->object.size) - offsetof(Object, data.payload);
2051 t = (size_t) l;
2052
2053 /* We can't read objects larger than 4G on a 32bit machine */
2054 if ((uint64_t) t != l)
2055 return -E2BIG;
2056
2057 if (o->object.flags & OBJECT_COMPRESSED) {
2058 #ifdef HAVE_XZ
2059 uint64_t rsize;
2060
2061 if (!uncompress_blob(o->data.payload, l, &f->compress_buffer, &f->compress_buffer_size, &rsize, j->data_threshold))
2062 return -EBADMSG;
2063
2064 *data = f->compress_buffer;
2065 *size = (size_t) rsize;
2066 #else
2067 return -EPROTONOSUPPORT;
2068 #endif
2069 } else {
2070 *data = o->data.payload;
2071 *size = t;
2072 }
2073
2074 return 0;
2075 }
2076
2077 _public_ int sd_journal_enumerate_data(sd_journal *j, const void **data, size_t *size) {
2078 JournalFile *f;
2079 uint64_t p, n;
2080 le64_t le_hash;
2081 int r;
2082 Object *o;
2083
2084 assert_return(j, -EINVAL);
2085 assert_return(!journal_pid_changed(j), -ECHILD);
2086 assert_return(data, -EINVAL);
2087 assert_return(size, -EINVAL);
2088
2089 f = j->current_file;
2090 if (!f)
2091 return -EADDRNOTAVAIL;
2092
2093 if (f->current_offset <= 0)
2094 return -EADDRNOTAVAIL;
2095
2096 r = journal_file_move_to_object(f, OBJECT_ENTRY, f->current_offset, &o);
2097 if (r < 0)
2098 return r;
2099
2100 n = journal_file_entry_n_items(o);
2101 if (j->current_field >= n)
2102 return 0;
2103
2104 p = le64toh(o->entry.items[j->current_field].object_offset);
2105 le_hash = o->entry.items[j->current_field].hash;
2106 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
2107 if (r < 0)
2108 return r;
2109
2110 if (le_hash != o->data.hash)
2111 return -EBADMSG;
2112
2113 r = return_data(j, f, o, data, size);
2114 if (r < 0)
2115 return r;
2116
2117 j->current_field ++;
2118
2119 return 1;
2120 }
2121
2122 _public_ void sd_journal_restart_data(sd_journal *j) {
2123 if (!j)
2124 return;
2125
2126 j->current_field = 0;
2127 }
2128
2129 _public_ int sd_journal_get_fd(sd_journal *j) {
2130 int r;
2131
2132 assert_return(j, -EINVAL);
2133 assert_return(!journal_pid_changed(j), -ECHILD);
2134
2135 if (j->inotify_fd >= 0)
2136 return j->inotify_fd;
2137
2138 r = allocate_inotify(j);
2139 if (r < 0)
2140 return r;
2141
2142 /* Iterate through all dirs again, to add them to the
2143 * inotify */
2144 if (j->no_new_files)
2145 r = add_current_paths(j);
2146 else if (j->path)
2147 r = add_root_directory(j, j->path);
2148 else
2149 r = add_search_paths(j);
2150 if (r < 0)
2151 return r;
2152
2153 return j->inotify_fd;
2154 }
2155
2156 _public_ int sd_journal_get_events(sd_journal *j) {
2157 int fd;
2158
2159 assert_return(j, -EINVAL);
2160 assert_return(!journal_pid_changed(j), -ECHILD);
2161
2162 fd = sd_journal_get_fd(j);
2163 if (fd < 0)
2164 return fd;
2165
2166 return POLLIN;
2167 }
2168
2169 _public_ int sd_journal_get_timeout(sd_journal *j, uint64_t *timeout_usec) {
2170 int fd;
2171
2172 assert_return(j, -EINVAL);
2173 assert_return(!journal_pid_changed(j), -ECHILD);
2174 assert_return(timeout_usec, -EINVAL);
2175
2176 fd = sd_journal_get_fd(j);
2177 if (fd < 0)
2178 return fd;
2179
2180 if (!j->on_network) {
2181 *timeout_usec = (uint64_t) -1;
2182 return 0;
2183 }
2184
2185 /* If we are on the network we need to regularly check for
2186 * changes manually */
2187
2188 *timeout_usec = j->last_process_usec + JOURNAL_FILES_RECHECK_USEC;
2189 return 1;
2190 }
2191
2192 static void process_inotify_event(sd_journal *j, struct inotify_event *e) {
2193 Directory *d;
2194 int r;
2195
2196 assert(j);
2197 assert(e);
2198
2199 /* Is this a subdirectory we watch? */
2200 d = hashmap_get(j->directories_by_wd, INT_TO_PTR(e->wd));
2201 if (d) {
2202 sd_id128_t id;
2203
2204 if (!(e->mask & IN_ISDIR) && e->len > 0 &&
2205 (endswith(e->name, ".journal") ||
2206 endswith(e->name, ".journal~"))) {
2207
2208 /* Event for a journal file */
2209
2210 if (e->mask & (IN_CREATE|IN_MOVED_TO|IN_MODIFY|IN_ATTRIB)) {
2211 r = add_file(j, d->path, e->name);
2212 if (r < 0) {
2213 log_debug("Failed to add file %s/%s: %s",
2214 d->path, e->name, strerror(-r));
2215 set_put_error(j, r);
2216 }
2217
2218 } else if (e->mask & (IN_DELETE|IN_MOVED_FROM|IN_UNMOUNT)) {
2219
2220 r = remove_file(j, d->path, e->name);
2221 if (r < 0)
2222 log_debug("Failed to remove file %s/%s: %s", d->path, e->name, strerror(-r));
2223 }
2224
2225 } else if (!d->is_root && e->len == 0) {
2226
2227 /* Event for a subdirectory */
2228
2229 if (e->mask & (IN_DELETE_SELF|IN_MOVE_SELF|IN_UNMOUNT)) {
2230 r = remove_directory(j, d);
2231 if (r < 0)
2232 log_debug("Failed to remove directory %s: %s", d->path, strerror(-r));
2233 }
2234
2235
2236 } else if (d->is_root && (e->mask & IN_ISDIR) && e->len > 0 && sd_id128_from_string(e->name, &id) >= 0) {
2237
2238 /* Event for root directory */
2239
2240 if (e->mask & (IN_CREATE|IN_MOVED_TO|IN_MODIFY|IN_ATTRIB)) {
2241 r = add_directory(j, d->path, e->name);
2242 if (r < 0)
2243 log_debug("Failed to add directory %s/%s: %s", d->path, e->name, strerror(-r));
2244 }
2245 }
2246
2247 return;
2248 }
2249
2250 if (e->mask & IN_IGNORED)
2251 return;
2252
2253 log_warning("Unknown inotify event.");
2254 }
2255
2256 static int determine_change(sd_journal *j) {
2257 bool b;
2258
2259 assert(j);
2260
2261 b = j->current_invalidate_counter != j->last_invalidate_counter;
2262 j->last_invalidate_counter = j->current_invalidate_counter;
2263
2264 return b ? SD_JOURNAL_INVALIDATE : SD_JOURNAL_APPEND;
2265 }
2266
2267 _public_ int sd_journal_process(sd_journal *j) {
2268 uint8_t buffer[sizeof(struct inotify_event) + FILENAME_MAX] _alignas_(struct inotify_event);
2269 bool got_something = false;
2270
2271 assert_return(j, -EINVAL);
2272 assert_return(!journal_pid_changed(j), -ECHILD);
2273
2274 j->last_process_usec = now(CLOCK_MONOTONIC);
2275
2276 for (;;) {
2277 struct inotify_event *e;
2278 ssize_t l;
2279
2280 l = read(j->inotify_fd, buffer, sizeof(buffer));
2281 if (l < 0) {
2282 if (errno == EAGAIN || errno == EINTR)
2283 return got_something ? determine_change(j) : SD_JOURNAL_NOP;
2284
2285 return -errno;
2286 }
2287
2288 got_something = true;
2289
2290 e = (struct inotify_event*) buffer;
2291 while (l > 0) {
2292 size_t step;
2293
2294 process_inotify_event(j, e);
2295
2296 step = sizeof(struct inotify_event) + e->len;
2297 assert(step <= (size_t) l);
2298
2299 e = (struct inotify_event*) ((uint8_t*) e + step);
2300 l -= step;
2301 }
2302 }
2303 }
2304
2305 _public_ int sd_journal_wait(sd_journal *j, uint64_t timeout_usec) {
2306 int r;
2307 uint64_t t;
2308
2309 assert_return(j, -EINVAL);
2310 assert_return(!journal_pid_changed(j), -ECHILD);
2311
2312 if (j->inotify_fd < 0) {
2313
2314 /* This is the first invocation, hence create the
2315 * inotify watch */
2316 r = sd_journal_get_fd(j);
2317 if (r < 0)
2318 return r;
2319
2320 /* The journal might have changed since the context
2321 * object was created and we weren't watching before,
2322 * hence don't wait for anything, and return
2323 * immediately. */
2324 return determine_change(j);
2325 }
2326
2327 r = sd_journal_get_timeout(j, &t);
2328 if (r < 0)
2329 return r;
2330
2331 if (t != (uint64_t) -1) {
2332 usec_t n;
2333
2334 n = now(CLOCK_MONOTONIC);
2335 t = t > n ? t - n : 0;
2336
2337 if (timeout_usec == (uint64_t) -1 || timeout_usec > t)
2338 timeout_usec = t;
2339 }
2340
2341 do {
2342 r = fd_wait_for_event(j->inotify_fd, POLLIN, timeout_usec);
2343 } while (r == -EINTR);
2344
2345 if (r < 0)
2346 return r;
2347
2348 return sd_journal_process(j);
2349 }
2350
2351 _public_ int sd_journal_get_cutoff_realtime_usec(sd_journal *j, uint64_t *from, uint64_t *to) {
2352 Iterator i;
2353 JournalFile *f;
2354 bool first = true;
2355 uint64_t fmin = 0, tmax = 0;
2356 int r;
2357
2358 assert_return(j, -EINVAL);
2359 assert_return(!journal_pid_changed(j), -ECHILD);
2360 assert_return(from || to, -EINVAL);
2361 assert_return(from != to, -EINVAL);
2362
2363 HASHMAP_FOREACH(f, j->files, i) {
2364 usec_t fr, t;
2365
2366 r = journal_file_get_cutoff_realtime_usec(f, &fr, &t);
2367 if (r == -ENOENT)
2368 continue;
2369 if (r < 0)
2370 return r;
2371 if (r == 0)
2372 continue;
2373
2374 if (first) {
2375 fmin = fr;
2376 tmax = t;
2377 first = false;
2378 } else {
2379 fmin = MIN(fr, fmin);
2380 tmax = MAX(t, tmax);
2381 }
2382 }
2383
2384 if (from)
2385 *from = fmin;
2386 if (to)
2387 *to = tmax;
2388
2389 return first ? 0 : 1;
2390 }
2391
2392 _public_ int sd_journal_get_cutoff_monotonic_usec(sd_journal *j, sd_id128_t boot_id, uint64_t *from, uint64_t *to) {
2393 Iterator i;
2394 JournalFile *f;
2395 bool first = true;
2396 int r;
2397
2398 assert_return(j, -EINVAL);
2399 assert_return(!journal_pid_changed(j), -ECHILD);
2400 assert_return(from || to, -EINVAL);
2401 assert_return(from != to, -EINVAL);
2402
2403 HASHMAP_FOREACH(f, j->files, i) {
2404 usec_t fr, t;
2405
2406 r = journal_file_get_cutoff_monotonic_usec(f, boot_id, &fr, &t);
2407 if (r == -ENOENT)
2408 continue;
2409 if (r < 0)
2410 return r;
2411 if (r == 0)
2412 continue;
2413
2414 if (first) {
2415 if (from)
2416 *from = fr;
2417 if (to)
2418 *to = t;
2419 first = false;
2420 } else {
2421 if (from)
2422 *from = MIN(fr, *from);
2423 if (to)
2424 *to = MAX(t, *to);
2425 }
2426 }
2427
2428 return first ? 0 : 1;
2429 }
2430
2431 void journal_print_header(sd_journal *j) {
2432 Iterator i;
2433 JournalFile *f;
2434 bool newline = false;
2435
2436 assert(j);
2437
2438 HASHMAP_FOREACH(f, j->files, i) {
2439 if (newline)
2440 putchar('\n');
2441 else
2442 newline = true;
2443
2444 journal_file_print_header(f);
2445 }
2446 }
2447
2448 _public_ int sd_journal_get_usage(sd_journal *j, uint64_t *bytes) {
2449 Iterator i;
2450 JournalFile *f;
2451 uint64_t sum = 0;
2452
2453 assert_return(j, -EINVAL);
2454 assert_return(!journal_pid_changed(j), -ECHILD);
2455 assert_return(bytes, -EINVAL);
2456
2457 HASHMAP_FOREACH(f, j->files, i) {
2458 struct stat st;
2459
2460 if (fstat(f->fd, &st) < 0)
2461 return -errno;
2462
2463 sum += (uint64_t) st.st_blocks * 512ULL;
2464 }
2465
2466 *bytes = sum;
2467 return 0;
2468 }
2469
2470 _public_ int sd_journal_query_unique(sd_journal *j, const char *field) {
2471 char *f;
2472
2473 assert_return(j, -EINVAL);
2474 assert_return(!journal_pid_changed(j), -ECHILD);
2475 assert_return(!isempty(field), -EINVAL);
2476 assert_return(field_is_valid(field), -EINVAL);
2477
2478 f = strdup(field);
2479 if (!f)
2480 return -ENOMEM;
2481
2482 free(j->unique_field);
2483 j->unique_field = f;
2484 j->unique_file = NULL;
2485 j->unique_offset = 0;
2486
2487 return 0;
2488 }
2489
2490 _public_ int sd_journal_enumerate_unique(sd_journal *j, const void **data, size_t *l) {
2491 size_t k;
2492
2493 assert_return(j, -EINVAL);
2494 assert_return(!journal_pid_changed(j), -ECHILD);
2495 assert_return(data, -EINVAL);
2496 assert_return(l, -EINVAL);
2497 assert_return(j->unique_field, -EINVAL);
2498
2499 k = strlen(j->unique_field);
2500
2501 if (!j->unique_file) {
2502 j->unique_file = hashmap_first(j->files);
2503 if (!j->unique_file)
2504 return 0;
2505 j->unique_offset = 0;
2506 }
2507
2508 for (;;) {
2509 JournalFile *of;
2510 Iterator i;
2511 Object *o;
2512 const void *odata;
2513 size_t ol;
2514 bool found;
2515 int r;
2516
2517 /* Proceed to next data object in the field's linked list */
2518 if (j->unique_offset == 0) {
2519 r = journal_file_find_field_object(j->unique_file, j->unique_field, k, &o, NULL);
2520 if (r < 0)
2521 return r;
2522
2523 j->unique_offset = r > 0 ? le64toh(o->field.head_data_offset) : 0;
2524 } else {
2525 r = journal_file_move_to_object(j->unique_file, OBJECT_DATA, j->unique_offset, &o);
2526 if (r < 0)
2527 return r;
2528
2529 j->unique_offset = le64toh(o->data.next_field_offset);
2530 }
2531
2532 /* We reached the end of the list? Then start again, with the next file */
2533 if (j->unique_offset == 0) {
2534 JournalFile *n;
2535
2536 n = hashmap_next(j->files, j->unique_file->path);
2537 if (!n)
2538 return 0;
2539
2540 j->unique_file = n;
2541 continue;
2542 }
2543
2544 /* We do not use the type context here, but 0 instead,
2545 * so that we can look at this data object at the same
2546 * time as one on another file */
2547 r = journal_file_move_to_object(j->unique_file, 0, j->unique_offset, &o);
2548 if (r < 0)
2549 return r;
2550
2551 /* Let's do the type check by hand, since we used 0 context above. */
2552 if (o->object.type != OBJECT_DATA) {
2553 log_error("%s:offset " OFSfmt ": object has type %d, expected %d",
2554 j->unique_file->path, j->unique_offset,
2555 o->object.type, OBJECT_DATA);
2556 return -EBADMSG;
2557 }
2558
2559 r = journal_file_object_keep(j->unique_file, o, j->unique_offset);
2560 if (r < 0)
2561 return r;
2562
2563 r = return_data(j, j->unique_file, o, &odata, &ol);
2564 if (r < 0)
2565 return r;
2566
2567 /* OK, now let's see if we already returned this data
2568 * object by checking if it exists in the earlier
2569 * traversed files. */
2570 found = false;
2571 HASHMAP_FOREACH(of, j->files, i) {
2572 Object *oo;
2573 uint64_t op;
2574
2575 if (of == j->unique_file)
2576 break;
2577
2578 /* Skip this file it didn't have any fields
2579 * indexed */
2580 if (JOURNAL_HEADER_CONTAINS(of->header, n_fields) &&
2581 le64toh(of->header->n_fields) <= 0)
2582 continue;
2583
2584 r = journal_file_find_data_object_with_hash(of, odata, ol, le64toh(o->data.hash), &oo, &op);
2585 if (r < 0)
2586 return r;
2587
2588 if (r > 0)
2589 found = true;
2590 }
2591
2592 if (found)
2593 continue;
2594
2595 r = journal_file_object_release(j->unique_file, o, j->unique_offset);
2596 if (r < 0)
2597 return r;
2598
2599 r = return_data(j, j->unique_file, o, data, l);
2600 if (r < 0)
2601 return r;
2602
2603 return 1;
2604 }
2605 }
2606
2607 _public_ void sd_journal_restart_unique(sd_journal *j) {
2608 if (!j)
2609 return;
2610
2611 j->unique_file = NULL;
2612 j->unique_offset = 0;
2613 }
2614
2615 _public_ int sd_journal_reliable_fd(sd_journal *j) {
2616 assert_return(j, -EINVAL);
2617 assert_return(!journal_pid_changed(j), -ECHILD);
2618
2619 return !j->on_network;
2620 }
2621
2622 static char *lookup_field(const char *field, void *userdata) {
2623 sd_journal *j = userdata;
2624 const void *data;
2625 size_t size, d;
2626 int r;
2627
2628 assert(field);
2629 assert(j);
2630
2631 r = sd_journal_get_data(j, field, &data, &size);
2632 if (r < 0 ||
2633 size > REPLACE_VAR_MAX)
2634 return strdup(field);
2635
2636 d = strlen(field) + 1;
2637
2638 return strndup((const char*) data + d, size - d);
2639 }
2640
2641 _public_ int sd_journal_get_catalog(sd_journal *j, char **ret) {
2642 const void *data;
2643 size_t size;
2644 sd_id128_t id;
2645 _cleanup_free_ char *text = NULL, *cid = NULL;
2646 char *t;
2647 int r;
2648
2649 assert_return(j, -EINVAL);
2650 assert_return(!journal_pid_changed(j), -ECHILD);
2651 assert_return(ret, -EINVAL);
2652
2653 r = sd_journal_get_data(j, "MESSAGE_ID", &data, &size);
2654 if (r < 0)
2655 return r;
2656
2657 cid = strndup((const char*) data + 11, size - 11);
2658 if (!cid)
2659 return -ENOMEM;
2660
2661 r = sd_id128_from_string(cid, &id);
2662 if (r < 0)
2663 return r;
2664
2665 r = catalog_get(CATALOG_DATABASE, id, &text);
2666 if (r < 0)
2667 return r;
2668
2669 t = replace_var(text, lookup_field, j);
2670 if (!t)
2671 return -ENOMEM;
2672
2673 *ret = t;
2674 return 0;
2675 }
2676
2677 _public_ int sd_journal_get_catalog_for_message_id(sd_id128_t id, char **ret) {
2678 assert_return(ret, -EINVAL);
2679
2680 return catalog_get(CATALOG_DATABASE, id, ret);
2681 }
2682
2683 _public_ int sd_journal_set_data_threshold(sd_journal *j, size_t sz) {
2684 assert_return(j, -EINVAL);
2685 assert_return(!journal_pid_changed(j), -ECHILD);
2686
2687 j->data_threshold = sz;
2688 return 0;
2689 }
2690
2691 _public_ int sd_journal_get_data_threshold(sd_journal *j, size_t *sz) {
2692 assert_return(j, -EINVAL);
2693 assert_return(!journal_pid_changed(j), -ECHILD);
2694 assert_return(sz, -EINVAL);
2695
2696 *sz = j->data_threshold;
2697 return 0;
2698 }
Unnamed repository; edit this file 'description' to name the repository.