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