]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/journal/journal-file.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #12645 from poettering/journal-mmap-einval
[thirdparty/systemd.git] / src / journal / journal-file.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2
3 #include <errno.h>
4 #include <fcntl.h>
5 #include <linux/fs.h>
6 #include <pthread.h>
7 #include <stddef.h>
8 #include <sys/mman.h>
9 #include <sys/statvfs.h>
10 #include <sys/uio.h>
11 #include <unistd.h>
12
13 #include "sd-event.h"
14
15 #include "alloc-util.h"
16 #include "btrfs-util.h"
17 #include "chattr-util.h"
18 #include "compress.h"
19 #include "fd-util.h"
20 #include "fs-util.h"
21 #include "journal-authenticate.h"
22 #include "journal-def.h"
23 #include "journal-file.h"
24 #include "lookup3.h"
25 #include "memory-util.h"
26 #include "parse-util.h"
27 #include "path-util.h"
28 #include "random-util.h"
29 #include "set.h"
30 #include "sort-util.h"
31 #include "stat-util.h"
32 #include "string-util.h"
33 #include "strv.h"
34 #include "xattr-util.h"
35
36 #define DEFAULT_DATA_HASH_TABLE_SIZE (2047ULL*sizeof(HashItem))
37 #define DEFAULT_FIELD_HASH_TABLE_SIZE (333ULL*sizeof(HashItem))
38
39 #define DEFAULT_COMPRESS_THRESHOLD (512ULL)
40 #define MIN_COMPRESS_THRESHOLD (8ULL)
41
42 /* This is the minimum journal file size */
43 #define JOURNAL_FILE_SIZE_MIN (512ULL*1024ULL) /* 512 KiB */
44
45 /* These are the lower and upper bounds if we deduce the max_use value
46 * from the file system size */
47 #define DEFAULT_MAX_USE_LOWER (1ULL*1024ULL*1024ULL) /* 1 MiB */
48 #define DEFAULT_MAX_USE_UPPER (4ULL*1024ULL*1024ULL*1024ULL) /* 4 GiB */
49
50 /* This is the default minimal use limit, how much we'll use even if keep_free suggests otherwise. */
51 #define DEFAULT_MIN_USE (1ULL*1024ULL*1024ULL) /* 1 MiB */
52
53 /* This is the upper bound if we deduce max_size from max_use */
54 #define DEFAULT_MAX_SIZE_UPPER (128ULL*1024ULL*1024ULL) /* 128 MiB */
55
56 /* This is the upper bound if we deduce the keep_free value from the
57 * file system size */
58 #define DEFAULT_KEEP_FREE_UPPER (4ULL*1024ULL*1024ULL*1024ULL) /* 4 GiB */
59
60 /* This is the keep_free value when we can't determine the system
61 * size */
62 #define DEFAULT_KEEP_FREE (1024ULL*1024ULL) /* 1 MB */
63
64 /* This is the default maximum number of journal files to keep around. */
65 #define DEFAULT_N_MAX_FILES (100)
66
67 /* n_data was the first entry we added after the initial file format design */
68 #define HEADER_SIZE_MIN ALIGN64(offsetof(Header, n_data))
69
70 /* How many entries to keep in the entry array chain cache at max */
71 #define CHAIN_CACHE_MAX 20
72
73 /* How much to increase the journal file size at once each time we allocate something new. */
74 #define FILE_SIZE_INCREASE (8ULL*1024ULL*1024ULL) /* 8MB */
75
76 /* Reread fstat() of the file for detecting deletions at least this often */
77 #define LAST_STAT_REFRESH_USEC (5*USEC_PER_SEC)
78
79 /* The mmap context to use for the header we pick as one above the last defined typed */
80 #define CONTEXT_HEADER _OBJECT_TYPE_MAX
81
82 #ifdef __clang__
83 # pragma GCC diagnostic ignored "-Waddress-of-packed-member"
84 #endif
85
86 /* This may be called from a separate thread to prevent blocking the caller for the duration of fsync().
87 * As a result we use atomic operations on f->offline_state for inter-thread communications with
88 * journal_file_set_offline() and journal_file_set_online(). */
89 static void journal_file_set_offline_internal(JournalFile *f) {
90 assert(f);
91 assert(f->fd >= 0);
92 assert(f->header);
93
94 for (;;) {
95 switch (f->offline_state) {
96 case OFFLINE_CANCEL:
97 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_CANCEL, OFFLINE_DONE))
98 continue;
99 return;
100
101 case OFFLINE_AGAIN_FROM_SYNCING:
102 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_AGAIN_FROM_SYNCING, OFFLINE_SYNCING))
103 continue;
104 break;
105
106 case OFFLINE_AGAIN_FROM_OFFLINING:
107 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_AGAIN_FROM_OFFLINING, OFFLINE_SYNCING))
108 continue;
109 break;
110
111 case OFFLINE_SYNCING:
112 (void) fsync(f->fd);
113
114 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_SYNCING, OFFLINE_OFFLINING))
115 continue;
116
117 f->header->state = f->archive ? STATE_ARCHIVED : STATE_OFFLINE;
118 (void) fsync(f->fd);
119 break;
120
121 case OFFLINE_OFFLINING:
122 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_OFFLINING, OFFLINE_DONE))
123 continue;
124 _fallthrough_;
125 case OFFLINE_DONE:
126 return;
127
128 case OFFLINE_JOINED:
129 log_debug("OFFLINE_JOINED unexpected offline state for journal_file_set_offline_internal()");
130 return;
131 }
132 }
133 }
134
135 static void * journal_file_set_offline_thread(void *arg) {
136 JournalFile *f = arg;
137
138 (void) pthread_setname_np(pthread_self(), "journal-offline");
139
140 journal_file_set_offline_internal(f);
141
142 return NULL;
143 }
144
145 static int journal_file_set_offline_thread_join(JournalFile *f) {
146 int r;
147
148 assert(f);
149
150 if (f->offline_state == OFFLINE_JOINED)
151 return 0;
152
153 r = pthread_join(f->offline_thread, NULL);
154 if (r)
155 return -r;
156
157 f->offline_state = OFFLINE_JOINED;
158
159 if (mmap_cache_got_sigbus(f->mmap, f->cache_fd))
160 return -EIO;
161
162 return 0;
163 }
164
165 /* Trigger a restart if the offline thread is mid-flight in a restartable state. */
166 static bool journal_file_set_offline_try_restart(JournalFile *f) {
167 for (;;) {
168 switch (f->offline_state) {
169 case OFFLINE_AGAIN_FROM_SYNCING:
170 case OFFLINE_AGAIN_FROM_OFFLINING:
171 return true;
172
173 case OFFLINE_CANCEL:
174 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_CANCEL, OFFLINE_AGAIN_FROM_SYNCING))
175 continue;
176 return true;
177
178 case OFFLINE_SYNCING:
179 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_SYNCING, OFFLINE_AGAIN_FROM_SYNCING))
180 continue;
181 return true;
182
183 case OFFLINE_OFFLINING:
184 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_OFFLINING, OFFLINE_AGAIN_FROM_OFFLINING))
185 continue;
186 return true;
187
188 default:
189 return false;
190 }
191 }
192 }
193
194 /* Sets a journal offline.
195 *
196 * If wait is false then an offline is dispatched in a separate thread for a
197 * subsequent journal_file_set_offline() or journal_file_set_online() of the
198 * same journal to synchronize with.
199 *
200 * If wait is true, then either an existing offline thread will be restarted
201 * and joined, or if none exists the offline is simply performed in this
202 * context without involving another thread.
203 */
204 int journal_file_set_offline(JournalFile *f, bool wait) {
205 bool restarted;
206 int r;
207
208 assert(f);
209
210 if (!f->writable)
211 return -EPERM;
212
213 if (f->fd < 0 || !f->header)
214 return -EINVAL;
215
216 /* An offlining journal is implicitly online and may modify f->header->state,
217 * we must also join any potentially lingering offline thread when not online. */
218 if (!journal_file_is_offlining(f) && f->header->state != STATE_ONLINE)
219 return journal_file_set_offline_thread_join(f);
220
221 /* Restart an in-flight offline thread and wait if needed, or join a lingering done one. */
222 restarted = journal_file_set_offline_try_restart(f);
223 if ((restarted && wait) || !restarted) {
224 r = journal_file_set_offline_thread_join(f);
225 if (r < 0)
226 return r;
227 }
228
229 if (restarted)
230 return 0;
231
232 /* Initiate a new offline. */
233 f->offline_state = OFFLINE_SYNCING;
234
235 if (wait) /* Without using a thread if waiting. */
236 journal_file_set_offline_internal(f);
237 else {
238 sigset_t ss, saved_ss;
239 int k;
240
241 assert_se(sigfillset(&ss) >= 0);
242 /* Don't block SIGBUS since the offlining thread accesses a memory mapped file.
243 * Asynchronous SIGBUS signals can safely be handled by either thread. */
244 assert_se(sigdelset(&ss, SIGBUS) >= 0);
245
246 r = pthread_sigmask(SIG_BLOCK, &ss, &saved_ss);
247 if (r > 0)
248 return -r;
249
250 r = pthread_create(&f->offline_thread, NULL, journal_file_set_offline_thread, f);
251
252 k = pthread_sigmask(SIG_SETMASK, &saved_ss, NULL);
253 if (r > 0) {
254 f->offline_state = OFFLINE_JOINED;
255 return -r;
256 }
257 if (k > 0)
258 return -k;
259 }
260
261 return 0;
262 }
263
264 static int journal_file_set_online(JournalFile *f) {
265 bool wait = true;
266
267 assert(f);
268
269 if (!f->writable)
270 return -EPERM;
271
272 if (f->fd < 0 || !f->header)
273 return -EINVAL;
274
275 while (wait) {
276 switch (f->offline_state) {
277 case OFFLINE_JOINED:
278 /* No offline thread, no need to wait. */
279 wait = false;
280 break;
281
282 case OFFLINE_SYNCING:
283 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_SYNCING, OFFLINE_CANCEL))
284 continue;
285 /* Canceled syncing prior to offlining, no need to wait. */
286 wait = false;
287 break;
288
289 case OFFLINE_AGAIN_FROM_SYNCING:
290 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_AGAIN_FROM_SYNCING, OFFLINE_CANCEL))
291 continue;
292 /* Canceled restart from syncing, no need to wait. */
293 wait = false;
294 break;
295
296 case OFFLINE_AGAIN_FROM_OFFLINING:
297 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_AGAIN_FROM_OFFLINING, OFFLINE_CANCEL))
298 continue;
299 /* Canceled restart from offlining, must wait for offlining to complete however. */
300 _fallthrough_;
301 default: {
302 int r;
303
304 r = journal_file_set_offline_thread_join(f);
305 if (r < 0)
306 return r;
307
308 wait = false;
309 break;
310 }
311 }
312 }
313
314 if (mmap_cache_got_sigbus(f->mmap, f->cache_fd))
315 return -EIO;
316
317 switch (f->header->state) {
318 case STATE_ONLINE:
319 return 0;
320
321 case STATE_OFFLINE:
322 f->header->state = STATE_ONLINE;
323 (void) fsync(f->fd);
324 return 0;
325
326 default:
327 return -EINVAL;
328 }
329 }
330
331 bool journal_file_is_offlining(JournalFile *f) {
332 assert(f);
333
334 __sync_synchronize();
335
336 if (IN_SET(f->offline_state, OFFLINE_DONE, OFFLINE_JOINED))
337 return false;
338
339 return true;
340 }
341
342 JournalFile* journal_file_close(JournalFile *f) {
343 assert(f);
344
345 #if HAVE_GCRYPT
346 /* Write the final tag */
347 if (f->seal && f->writable) {
348 int r;
349
350 r = journal_file_append_tag(f);
351 if (r < 0)
352 log_error_errno(r, "Failed to append tag when closing journal: %m");
353 }
354 #endif
355
356 if (f->post_change_timer) {
357 if (sd_event_source_get_enabled(f->post_change_timer, NULL) > 0)
358 journal_file_post_change(f);
359
360 sd_event_source_disable_unref(f->post_change_timer);
361 }
362
363 journal_file_set_offline(f, true);
364
365 if (f->mmap && f->cache_fd)
366 mmap_cache_free_fd(f->mmap, f->cache_fd);
367
368 if (f->fd >= 0 && f->defrag_on_close) {
369
370 /* Be friendly to btrfs: turn COW back on again now,
371 * and defragment the file. We won't write to the file
372 * ever again, hence remove all fragmentation, and
373 * reenable all the good bits COW usually provides
374 * (such as data checksumming). */
375
376 (void) chattr_fd(f->fd, 0, FS_NOCOW_FL, NULL);
377 (void) btrfs_defrag_fd(f->fd);
378 }
379
380 if (f->close_fd)
381 safe_close(f->fd);
382 free(f->path);
383
384 mmap_cache_unref(f->mmap);
385
386 ordered_hashmap_free_free(f->chain_cache);
387
388 #if HAVE_XZ || HAVE_LZ4
389 free(f->compress_buffer);
390 #endif
391
392 #if HAVE_GCRYPT
393 if (f->fss_file)
394 munmap(f->fss_file, PAGE_ALIGN(f->fss_file_size));
395 else
396 free(f->fsprg_state);
397
398 free(f->fsprg_seed);
399
400 if (f->hmac)
401 gcry_md_close(f->hmac);
402 #endif
403
404 return mfree(f);
405 }
406
407 static int journal_file_init_header(JournalFile *f, JournalFile *template) {
408 Header h = {};
409 ssize_t k;
410 int r;
411
412 assert(f);
413
414 memcpy(h.signature, HEADER_SIGNATURE, 8);
415 h.header_size = htole64(ALIGN64(sizeof(h)));
416
417 h.incompatible_flags |= htole32(
418 f->compress_xz * HEADER_INCOMPATIBLE_COMPRESSED_XZ |
419 f->compress_lz4 * HEADER_INCOMPATIBLE_COMPRESSED_LZ4);
420
421 h.compatible_flags = htole32(
422 f->seal * HEADER_COMPATIBLE_SEALED);
423
424 r = sd_id128_randomize(&h.file_id);
425 if (r < 0)
426 return r;
427
428 if (template) {
429 h.seqnum_id = template->header->seqnum_id;
430 h.tail_entry_seqnum = template->header->tail_entry_seqnum;
431 } else
432 h.seqnum_id = h.file_id;
433
434 k = pwrite(f->fd, &h, sizeof(h), 0);
435 if (k < 0)
436 return -errno;
437
438 if (k != sizeof(h))
439 return -EIO;
440
441 return 0;
442 }
443
444 static int journal_file_refresh_header(JournalFile *f) {
445 sd_id128_t boot_id;
446 int r;
447
448 assert(f);
449 assert(f->header);
450
451 r = sd_id128_get_machine(&f->header->machine_id);
452 if (IN_SET(r, -ENOENT, -ENOMEDIUM))
453 /* We don't have a machine-id, let's continue without */
454 zero(f->header->machine_id);
455 else if (r < 0)
456 return r;
457
458 r = sd_id128_get_boot(&boot_id);
459 if (r < 0)
460 return r;
461
462 f->header->boot_id = boot_id;
463
464 r = journal_file_set_online(f);
465
466 /* Sync the online state to disk */
467 (void) fsync(f->fd);
468
469 /* We likely just created a new file, also sync the directory this file is located in. */
470 (void) fsync_directory_of_file(f->fd);
471
472 return r;
473 }
474
475 static bool warn_wrong_flags(const JournalFile *f, bool compatible) {
476 const uint32_t any = compatible ? HEADER_COMPATIBLE_ANY : HEADER_INCOMPATIBLE_ANY,
477 supported = compatible ? HEADER_COMPATIBLE_SUPPORTED : HEADER_INCOMPATIBLE_SUPPORTED;
478 const char *type = compatible ? "compatible" : "incompatible";
479 uint32_t flags;
480
481 flags = le32toh(compatible ? f->header->compatible_flags : f->header->incompatible_flags);
482
483 if (flags & ~supported) {
484 if (flags & ~any)
485 log_debug("Journal file %s has unknown %s flags 0x%"PRIx32,
486 f->path, type, flags & ~any);
487 flags = (flags & any) & ~supported;
488 if (flags) {
489 const char* strv[3];
490 unsigned n = 0;
491 _cleanup_free_ char *t = NULL;
492
493 if (compatible && (flags & HEADER_COMPATIBLE_SEALED))
494 strv[n++] = "sealed";
495 if (!compatible && (flags & HEADER_INCOMPATIBLE_COMPRESSED_XZ))
496 strv[n++] = "xz-compressed";
497 if (!compatible && (flags & HEADER_INCOMPATIBLE_COMPRESSED_LZ4))
498 strv[n++] = "lz4-compressed";
499 strv[n] = NULL;
500 assert(n < ELEMENTSOF(strv));
501
502 t = strv_join((char**) strv, ", ");
503 log_debug("Journal file %s uses %s %s %s disabled at compilation time.",
504 f->path, type, n > 1 ? "flags" : "flag", strnull(t));
505 }
506 return true;
507 }
508
509 return false;
510 }
511
512 static int journal_file_verify_header(JournalFile *f) {
513 uint64_t arena_size, header_size;
514
515 assert(f);
516 assert(f->header);
517
518 if (memcmp(f->header->signature, HEADER_SIGNATURE, 8))
519 return -EBADMSG;
520
521 /* In both read and write mode we refuse to open files with incompatible
522 * flags we don't know. */
523 if (warn_wrong_flags(f, false))
524 return -EPROTONOSUPPORT;
525
526 /* When open for writing we refuse to open files with compatible flags, too. */
527 if (f->writable && warn_wrong_flags(f, true))
528 return -EPROTONOSUPPORT;
529
530 if (f->header->state >= _STATE_MAX)
531 return -EBADMSG;
532
533 header_size = le64toh(f->header->header_size);
534
535 /* The first addition was n_data, so check that we are at least this large */
536 if (header_size < HEADER_SIZE_MIN)
537 return -EBADMSG;
538
539 if (JOURNAL_HEADER_SEALED(f->header) && !JOURNAL_HEADER_CONTAINS(f->header, n_entry_arrays))
540 return -EBADMSG;
541
542 arena_size = le64toh(f->header->arena_size);
543
544 if (UINT64_MAX - header_size < arena_size || header_size + arena_size > (uint64_t) f->last_stat.st_size)
545 return -ENODATA;
546
547 if (le64toh(f->header->tail_object_offset) > header_size + arena_size)
548 return -ENODATA;
549
550 if (!VALID64(le64toh(f->header->data_hash_table_offset)) ||
551 !VALID64(le64toh(f->header->field_hash_table_offset)) ||
552 !VALID64(le64toh(f->header->tail_object_offset)) ||
553 !VALID64(le64toh(f->header->entry_array_offset)))
554 return -ENODATA;
555
556 if (f->writable) {
557 sd_id128_t machine_id;
558 uint8_t state;
559 int r;
560
561 r = sd_id128_get_machine(&machine_id);
562 if (r < 0)
563 return r;
564
565 if (!sd_id128_equal(machine_id, f->header->machine_id))
566 return -EHOSTDOWN;
567
568 state = f->header->state;
569
570 if (state == STATE_ARCHIVED)
571 return -ESHUTDOWN; /* Already archived */
572 else if (state == STATE_ONLINE)
573 return log_debug_errno(SYNTHETIC_ERRNO(EBUSY),
574 "Journal file %s is already online. Assuming unclean closing.",
575 f->path);
576 else if (state != STATE_OFFLINE)
577 return log_debug_errno(SYNTHETIC_ERRNO(EBUSY),
578 "Journal file %s has unknown state %i.",
579 f->path, state);
580
581 if (f->header->field_hash_table_size == 0 || f->header->data_hash_table_size == 0)
582 return -EBADMSG;
583
584 /* Don't permit appending to files from the future. Because otherwise the realtime timestamps wouldn't
585 * be strictly ordered in the entries in the file anymore, and we can't have that since it breaks
586 * bisection. */
587 if (le64toh(f->header->tail_entry_realtime) > now(CLOCK_REALTIME))
588 return log_debug_errno(SYNTHETIC_ERRNO(ETXTBSY),
589 "Journal file %s is from the future, refusing to append new data to it that'd be older.",
590 f->path);
591 }
592
593 f->compress_xz = JOURNAL_HEADER_COMPRESSED_XZ(f->header);
594 f->compress_lz4 = JOURNAL_HEADER_COMPRESSED_LZ4(f->header);
595
596 f->seal = JOURNAL_HEADER_SEALED(f->header);
597
598 return 0;
599 }
600
601 static int journal_file_fstat(JournalFile *f) {
602 int r;
603
604 assert(f);
605 assert(f->fd >= 0);
606
607 if (fstat(f->fd, &f->last_stat) < 0)
608 return -errno;
609
610 f->last_stat_usec = now(CLOCK_MONOTONIC);
611
612 /* Refuse dealing with with files that aren't regular */
613 r = stat_verify_regular(&f->last_stat);
614 if (r < 0)
615 return r;
616
617 /* Refuse appending to files that are already deleted */
618 if (f->last_stat.st_nlink <= 0)
619 return -EIDRM;
620
621 return 0;
622 }
623
624 static int journal_file_allocate(JournalFile *f, uint64_t offset, uint64_t size) {
625 uint64_t old_size, new_size;
626 int r;
627
628 assert(f);
629 assert(f->header);
630
631 /* We assume that this file is not sparse, and we know that
632 * for sure, since we always call posix_fallocate()
633 * ourselves */
634
635 if (mmap_cache_got_sigbus(f->mmap, f->cache_fd))
636 return -EIO;
637
638 old_size =
639 le64toh(f->header->header_size) +
640 le64toh(f->header->arena_size);
641
642 new_size = PAGE_ALIGN(offset + size);
643 if (new_size < le64toh(f->header->header_size))
644 new_size = le64toh(f->header->header_size);
645
646 if (new_size <= old_size) {
647
648 /* We already pre-allocated enough space, but before
649 * we write to it, let's check with fstat() if the
650 * file got deleted, in order make sure we don't throw
651 * away the data immediately. Don't check fstat() for
652 * all writes though, but only once ever 10s. */
653
654 if (f->last_stat_usec + LAST_STAT_REFRESH_USEC > now(CLOCK_MONOTONIC))
655 return 0;
656
657 return journal_file_fstat(f);
658 }
659
660 /* Allocate more space. */
661
662 if (f->metrics.max_size > 0 && new_size > f->metrics.max_size)
663 return -E2BIG;
664
665 if (new_size > f->metrics.min_size && f->metrics.keep_free > 0) {
666 struct statvfs svfs;
667
668 if (fstatvfs(f->fd, &svfs) >= 0) {
669 uint64_t available;
670
671 available = LESS_BY((uint64_t) svfs.f_bfree * (uint64_t) svfs.f_bsize, f->metrics.keep_free);
672
673 if (new_size - old_size > available)
674 return -E2BIG;
675 }
676 }
677
678 /* Increase by larger blocks at once */
679 new_size = DIV_ROUND_UP(new_size, FILE_SIZE_INCREASE) * FILE_SIZE_INCREASE;
680 if (f->metrics.max_size > 0 && new_size > f->metrics.max_size)
681 new_size = f->metrics.max_size;
682
683 /* Note that the glibc fallocate() fallback is very
684 inefficient, hence we try to minimize the allocation area
685 as we can. */
686 r = posix_fallocate(f->fd, old_size, new_size - old_size);
687 if (r != 0)
688 return -r;
689
690 f->header->arena_size = htole64(new_size - le64toh(f->header->header_size));
691
692 return journal_file_fstat(f);
693 }
694
695 static unsigned type_to_context(ObjectType type) {
696 /* One context for each type, plus one catch-all for the rest */
697 assert_cc(_OBJECT_TYPE_MAX <= MMAP_CACHE_MAX_CONTEXTS);
698 assert_cc(CONTEXT_HEADER < MMAP_CACHE_MAX_CONTEXTS);
699 return type > OBJECT_UNUSED && type < _OBJECT_TYPE_MAX ? type : 0;
700 }
701
702 static int journal_file_move_to(JournalFile *f, ObjectType type, bool keep_always, uint64_t offset, uint64_t size, void **ret, size_t *ret_size) {
703 int r;
704
705 assert(f);
706 assert(ret);
707
708 if (size <= 0)
709 return -EINVAL;
710
711 /* Avoid SIGBUS on invalid accesses */
712 if (offset + size > (uint64_t) f->last_stat.st_size) {
713 /* Hmm, out of range? Let's refresh the fstat() data
714 * first, before we trust that check. */
715
716 r = journal_file_fstat(f);
717 if (r < 0)
718 return r;
719
720 if (offset + size > (uint64_t) f->last_stat.st_size)
721 return -EADDRNOTAVAIL;
722 }
723
724 return mmap_cache_get(f->mmap, f->cache_fd, f->prot, type_to_context(type), keep_always, offset, size, &f->last_stat, ret, ret_size);
725 }
726
727 static uint64_t minimum_header_size(Object *o) {
728
729 static const uint64_t table[] = {
730 [OBJECT_DATA] = sizeof(DataObject),
731 [OBJECT_FIELD] = sizeof(FieldObject),
732 [OBJECT_ENTRY] = sizeof(EntryObject),
733 [OBJECT_DATA_HASH_TABLE] = sizeof(HashTableObject),
734 [OBJECT_FIELD_HASH_TABLE] = sizeof(HashTableObject),
735 [OBJECT_ENTRY_ARRAY] = sizeof(EntryArrayObject),
736 [OBJECT_TAG] = sizeof(TagObject),
737 };
738
739 if (o->object.type >= ELEMENTSOF(table) || table[o->object.type] <= 0)
740 return sizeof(ObjectHeader);
741
742 return table[o->object.type];
743 }
744
745 /* Lightweight object checks. We want this to be fast, so that we won't
746 * slowdown every journal_file_move_to_object() call too much. */
747 static int journal_file_check_object(JournalFile *f, uint64_t offset, Object *o) {
748 assert(f);
749 assert(o);
750
751 switch (o->object.type) {
752
753 case OBJECT_DATA: {
754 if ((le64toh(o->data.entry_offset) == 0) ^ (le64toh(o->data.n_entries) == 0))
755 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
756 "Bad n_entries: %" PRIu64 ": %" PRIu64,
757 le64toh(o->data.n_entries),
758 offset);
759
760 if (le64toh(o->object.size) - offsetof(DataObject, payload) <= 0)
761 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
762 "Bad object size (<= %zu): %" PRIu64 ": %" PRIu64,
763 offsetof(DataObject, payload),
764 le64toh(o->object.size),
765 offset);
766
767 if (!VALID64(le64toh(o->data.next_hash_offset)) ||
768 !VALID64(le64toh(o->data.next_field_offset)) ||
769 !VALID64(le64toh(o->data.entry_offset)) ||
770 !VALID64(le64toh(o->data.entry_array_offset)))
771 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
772 "Invalid offset, next_hash_offset=" OFSfmt ", next_field_offset=" OFSfmt ", entry_offset=" OFSfmt ", entry_array_offset=" OFSfmt ": %" PRIu64,
773 le64toh(o->data.next_hash_offset),
774 le64toh(o->data.next_field_offset),
775 le64toh(o->data.entry_offset),
776 le64toh(o->data.entry_array_offset),
777 offset);
778
779 break;
780 }
781
782 case OBJECT_FIELD:
783 if (le64toh(o->object.size) - offsetof(FieldObject, payload) <= 0)
784 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
785 "Bad field size (<= %zu): %" PRIu64 ": %" PRIu64,
786 offsetof(FieldObject, payload),
787 le64toh(o->object.size),
788 offset);
789
790 if (!VALID64(le64toh(o->field.next_hash_offset)) ||
791 !VALID64(le64toh(o->field.head_data_offset)))
792 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
793 "Invalid offset, next_hash_offset=" OFSfmt ", head_data_offset=" OFSfmt ": %" PRIu64,
794 le64toh(o->field.next_hash_offset),
795 le64toh(o->field.head_data_offset),
796 offset);
797 break;
798
799 case OBJECT_ENTRY:
800 if ((le64toh(o->object.size) - offsetof(EntryObject, items)) % sizeof(EntryItem) != 0)
801 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
802 "Bad entry size (<= %zu): %" PRIu64 ": %" PRIu64,
803 offsetof(EntryObject, items),
804 le64toh(o->object.size),
805 offset);
806
807 if ((le64toh(o->object.size) - offsetof(EntryObject, items)) / sizeof(EntryItem) <= 0)
808 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
809 "Invalid number items in entry: %" PRIu64 ": %" PRIu64,
810 (le64toh(o->object.size) - offsetof(EntryObject, items)) / sizeof(EntryItem),
811 offset);
812
813 if (le64toh(o->entry.seqnum) <= 0)
814 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
815 "Invalid entry seqnum: %" PRIx64 ": %" PRIu64,
816 le64toh(o->entry.seqnum),
817 offset);
818
819 if (!VALID_REALTIME(le64toh(o->entry.realtime)))
820 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
821 "Invalid entry realtime timestamp: %" PRIu64 ": %" PRIu64,
822 le64toh(o->entry.realtime),
823 offset);
824
825 if (!VALID_MONOTONIC(le64toh(o->entry.monotonic)))
826 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
827 "Invalid entry monotonic timestamp: %" PRIu64 ": %" PRIu64,
828 le64toh(o->entry.monotonic),
829 offset);
830
831 break;
832
833 case OBJECT_DATA_HASH_TABLE:
834 case OBJECT_FIELD_HASH_TABLE:
835 if ((le64toh(o->object.size) - offsetof(HashTableObject, items)) % sizeof(HashItem) != 0 ||
836 (le64toh(o->object.size) - offsetof(HashTableObject, items)) / sizeof(HashItem) <= 0)
837 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
838 "Invalid %s hash table size: %" PRIu64 ": %" PRIu64,
839 o->object.type == OBJECT_DATA_HASH_TABLE ? "data" : "field",
840 le64toh(o->object.size),
841 offset);
842
843 break;
844
845 case OBJECT_ENTRY_ARRAY:
846 if ((le64toh(o->object.size) - offsetof(EntryArrayObject, items)) % sizeof(le64_t) != 0 ||
847 (le64toh(o->object.size) - offsetof(EntryArrayObject, items)) / sizeof(le64_t) <= 0)
848 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
849 "Invalid object entry array size: %" PRIu64 ": %" PRIu64,
850 le64toh(o->object.size),
851 offset);
852
853 if (!VALID64(le64toh(o->entry_array.next_entry_array_offset)))
854 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
855 "Invalid object entry array next_entry_array_offset: " OFSfmt ": %" PRIu64,
856 le64toh(o->entry_array.next_entry_array_offset),
857 offset);
858
859 break;
860
861 case OBJECT_TAG:
862 if (le64toh(o->object.size) != sizeof(TagObject))
863 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
864 "Invalid object tag size: %" PRIu64 ": %" PRIu64,
865 le64toh(o->object.size),
866 offset);
867
868 if (!VALID_EPOCH(le64toh(o->tag.epoch)))
869 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
870 "Invalid object tag epoch: %" PRIu64 ": %" PRIu64,
871 le64toh(o->tag.epoch), offset);
872
873 break;
874 }
875
876 return 0;
877 }
878
879 int journal_file_move_to_object(JournalFile *f, ObjectType type, uint64_t offset, Object **ret) {
880 int r;
881 void *t;
882 size_t tsize;
883 Object *o;
884 uint64_t s;
885
886 assert(f);
887 assert(ret);
888
889 /* Objects may only be located at multiple of 64 bit */
890 if (!VALID64(offset))
891 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
892 "Attempt to move to object at non-64bit boundary: %" PRIu64,
893 offset);
894
895 /* Object may not be located in the file header */
896 if (offset < le64toh(f->header->header_size))
897 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
898 "Attempt to move to object located in file header: %" PRIu64,
899 offset);
900
901 r = journal_file_move_to(f, type, false, offset, sizeof(ObjectHeader), &t, &tsize);
902 if (r < 0)
903 return r;
904
905 o = (Object*) t;
906 s = le64toh(o->object.size);
907
908 if (s == 0)
909 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
910 "Attempt to move to uninitialized object: %" PRIu64,
911 offset);
912 if (s < sizeof(ObjectHeader))
913 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
914 "Attempt to move to overly short object: %" PRIu64,
915 offset);
916
917 if (o->object.type <= OBJECT_UNUSED)
918 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
919 "Attempt to move to object with invalid type: %" PRIu64,
920 offset);
921
922 if (s < minimum_header_size(o))
923 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
924 "Attempt to move to truncated object: %" PRIu64,
925 offset);
926
927 if (type > OBJECT_UNUSED && o->object.type != type)
928 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
929 "Attempt to move to object of unexpected type: %" PRIu64,
930 offset);
931
932 if (s > tsize) {
933 r = journal_file_move_to(f, type, false, offset, s, &t, NULL);
934 if (r < 0)
935 return r;
936
937 o = (Object*) t;
938 }
939
940 r = journal_file_check_object(f, offset, o);
941 if (r < 0)
942 return r;
943
944 *ret = o;
945 return 0;
946 }
947
948 static uint64_t journal_file_entry_seqnum(JournalFile *f, uint64_t *seqnum) {
949 uint64_t r;
950
951 assert(f);
952 assert(f->header);
953
954 r = le64toh(f->header->tail_entry_seqnum) + 1;
955
956 if (seqnum) {
957 /* If an external seqnum counter was passed, we update
958 * both the local and the external one, and set it to
959 * the maximum of both */
960
961 if (*seqnum + 1 > r)
962 r = *seqnum + 1;
963
964 *seqnum = r;
965 }
966
967 f->header->tail_entry_seqnum = htole64(r);
968
969 if (f->header->head_entry_seqnum == 0)
970 f->header->head_entry_seqnum = htole64(r);
971
972 return r;
973 }
974
975 int journal_file_append_object(JournalFile *f, ObjectType type, uint64_t size, Object **ret, uint64_t *offset) {
976 int r;
977 uint64_t p;
978 Object *tail, *o;
979 void *t;
980
981 assert(f);
982 assert(f->header);
983 assert(type > OBJECT_UNUSED && type < _OBJECT_TYPE_MAX);
984 assert(size >= sizeof(ObjectHeader));
985 assert(offset);
986 assert(ret);
987
988 r = journal_file_set_online(f);
989 if (r < 0)
990 return r;
991
992 p = le64toh(f->header->tail_object_offset);
993 if (p == 0)
994 p = le64toh(f->header->header_size);
995 else {
996 r = journal_file_move_to_object(f, OBJECT_UNUSED, p, &tail);
997 if (r < 0)
998 return r;
999
1000 p += ALIGN64(le64toh(tail->object.size));
1001 }
1002
1003 r = journal_file_allocate(f, p, size);
1004 if (r < 0)
1005 return r;
1006
1007 r = journal_file_move_to(f, type, false, p, size, &t, NULL);
1008 if (r < 0)
1009 return r;
1010
1011 o = (Object*) t;
1012
1013 zero(o->object);
1014 o->object.type = type;
1015 o->object.size = htole64(size);
1016
1017 f->header->tail_object_offset = htole64(p);
1018 f->header->n_objects = htole64(le64toh(f->header->n_objects) + 1);
1019
1020 *ret = o;
1021 *offset = p;
1022
1023 return 0;
1024 }
1025
1026 static int journal_file_setup_data_hash_table(JournalFile *f) {
1027 uint64_t s, p;
1028 Object *o;
1029 int r;
1030
1031 assert(f);
1032 assert(f->header);
1033
1034 /* We estimate that we need 1 hash table entry per 768 bytes
1035 of journal file and we want to make sure we never get
1036 beyond 75% fill level. Calculate the hash table size for
1037 the maximum file size based on these metrics. */
1038
1039 s = (f->metrics.max_size * 4 / 768 / 3) * sizeof(HashItem);
1040 if (s < DEFAULT_DATA_HASH_TABLE_SIZE)
1041 s = DEFAULT_DATA_HASH_TABLE_SIZE;
1042
1043 log_debug("Reserving %"PRIu64" entries in hash table.", s / sizeof(HashItem));
1044
1045 r = journal_file_append_object(f,
1046 OBJECT_DATA_HASH_TABLE,
1047 offsetof(Object, hash_table.items) + s,
1048 &o, &p);
1049 if (r < 0)
1050 return r;
1051
1052 memzero(o->hash_table.items, s);
1053
1054 f->header->data_hash_table_offset = htole64(p + offsetof(Object, hash_table.items));
1055 f->header->data_hash_table_size = htole64(s);
1056
1057 return 0;
1058 }
1059
1060 static int journal_file_setup_field_hash_table(JournalFile *f) {
1061 uint64_t s, p;
1062 Object *o;
1063 int r;
1064
1065 assert(f);
1066 assert(f->header);
1067
1068 /* We use a fixed size hash table for the fields as this
1069 * number should grow very slowly only */
1070
1071 s = DEFAULT_FIELD_HASH_TABLE_SIZE;
1072 r = journal_file_append_object(f,
1073 OBJECT_FIELD_HASH_TABLE,
1074 offsetof(Object, hash_table.items) + s,
1075 &o, &p);
1076 if (r < 0)
1077 return r;
1078
1079 memzero(o->hash_table.items, s);
1080
1081 f->header->field_hash_table_offset = htole64(p + offsetof(Object, hash_table.items));
1082 f->header->field_hash_table_size = htole64(s);
1083
1084 return 0;
1085 }
1086
1087 int journal_file_map_data_hash_table(JournalFile *f) {
1088 uint64_t s, p;
1089 void *t;
1090 int r;
1091
1092 assert(f);
1093 assert(f->header);
1094
1095 if (f->data_hash_table)
1096 return 0;
1097
1098 p = le64toh(f->header->data_hash_table_offset);
1099 s = le64toh(f->header->data_hash_table_size);
1100
1101 r = journal_file_move_to(f,
1102 OBJECT_DATA_HASH_TABLE,
1103 true,
1104 p, s,
1105 &t, NULL);
1106 if (r < 0)
1107 return r;
1108
1109 f->data_hash_table = t;
1110 return 0;
1111 }
1112
1113 int journal_file_map_field_hash_table(JournalFile *f) {
1114 uint64_t s, p;
1115 void *t;
1116 int r;
1117
1118 assert(f);
1119 assert(f->header);
1120
1121 if (f->field_hash_table)
1122 return 0;
1123
1124 p = le64toh(f->header->field_hash_table_offset);
1125 s = le64toh(f->header->field_hash_table_size);
1126
1127 r = journal_file_move_to(f,
1128 OBJECT_FIELD_HASH_TABLE,
1129 true,
1130 p, s,
1131 &t, NULL);
1132 if (r < 0)
1133 return r;
1134
1135 f->field_hash_table = t;
1136 return 0;
1137 }
1138
1139 static int journal_file_link_field(
1140 JournalFile *f,
1141 Object *o,
1142 uint64_t offset,
1143 uint64_t hash) {
1144
1145 uint64_t p, h, m;
1146 int r;
1147
1148 assert(f);
1149 assert(f->header);
1150 assert(f->field_hash_table);
1151 assert(o);
1152 assert(offset > 0);
1153
1154 if (o->object.type != OBJECT_FIELD)
1155 return -EINVAL;
1156
1157 m = le64toh(f->header->field_hash_table_size) / sizeof(HashItem);
1158 if (m <= 0)
1159 return -EBADMSG;
1160
1161 /* This might alter the window we are looking at */
1162 o->field.next_hash_offset = o->field.head_data_offset = 0;
1163
1164 h = hash % m;
1165 p = le64toh(f->field_hash_table[h].tail_hash_offset);
1166 if (p == 0)
1167 f->field_hash_table[h].head_hash_offset = htole64(offset);
1168 else {
1169 r = journal_file_move_to_object(f, OBJECT_FIELD, p, &o);
1170 if (r < 0)
1171 return r;
1172
1173 o->field.next_hash_offset = htole64(offset);
1174 }
1175
1176 f->field_hash_table[h].tail_hash_offset = htole64(offset);
1177
1178 if (JOURNAL_HEADER_CONTAINS(f->header, n_fields))
1179 f->header->n_fields = htole64(le64toh(f->header->n_fields) + 1);
1180
1181 return 0;
1182 }
1183
1184 static int journal_file_link_data(
1185 JournalFile *f,
1186 Object *o,
1187 uint64_t offset,
1188 uint64_t hash) {
1189
1190 uint64_t p, h, m;
1191 int r;
1192
1193 assert(f);
1194 assert(f->header);
1195 assert(f->data_hash_table);
1196 assert(o);
1197 assert(offset > 0);
1198
1199 if (o->object.type != OBJECT_DATA)
1200 return -EINVAL;
1201
1202 m = le64toh(f->header->data_hash_table_size) / sizeof(HashItem);
1203 if (m <= 0)
1204 return -EBADMSG;
1205
1206 /* This might alter the window we are looking at */
1207 o->data.next_hash_offset = o->data.next_field_offset = 0;
1208 o->data.entry_offset = o->data.entry_array_offset = 0;
1209 o->data.n_entries = 0;
1210
1211 h = hash % m;
1212 p = le64toh(f->data_hash_table[h].tail_hash_offset);
1213 if (p == 0)
1214 /* Only entry in the hash table is easy */
1215 f->data_hash_table[h].head_hash_offset = htole64(offset);
1216 else {
1217 /* Move back to the previous data object, to patch in
1218 * pointer */
1219
1220 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
1221 if (r < 0)
1222 return r;
1223
1224 o->data.next_hash_offset = htole64(offset);
1225 }
1226
1227 f->data_hash_table[h].tail_hash_offset = htole64(offset);
1228
1229 if (JOURNAL_HEADER_CONTAINS(f->header, n_data))
1230 f->header->n_data = htole64(le64toh(f->header->n_data) + 1);
1231
1232 return 0;
1233 }
1234
1235 int journal_file_find_field_object_with_hash(
1236 JournalFile *f,
1237 const void *field, uint64_t size, uint64_t hash,
1238 Object **ret, uint64_t *offset) {
1239
1240 uint64_t p, osize, h, m;
1241 int r;
1242
1243 assert(f);
1244 assert(f->header);
1245 assert(field && size > 0);
1246
1247 /* If the field hash table is empty, we can't find anything */
1248 if (le64toh(f->header->field_hash_table_size) <= 0)
1249 return 0;
1250
1251 /* Map the field hash table, if it isn't mapped yet. */
1252 r = journal_file_map_field_hash_table(f);
1253 if (r < 0)
1254 return r;
1255
1256 osize = offsetof(Object, field.payload) + size;
1257
1258 m = le64toh(f->header->field_hash_table_size) / sizeof(HashItem);
1259 if (m <= 0)
1260 return -EBADMSG;
1261
1262 h = hash % m;
1263 p = le64toh(f->field_hash_table[h].head_hash_offset);
1264
1265 while (p > 0) {
1266 Object *o;
1267
1268 r = journal_file_move_to_object(f, OBJECT_FIELD, p, &o);
1269 if (r < 0)
1270 return r;
1271
1272 if (le64toh(o->field.hash) == hash &&
1273 le64toh(o->object.size) == osize &&
1274 memcmp(o->field.payload, field, size) == 0) {
1275
1276 if (ret)
1277 *ret = o;
1278 if (offset)
1279 *offset = p;
1280
1281 return 1;
1282 }
1283
1284 p = le64toh(o->field.next_hash_offset);
1285 }
1286
1287 return 0;
1288 }
1289
1290 int journal_file_find_field_object(
1291 JournalFile *f,
1292 const void *field, uint64_t size,
1293 Object **ret, uint64_t *offset) {
1294
1295 uint64_t hash;
1296
1297 assert(f);
1298 assert(field && size > 0);
1299
1300 hash = hash64(field, size);
1301
1302 return journal_file_find_field_object_with_hash(f,
1303 field, size, hash,
1304 ret, offset);
1305 }
1306
1307 int journal_file_find_data_object_with_hash(
1308 JournalFile *f,
1309 const void *data, uint64_t size, uint64_t hash,
1310 Object **ret, uint64_t *offset) {
1311
1312 uint64_t p, osize, h, m;
1313 int r;
1314
1315 assert(f);
1316 assert(f->header);
1317 assert(data || size == 0);
1318
1319 /* If there's no data hash table, then there's no entry. */
1320 if (le64toh(f->header->data_hash_table_size) <= 0)
1321 return 0;
1322
1323 /* Map the data hash table, if it isn't mapped yet. */
1324 r = journal_file_map_data_hash_table(f);
1325 if (r < 0)
1326 return r;
1327
1328 osize = offsetof(Object, data.payload) + size;
1329
1330 m = le64toh(f->header->data_hash_table_size) / sizeof(HashItem);
1331 if (m <= 0)
1332 return -EBADMSG;
1333
1334 h = hash % m;
1335 p = le64toh(f->data_hash_table[h].head_hash_offset);
1336
1337 while (p > 0) {
1338 Object *o;
1339
1340 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
1341 if (r < 0)
1342 return r;
1343
1344 if (le64toh(o->data.hash) != hash)
1345 goto next;
1346
1347 if (o->object.flags & OBJECT_COMPRESSION_MASK) {
1348 #if HAVE_XZ || HAVE_LZ4
1349 uint64_t l;
1350 size_t rsize = 0;
1351
1352 l = le64toh(o->object.size);
1353 if (l <= offsetof(Object, data.payload))
1354 return -EBADMSG;
1355
1356 l -= offsetof(Object, data.payload);
1357
1358 r = decompress_blob(o->object.flags & OBJECT_COMPRESSION_MASK,
1359 o->data.payload, l, &f->compress_buffer, &f->compress_buffer_size, &rsize, 0);
1360 if (r < 0)
1361 return r;
1362
1363 if (rsize == size &&
1364 memcmp(f->compress_buffer, data, size) == 0) {
1365
1366 if (ret)
1367 *ret = o;
1368
1369 if (offset)
1370 *offset = p;
1371
1372 return 1;
1373 }
1374 #else
1375 return -EPROTONOSUPPORT;
1376 #endif
1377 } else if (le64toh(o->object.size) == osize &&
1378 memcmp(o->data.payload, data, size) == 0) {
1379
1380 if (ret)
1381 *ret = o;
1382
1383 if (offset)
1384 *offset = p;
1385
1386 return 1;
1387 }
1388
1389 next:
1390 p = le64toh(o->data.next_hash_offset);
1391 }
1392
1393 return 0;
1394 }
1395
1396 int journal_file_find_data_object(
1397 JournalFile *f,
1398 const void *data, uint64_t size,
1399 Object **ret, uint64_t *offset) {
1400
1401 uint64_t hash;
1402
1403 assert(f);
1404 assert(data || size == 0);
1405
1406 hash = hash64(data, size);
1407
1408 return journal_file_find_data_object_with_hash(f,
1409 data, size, hash,
1410 ret, offset);
1411 }
1412
1413 static int journal_file_append_field(
1414 JournalFile *f,
1415 const void *field, uint64_t size,
1416 Object **ret, uint64_t *offset) {
1417
1418 uint64_t hash, p;
1419 uint64_t osize;
1420 Object *o;
1421 int r;
1422
1423 assert(f);
1424 assert(field && size > 0);
1425
1426 hash = hash64(field, size);
1427
1428 r = journal_file_find_field_object_with_hash(f, field, size, hash, &o, &p);
1429 if (r < 0)
1430 return r;
1431 else if (r > 0) {
1432
1433 if (ret)
1434 *ret = o;
1435
1436 if (offset)
1437 *offset = p;
1438
1439 return 0;
1440 }
1441
1442 osize = offsetof(Object, field.payload) + size;
1443 r = journal_file_append_object(f, OBJECT_FIELD, osize, &o, &p);
1444 if (r < 0)
1445 return r;
1446
1447 o->field.hash = htole64(hash);
1448 memcpy(o->field.payload, field, size);
1449
1450 r = journal_file_link_field(f, o, p, hash);
1451 if (r < 0)
1452 return r;
1453
1454 /* The linking might have altered the window, so let's
1455 * refresh our pointer */
1456 r = journal_file_move_to_object(f, OBJECT_FIELD, p, &o);
1457 if (r < 0)
1458 return r;
1459
1460 #if HAVE_GCRYPT
1461 r = journal_file_hmac_put_object(f, OBJECT_FIELD, o, p);
1462 if (r < 0)
1463 return r;
1464 #endif
1465
1466 if (ret)
1467 *ret = o;
1468
1469 if (offset)
1470 *offset = p;
1471
1472 return 0;
1473 }
1474
1475 static int journal_file_append_data(
1476 JournalFile *f,
1477 const void *data, uint64_t size,
1478 Object **ret, uint64_t *offset) {
1479
1480 uint64_t hash, p;
1481 uint64_t osize;
1482 Object *o;
1483 int r, compression = 0;
1484 const void *eq;
1485
1486 assert(f);
1487 assert(data || size == 0);
1488
1489 hash = hash64(data, size);
1490
1491 r = journal_file_find_data_object_with_hash(f, data, size, hash, &o, &p);
1492 if (r < 0)
1493 return r;
1494 if (r > 0) {
1495
1496 if (ret)
1497 *ret = o;
1498
1499 if (offset)
1500 *offset = p;
1501
1502 return 0;
1503 }
1504
1505 osize = offsetof(Object, data.payload) + size;
1506 r = journal_file_append_object(f, OBJECT_DATA, osize, &o, &p);
1507 if (r < 0)
1508 return r;
1509
1510 o->data.hash = htole64(hash);
1511
1512 #if HAVE_XZ || HAVE_LZ4
1513 if (JOURNAL_FILE_COMPRESS(f) && size >= f->compress_threshold_bytes) {
1514 size_t rsize = 0;
1515
1516 compression = compress_blob(data, size, o->data.payload, size - 1, &rsize);
1517
1518 if (compression >= 0) {
1519 o->object.size = htole64(offsetof(Object, data.payload) + rsize);
1520 o->object.flags |= compression;
1521
1522 log_debug("Compressed data object %"PRIu64" -> %zu using %s",
1523 size, rsize, object_compressed_to_string(compression));
1524 } else
1525 /* Compression didn't work, we don't really care why, let's continue without compression */
1526 compression = 0;
1527 }
1528 #endif
1529
1530 if (compression == 0)
1531 memcpy_safe(o->data.payload, data, size);
1532
1533 r = journal_file_link_data(f, o, p, hash);
1534 if (r < 0)
1535 return r;
1536
1537 #if HAVE_GCRYPT
1538 r = journal_file_hmac_put_object(f, OBJECT_DATA, o, p);
1539 if (r < 0)
1540 return r;
1541 #endif
1542
1543 /* The linking might have altered the window, so let's
1544 * refresh our pointer */
1545 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
1546 if (r < 0)
1547 return r;
1548
1549 if (!data)
1550 eq = NULL;
1551 else
1552 eq = memchr(data, '=', size);
1553 if (eq && eq > data) {
1554 Object *fo = NULL;
1555 uint64_t fp;
1556
1557 /* Create field object ... */
1558 r = journal_file_append_field(f, data, (uint8_t*) eq - (uint8_t*) data, &fo, &fp);
1559 if (r < 0)
1560 return r;
1561
1562 /* ... and link it in. */
1563 o->data.next_field_offset = fo->field.head_data_offset;
1564 fo->field.head_data_offset = le64toh(p);
1565 }
1566
1567 if (ret)
1568 *ret = o;
1569
1570 if (offset)
1571 *offset = p;
1572
1573 return 0;
1574 }
1575
1576 uint64_t journal_file_entry_n_items(Object *o) {
1577 assert(o);
1578
1579 if (o->object.type != OBJECT_ENTRY)
1580 return 0;
1581
1582 return (le64toh(o->object.size) - offsetof(Object, entry.items)) / sizeof(EntryItem);
1583 }
1584
1585 uint64_t journal_file_entry_array_n_items(Object *o) {
1586 assert(o);
1587
1588 if (o->object.type != OBJECT_ENTRY_ARRAY)
1589 return 0;
1590
1591 return (le64toh(o->object.size) - offsetof(Object, entry_array.items)) / sizeof(uint64_t);
1592 }
1593
1594 uint64_t journal_file_hash_table_n_items(Object *o) {
1595 assert(o);
1596
1597 if (!IN_SET(o->object.type, OBJECT_DATA_HASH_TABLE, OBJECT_FIELD_HASH_TABLE))
1598 return 0;
1599
1600 return (le64toh(o->object.size) - offsetof(Object, hash_table.items)) / sizeof(HashItem);
1601 }
1602
1603 static int link_entry_into_array(JournalFile *f,
1604 le64_t *first,
1605 le64_t *idx,
1606 uint64_t p) {
1607 int r;
1608 uint64_t n = 0, ap = 0, q, i, a, hidx;
1609 Object *o;
1610
1611 assert(f);
1612 assert(f->header);
1613 assert(first);
1614 assert(idx);
1615 assert(p > 0);
1616
1617 a = le64toh(*first);
1618 i = hidx = le64toh(*idx);
1619 while (a > 0) {
1620
1621 r = journal_file_move_to_object(f, OBJECT_ENTRY_ARRAY, a, &o);
1622 if (r < 0)
1623 return r;
1624
1625 n = journal_file_entry_array_n_items(o);
1626 if (i < n) {
1627 o->entry_array.items[i] = htole64(p);
1628 *idx = htole64(hidx + 1);
1629 return 0;
1630 }
1631
1632 i -= n;
1633 ap = a;
1634 a = le64toh(o->entry_array.next_entry_array_offset);
1635 }
1636
1637 if (hidx > n)
1638 n = (hidx+1) * 2;
1639 else
1640 n = n * 2;
1641
1642 if (n < 4)
1643 n = 4;
1644
1645 r = journal_file_append_object(f, OBJECT_ENTRY_ARRAY,
1646 offsetof(Object, entry_array.items) + n * sizeof(uint64_t),
1647 &o, &q);
1648 if (r < 0)
1649 return r;
1650
1651 #if HAVE_GCRYPT
1652 r = journal_file_hmac_put_object(f, OBJECT_ENTRY_ARRAY, o, q);
1653 if (r < 0)
1654 return r;
1655 #endif
1656
1657 o->entry_array.items[i] = htole64(p);
1658
1659 if (ap == 0)
1660 *first = htole64(q);
1661 else {
1662 r = journal_file_move_to_object(f, OBJECT_ENTRY_ARRAY, ap, &o);
1663 if (r < 0)
1664 return r;
1665
1666 o->entry_array.next_entry_array_offset = htole64(q);
1667 }
1668
1669 if (JOURNAL_HEADER_CONTAINS(f->header, n_entry_arrays))
1670 f->header->n_entry_arrays = htole64(le64toh(f->header->n_entry_arrays) + 1);
1671
1672 *idx = htole64(hidx + 1);
1673
1674 return 0;
1675 }
1676
1677 static int link_entry_into_array_plus_one(JournalFile *f,
1678 le64_t *extra,
1679 le64_t *first,
1680 le64_t *idx,
1681 uint64_t p) {
1682
1683 int r;
1684
1685 assert(f);
1686 assert(extra);
1687 assert(first);
1688 assert(idx);
1689 assert(p > 0);
1690
1691 if (*idx == 0)
1692 *extra = htole64(p);
1693 else {
1694 le64_t i;
1695
1696 i = htole64(le64toh(*idx) - 1);
1697 r = link_entry_into_array(f, first, &i, p);
1698 if (r < 0)
1699 return r;
1700 }
1701
1702 *idx = htole64(le64toh(*idx) + 1);
1703 return 0;
1704 }
1705
1706 static int journal_file_link_entry_item(JournalFile *f, Object *o, uint64_t offset, uint64_t i) {
1707 uint64_t p;
1708 int r;
1709 assert(f);
1710 assert(o);
1711 assert(offset > 0);
1712
1713 p = le64toh(o->entry.items[i].object_offset);
1714 if (p == 0)
1715 return -EINVAL;
1716
1717 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
1718 if (r < 0)
1719 return r;
1720
1721 return link_entry_into_array_plus_one(f,
1722 &o->data.entry_offset,
1723 &o->data.entry_array_offset,
1724 &o->data.n_entries,
1725 offset);
1726 }
1727
1728 static int journal_file_link_entry(JournalFile *f, Object *o, uint64_t offset) {
1729 uint64_t n, i;
1730 int r;
1731
1732 assert(f);
1733 assert(f->header);
1734 assert(o);
1735 assert(offset > 0);
1736
1737 if (o->object.type != OBJECT_ENTRY)
1738 return -EINVAL;
1739
1740 __sync_synchronize();
1741
1742 /* Link up the entry itself */
1743 r = link_entry_into_array(f,
1744 &f->header->entry_array_offset,
1745 &f->header->n_entries,
1746 offset);
1747 if (r < 0)
1748 return r;
1749
1750 /* log_debug("=> %s seqnr=%"PRIu64" n_entries=%"PRIu64, f->path, o->entry.seqnum, f->header->n_entries); */
1751
1752 if (f->header->head_entry_realtime == 0)
1753 f->header->head_entry_realtime = o->entry.realtime;
1754
1755 f->header->tail_entry_realtime = o->entry.realtime;
1756 f->header->tail_entry_monotonic = o->entry.monotonic;
1757
1758 /* Link up the items */
1759 n = journal_file_entry_n_items(o);
1760 for (i = 0; i < n; i++) {
1761 r = journal_file_link_entry_item(f, o, offset, i);
1762 if (r < 0)
1763 return r;
1764 }
1765
1766 return 0;
1767 }
1768
1769 static int journal_file_append_entry_internal(
1770 JournalFile *f,
1771 const dual_timestamp *ts,
1772 const sd_id128_t *boot_id,
1773 uint64_t xor_hash,
1774 const EntryItem items[], unsigned n_items,
1775 uint64_t *seqnum,
1776 Object **ret, uint64_t *offset) {
1777 uint64_t np;
1778 uint64_t osize;
1779 Object *o;
1780 int r;
1781
1782 assert(f);
1783 assert(f->header);
1784 assert(items || n_items == 0);
1785 assert(ts);
1786
1787 osize = offsetof(Object, entry.items) + (n_items * sizeof(EntryItem));
1788
1789 r = journal_file_append_object(f, OBJECT_ENTRY, osize, &o, &np);
1790 if (r < 0)
1791 return r;
1792
1793 o->entry.seqnum = htole64(journal_file_entry_seqnum(f, seqnum));
1794 memcpy_safe(o->entry.items, items, n_items * sizeof(EntryItem));
1795 o->entry.realtime = htole64(ts->realtime);
1796 o->entry.monotonic = htole64(ts->monotonic);
1797 o->entry.xor_hash = htole64(xor_hash);
1798 if (boot_id)
1799 f->header->boot_id = *boot_id;
1800 o->entry.boot_id = f->header->boot_id;
1801
1802 #if HAVE_GCRYPT
1803 r = journal_file_hmac_put_object(f, OBJECT_ENTRY, o, np);
1804 if (r < 0)
1805 return r;
1806 #endif
1807
1808 r = journal_file_link_entry(f, o, np);
1809 if (r < 0)
1810 return r;
1811
1812 if (ret)
1813 *ret = o;
1814
1815 if (offset)
1816 *offset = np;
1817
1818 return 0;
1819 }
1820
1821 void journal_file_post_change(JournalFile *f) {
1822 assert(f);
1823
1824 if (f->fd < 0)
1825 return;
1826
1827 /* inotify() does not receive IN_MODIFY events from file
1828 * accesses done via mmap(). After each access we hence
1829 * trigger IN_MODIFY by truncating the journal file to its
1830 * current size which triggers IN_MODIFY. */
1831
1832 __sync_synchronize();
1833
1834 if (ftruncate(f->fd, f->last_stat.st_size) < 0)
1835 log_debug_errno(errno, "Failed to truncate file to its own size: %m");
1836 }
1837
1838 static int post_change_thunk(sd_event_source *timer, uint64_t usec, void *userdata) {
1839 assert(userdata);
1840
1841 journal_file_post_change(userdata);
1842
1843 return 1;
1844 }
1845
1846 static void schedule_post_change(JournalFile *f) {
1847 uint64_t now;
1848 int r;
1849
1850 assert(f);
1851 assert(f->post_change_timer);
1852
1853 r = sd_event_source_get_enabled(f->post_change_timer, NULL);
1854 if (r < 0) {
1855 log_debug_errno(r, "Failed to get ftruncate timer state: %m");
1856 goto fail;
1857 }
1858 if (r > 0)
1859 return;
1860
1861 r = sd_event_now(sd_event_source_get_event(f->post_change_timer), CLOCK_MONOTONIC, &now);
1862 if (r < 0) {
1863 log_debug_errno(r, "Failed to get clock's now for scheduling ftruncate: %m");
1864 goto fail;
1865 }
1866
1867 r = sd_event_source_set_time(f->post_change_timer, now + f->post_change_timer_period);
1868 if (r < 0) {
1869 log_debug_errno(r, "Failed to set time for scheduling ftruncate: %m");
1870 goto fail;
1871 }
1872
1873 r = sd_event_source_set_enabled(f->post_change_timer, SD_EVENT_ONESHOT);
1874 if (r < 0) {
1875 log_debug_errno(r, "Failed to enable scheduled ftruncate: %m");
1876 goto fail;
1877 }
1878
1879 return;
1880
1881 fail:
1882 /* On failure, let's simply post the change immediately. */
1883 journal_file_post_change(f);
1884 }
1885
1886 /* Enable coalesced change posting in a timer on the provided sd_event instance */
1887 int journal_file_enable_post_change_timer(JournalFile *f, sd_event *e, usec_t t) {
1888 _cleanup_(sd_event_source_unrefp) sd_event_source *timer = NULL;
1889 int r;
1890
1891 assert(f);
1892 assert_return(!f->post_change_timer, -EINVAL);
1893 assert(e);
1894 assert(t);
1895
1896 r = sd_event_add_time(e, &timer, CLOCK_MONOTONIC, 0, 0, post_change_thunk, f);
1897 if (r < 0)
1898 return r;
1899
1900 r = sd_event_source_set_enabled(timer, SD_EVENT_OFF);
1901 if (r < 0)
1902 return r;
1903
1904 f->post_change_timer = TAKE_PTR(timer);
1905 f->post_change_timer_period = t;
1906
1907 return r;
1908 }
1909
1910 static int entry_item_cmp(const EntryItem *a, const EntryItem *b) {
1911 return CMP(le64toh(a->object_offset), le64toh(b->object_offset));
1912 }
1913
1914 int journal_file_append_entry(
1915 JournalFile *f,
1916 const dual_timestamp *ts,
1917 const sd_id128_t *boot_id,
1918 const struct iovec iovec[], unsigned n_iovec,
1919 uint64_t *seqnum,
1920 Object **ret, uint64_t *offset) {
1921
1922 unsigned i;
1923 EntryItem *items;
1924 int r;
1925 uint64_t xor_hash = 0;
1926 struct dual_timestamp _ts;
1927
1928 assert(f);
1929 assert(f->header);
1930 assert(iovec || n_iovec == 0);
1931
1932 if (ts) {
1933 if (!VALID_REALTIME(ts->realtime))
1934 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
1935 "Invalid realtime timestamp %" PRIu64 ", refusing entry.",
1936 ts->realtime);
1937 if (!VALID_MONOTONIC(ts->monotonic))
1938 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
1939 "Invalid monotomic timestamp %" PRIu64 ", refusing entry.",
1940 ts->monotonic);
1941 } else {
1942 dual_timestamp_get(&_ts);
1943 ts = &_ts;
1944 }
1945
1946 #if HAVE_GCRYPT
1947 r = journal_file_maybe_append_tag(f, ts->realtime);
1948 if (r < 0)
1949 return r;
1950 #endif
1951
1952 /* alloca() can't take 0, hence let's allocate at least one */
1953 items = newa(EntryItem, MAX(1u, n_iovec));
1954
1955 for (i = 0; i < n_iovec; i++) {
1956 uint64_t p;
1957 Object *o;
1958
1959 r = journal_file_append_data(f, iovec[i].iov_base, iovec[i].iov_len, &o, &p);
1960 if (r < 0)
1961 return r;
1962
1963 xor_hash ^= le64toh(o->data.hash);
1964 items[i].object_offset = htole64(p);
1965 items[i].hash = o->data.hash;
1966 }
1967
1968 /* Order by the position on disk, in order to improve seek
1969 * times for rotating media. */
1970 typesafe_qsort(items, n_iovec, entry_item_cmp);
1971
1972 r = journal_file_append_entry_internal(f, ts, boot_id, xor_hash, items, n_iovec, seqnum, ret, offset);
1973
1974 /* If the memory mapping triggered a SIGBUS then we return an
1975 * IO error and ignore the error code passed down to us, since
1976 * it is very likely just an effect of a nullified replacement
1977 * mapping page */
1978
1979 if (mmap_cache_got_sigbus(f->mmap, f->cache_fd))
1980 r = -EIO;
1981
1982 if (f->post_change_timer)
1983 schedule_post_change(f);
1984 else
1985 journal_file_post_change(f);
1986
1987 return r;
1988 }
1989
1990 typedef struct ChainCacheItem {
1991 uint64_t first; /* the array at the beginning of the chain */
1992 uint64_t array; /* the cached array */
1993 uint64_t begin; /* the first item in the cached array */
1994 uint64_t total; /* the total number of items in all arrays before this one in the chain */
1995 uint64_t last_index; /* the last index we looked at, to optimize locality when bisecting */
1996 } ChainCacheItem;
1997
1998 static void chain_cache_put(
1999 OrderedHashmap *h,
2000 ChainCacheItem *ci,
2001 uint64_t first,
2002 uint64_t array,
2003 uint64_t begin,
2004 uint64_t total,
2005 uint64_t last_index) {
2006
2007 if (!ci) {
2008 /* If the chain item to cache for this chain is the
2009 * first one it's not worth caching anything */
2010 if (array == first)
2011 return;
2012
2013 if (ordered_hashmap_size(h) >= CHAIN_CACHE_MAX) {
2014 ci = ordered_hashmap_steal_first(h);
2015 assert(ci);
2016 } else {
2017 ci = new(ChainCacheItem, 1);
2018 if (!ci)
2019 return;
2020 }
2021
2022 ci->first = first;
2023
2024 if (ordered_hashmap_put(h, &ci->first, ci) < 0) {
2025 free(ci);
2026 return;
2027 }
2028 } else
2029 assert(ci->first == first);
2030
2031 ci->array = array;
2032 ci->begin = begin;
2033 ci->total = total;
2034 ci->last_index = last_index;
2035 }
2036
2037 static int generic_array_get(
2038 JournalFile *f,
2039 uint64_t first,
2040 uint64_t i,
2041 Object **ret, uint64_t *offset) {
2042
2043 Object *o;
2044 uint64_t p = 0, a, t = 0;
2045 int r;
2046 ChainCacheItem *ci;
2047
2048 assert(f);
2049
2050 a = first;
2051
2052 /* Try the chain cache first */
2053 ci = ordered_hashmap_get(f->chain_cache, &first);
2054 if (ci && i > ci->total) {
2055 a = ci->array;
2056 i -= ci->total;
2057 t = ci->total;
2058 }
2059
2060 while (a > 0) {
2061 uint64_t k;
2062
2063 r = journal_file_move_to_object(f, OBJECT_ENTRY_ARRAY, a, &o);
2064 if (r < 0)
2065 return r;
2066
2067 k = journal_file_entry_array_n_items(o);
2068 if (i < k) {
2069 p = le64toh(o->entry_array.items[i]);
2070 goto found;
2071 }
2072
2073 i -= k;
2074 t += k;
2075 a = le64toh(o->entry_array.next_entry_array_offset);
2076 }
2077
2078 return 0;
2079
2080 found:
2081 /* Let's cache this item for the next invocation */
2082 chain_cache_put(f->chain_cache, ci, first, a, le64toh(o->entry_array.items[0]), t, i);
2083
2084 r = journal_file_move_to_object(f, OBJECT_ENTRY, p, &o);
2085 if (r < 0)
2086 return r;
2087
2088 if (ret)
2089 *ret = o;
2090
2091 if (offset)
2092 *offset = p;
2093
2094 return 1;
2095 }
2096
2097 static int generic_array_get_plus_one(
2098 JournalFile *f,
2099 uint64_t extra,
2100 uint64_t first,
2101 uint64_t i,
2102 Object **ret, uint64_t *offset) {
2103
2104 Object *o;
2105
2106 assert(f);
2107
2108 if (i == 0) {
2109 int r;
2110
2111 r = journal_file_move_to_object(f, OBJECT_ENTRY, extra, &o);
2112 if (r < 0)
2113 return r;
2114
2115 if (ret)
2116 *ret = o;
2117
2118 if (offset)
2119 *offset = extra;
2120
2121 return 1;
2122 }
2123
2124 return generic_array_get(f, first, i-1, ret, offset);
2125 }
2126
2127 enum {
2128 TEST_FOUND,
2129 TEST_LEFT,
2130 TEST_RIGHT
2131 };
2132
2133 static int generic_array_bisect(
2134 JournalFile *f,
2135 uint64_t first,
2136 uint64_t n,
2137 uint64_t needle,
2138 int (*test_object)(JournalFile *f, uint64_t p, uint64_t needle),
2139 direction_t direction,
2140 Object **ret,
2141 uint64_t *offset,
2142 uint64_t *idx) {
2143
2144 uint64_t a, p, t = 0, i = 0, last_p = 0, last_index = (uint64_t) -1;
2145 bool subtract_one = false;
2146 Object *o, *array = NULL;
2147 int r;
2148 ChainCacheItem *ci;
2149
2150 assert(f);
2151 assert(test_object);
2152
2153 /* Start with the first array in the chain */
2154 a = first;
2155
2156 ci = ordered_hashmap_get(f->chain_cache, &first);
2157 if (ci && n > ci->total && ci->begin != 0) {
2158 /* Ah, we have iterated this bisection array chain
2159 * previously! Let's see if we can skip ahead in the
2160 * chain, as far as the last time. But we can't jump
2161 * backwards in the chain, so let's check that
2162 * first. */
2163
2164 r = test_object(f, ci->begin, needle);
2165 if (r < 0)
2166 return r;
2167
2168 if (r == TEST_LEFT) {
2169 /* OK, what we are looking for is right of the
2170 * begin of this EntryArray, so let's jump
2171 * straight to previously cached array in the
2172 * chain */
2173
2174 a = ci->array;
2175 n -= ci->total;
2176 t = ci->total;
2177 last_index = ci->last_index;
2178 }
2179 }
2180
2181 while (a > 0) {
2182 uint64_t left, right, k, lp;
2183
2184 r = journal_file_move_to_object(f, OBJECT_ENTRY_ARRAY, a, &array);
2185 if (r < 0)
2186 return r;
2187
2188 k = journal_file_entry_array_n_items(array);
2189 right = MIN(k, n);
2190 if (right <= 0)
2191 return 0;
2192
2193 i = right - 1;
2194 lp = p = le64toh(array->entry_array.items[i]);
2195 if (p <= 0)
2196 r = -EBADMSG;
2197 else
2198 r = test_object(f, p, needle);
2199 if (r == -EBADMSG) {
2200 log_debug_errno(r, "Encountered invalid entry while bisecting, cutting algorithm short. (1)");
2201 n = i;
2202 continue;
2203 }
2204 if (r < 0)
2205 return r;
2206
2207 if (r == TEST_FOUND)
2208 r = direction == DIRECTION_DOWN ? TEST_RIGHT : TEST_LEFT;
2209
2210 if (r == TEST_RIGHT) {
2211 left = 0;
2212 right -= 1;
2213
2214 if (last_index != (uint64_t) -1) {
2215 assert(last_index <= right);
2216
2217 /* If we cached the last index we
2218 * looked at, let's try to not to jump
2219 * too wildly around and see if we can
2220 * limit the range to look at early to
2221 * the immediate neighbors of the last
2222 * index we looked at. */
2223
2224 if (last_index > 0) {
2225 uint64_t x = last_index - 1;
2226
2227 p = le64toh(array->entry_array.items[x]);
2228 if (p <= 0)
2229 return -EBADMSG;
2230
2231 r = test_object(f, p, needle);
2232 if (r < 0)
2233 return r;
2234
2235 if (r == TEST_FOUND)
2236 r = direction == DIRECTION_DOWN ? TEST_RIGHT : TEST_LEFT;
2237
2238 if (r == TEST_RIGHT)
2239 right = x;
2240 else
2241 left = x + 1;
2242 }
2243
2244 if (last_index < right) {
2245 uint64_t y = last_index + 1;
2246
2247 p = le64toh(array->entry_array.items[y]);
2248 if (p <= 0)
2249 return -EBADMSG;
2250
2251 r = test_object(f, p, needle);
2252 if (r < 0)
2253 return r;
2254
2255 if (r == TEST_FOUND)
2256 r = direction == DIRECTION_DOWN ? TEST_RIGHT : TEST_LEFT;
2257
2258 if (r == TEST_RIGHT)
2259 right = y;
2260 else
2261 left = y + 1;
2262 }
2263 }
2264
2265 for (;;) {
2266 if (left == right) {
2267 if (direction == DIRECTION_UP)
2268 subtract_one = true;
2269
2270 i = left;
2271 goto found;
2272 }
2273
2274 assert(left < right);
2275 i = (left + right) / 2;
2276
2277 p = le64toh(array->entry_array.items[i]);
2278 if (p <= 0)
2279 r = -EBADMSG;
2280 else
2281 r = test_object(f, p, needle);
2282 if (r == -EBADMSG) {
2283 log_debug_errno(r, "Encountered invalid entry while bisecting, cutting algorithm short. (2)");
2284 right = n = i;
2285 continue;
2286 }
2287 if (r < 0)
2288 return r;
2289
2290 if (r == TEST_FOUND)
2291 r = direction == DIRECTION_DOWN ? TEST_RIGHT : TEST_LEFT;
2292
2293 if (r == TEST_RIGHT)
2294 right = i;
2295 else
2296 left = i + 1;
2297 }
2298 }
2299
2300 if (k >= n) {
2301 if (direction == DIRECTION_UP) {
2302 i = n;
2303 subtract_one = true;
2304 goto found;
2305 }
2306
2307 return 0;
2308 }
2309
2310 last_p = lp;
2311
2312 n -= k;
2313 t += k;
2314 last_index = (uint64_t) -1;
2315 a = le64toh(array->entry_array.next_entry_array_offset);
2316 }
2317
2318 return 0;
2319
2320 found:
2321 if (subtract_one && t == 0 && i == 0)
2322 return 0;
2323
2324 /* Let's cache this item for the next invocation */
2325 chain_cache_put(f->chain_cache, ci, first, a, le64toh(array->entry_array.items[0]), t, subtract_one ? (i > 0 ? i-1 : (uint64_t) -1) : i);
2326
2327 if (subtract_one && i == 0)
2328 p = last_p;
2329 else if (subtract_one)
2330 p = le64toh(array->entry_array.items[i-1]);
2331 else
2332 p = le64toh(array->entry_array.items[i]);
2333
2334 r = journal_file_move_to_object(f, OBJECT_ENTRY, p, &o);
2335 if (r < 0)
2336 return r;
2337
2338 if (ret)
2339 *ret = o;
2340
2341 if (offset)
2342 *offset = p;
2343
2344 if (idx)
2345 *idx = t + i + (subtract_one ? -1 : 0);
2346
2347 return 1;
2348 }
2349
2350 static int generic_array_bisect_plus_one(
2351 JournalFile *f,
2352 uint64_t extra,
2353 uint64_t first,
2354 uint64_t n,
2355 uint64_t needle,
2356 int (*test_object)(JournalFile *f, uint64_t p, uint64_t needle),
2357 direction_t direction,
2358 Object **ret,
2359 uint64_t *offset,
2360 uint64_t *idx) {
2361
2362 int r;
2363 bool step_back = false;
2364 Object *o;
2365
2366 assert(f);
2367 assert(test_object);
2368
2369 if (n <= 0)
2370 return 0;
2371
2372 /* This bisects the array in object 'first', but first checks
2373 * an extra */
2374 r = test_object(f, extra, needle);
2375 if (r < 0)
2376 return r;
2377
2378 if (r == TEST_FOUND)
2379 r = direction == DIRECTION_DOWN ? TEST_RIGHT : TEST_LEFT;
2380
2381 /* if we are looking with DIRECTION_UP then we need to first
2382 see if in the actual array there is a matching entry, and
2383 return the last one of that. But if there isn't any we need
2384 to return this one. Hence remember this, and return it
2385 below. */
2386 if (r == TEST_LEFT)
2387 step_back = direction == DIRECTION_UP;
2388
2389 if (r == TEST_RIGHT) {
2390 if (direction == DIRECTION_DOWN)
2391 goto found;
2392 else
2393 return 0;
2394 }
2395
2396 r = generic_array_bisect(f, first, n-1, needle, test_object, direction, ret, offset, idx);
2397
2398 if (r == 0 && step_back)
2399 goto found;
2400
2401 if (r > 0 && idx)
2402 (*idx)++;
2403
2404 return r;
2405
2406 found:
2407 r = journal_file_move_to_object(f, OBJECT_ENTRY, extra, &o);
2408 if (r < 0)
2409 return r;
2410
2411 if (ret)
2412 *ret = o;
2413
2414 if (offset)
2415 *offset = extra;
2416
2417 if (idx)
2418 *idx = 0;
2419
2420 return 1;
2421 }
2422
2423 _pure_ static int test_object_offset(JournalFile *f, uint64_t p, uint64_t needle) {
2424 assert(f);
2425 assert(p > 0);
2426
2427 if (p == needle)
2428 return TEST_FOUND;
2429 else if (p < needle)
2430 return TEST_LEFT;
2431 else
2432 return TEST_RIGHT;
2433 }
2434
2435 static int test_object_seqnum(JournalFile *f, uint64_t p, uint64_t needle) {
2436 Object *o;
2437 int r;
2438
2439 assert(f);
2440 assert(p > 0);
2441
2442 r = journal_file_move_to_object(f, OBJECT_ENTRY, p, &o);
2443 if (r < 0)
2444 return r;
2445
2446 if (le64toh(o->entry.seqnum) == needle)
2447 return TEST_FOUND;
2448 else if (le64toh(o->entry.seqnum) < needle)
2449 return TEST_LEFT;
2450 else
2451 return TEST_RIGHT;
2452 }
2453
2454 int journal_file_move_to_entry_by_seqnum(
2455 JournalFile *f,
2456 uint64_t seqnum,
2457 direction_t direction,
2458 Object **ret,
2459 uint64_t *offset) {
2460 assert(f);
2461 assert(f->header);
2462
2463 return generic_array_bisect(f,
2464 le64toh(f->header->entry_array_offset),
2465 le64toh(f->header->n_entries),
2466 seqnum,
2467 test_object_seqnum,
2468 direction,
2469 ret, offset, NULL);
2470 }
2471
2472 static int test_object_realtime(JournalFile *f, uint64_t p, uint64_t needle) {
2473 Object *o;
2474 int r;
2475
2476 assert(f);
2477 assert(p > 0);
2478
2479 r = journal_file_move_to_object(f, OBJECT_ENTRY, p, &o);
2480 if (r < 0)
2481 return r;
2482
2483 if (le64toh(o->entry.realtime) == needle)
2484 return TEST_FOUND;
2485 else if (le64toh(o->entry.realtime) < needle)
2486 return TEST_LEFT;
2487 else
2488 return TEST_RIGHT;
2489 }
2490
2491 int journal_file_move_to_entry_by_realtime(
2492 JournalFile *f,
2493 uint64_t realtime,
2494 direction_t direction,
2495 Object **ret,
2496 uint64_t *offset) {
2497 assert(f);
2498 assert(f->header);
2499
2500 return generic_array_bisect(f,
2501 le64toh(f->header->entry_array_offset),
2502 le64toh(f->header->n_entries),
2503 realtime,
2504 test_object_realtime,
2505 direction,
2506 ret, offset, NULL);
2507 }
2508
2509 static int test_object_monotonic(JournalFile *f, uint64_t p, uint64_t needle) {
2510 Object *o;
2511 int r;
2512
2513 assert(f);
2514 assert(p > 0);
2515
2516 r = journal_file_move_to_object(f, OBJECT_ENTRY, p, &o);
2517 if (r < 0)
2518 return r;
2519
2520 if (le64toh(o->entry.monotonic) == needle)
2521 return TEST_FOUND;
2522 else if (le64toh(o->entry.monotonic) < needle)
2523 return TEST_LEFT;
2524 else
2525 return TEST_RIGHT;
2526 }
2527
2528 static int find_data_object_by_boot_id(
2529 JournalFile *f,
2530 sd_id128_t boot_id,
2531 Object **o,
2532 uint64_t *b) {
2533
2534 char t[STRLEN("_BOOT_ID=") + 32 + 1] = "_BOOT_ID=";
2535
2536 sd_id128_to_string(boot_id, t + 9);
2537 return journal_file_find_data_object(f, t, sizeof(t) - 1, o, b);
2538 }
2539
2540 int journal_file_move_to_entry_by_monotonic(
2541 JournalFile *f,
2542 sd_id128_t boot_id,
2543 uint64_t monotonic,
2544 direction_t direction,
2545 Object **ret,
2546 uint64_t *offset) {
2547
2548 Object *o;
2549 int r;
2550
2551 assert(f);
2552
2553 r = find_data_object_by_boot_id(f, boot_id, &o, NULL);
2554 if (r < 0)
2555 return r;
2556 if (r == 0)
2557 return -ENOENT;
2558
2559 return generic_array_bisect_plus_one(f,
2560 le64toh(o->data.entry_offset),
2561 le64toh(o->data.entry_array_offset),
2562 le64toh(o->data.n_entries),
2563 monotonic,
2564 test_object_monotonic,
2565 direction,
2566 ret, offset, NULL);
2567 }
2568
2569 void journal_file_reset_location(JournalFile *f) {
2570 f->location_type = LOCATION_HEAD;
2571 f->current_offset = 0;
2572 f->current_seqnum = 0;
2573 f->current_realtime = 0;
2574 f->current_monotonic = 0;
2575 zero(f->current_boot_id);
2576 f->current_xor_hash = 0;
2577 }
2578
2579 void journal_file_save_location(JournalFile *f, Object *o, uint64_t offset) {
2580 f->location_type = LOCATION_SEEK;
2581 f->current_offset = offset;
2582 f->current_seqnum = le64toh(o->entry.seqnum);
2583 f->current_realtime = le64toh(o->entry.realtime);
2584 f->current_monotonic = le64toh(o->entry.monotonic);
2585 f->current_boot_id = o->entry.boot_id;
2586 f->current_xor_hash = le64toh(o->entry.xor_hash);
2587 }
2588
2589 int journal_file_compare_locations(JournalFile *af, JournalFile *bf) {
2590 int r;
2591
2592 assert(af);
2593 assert(af->header);
2594 assert(bf);
2595 assert(bf->header);
2596 assert(af->location_type == LOCATION_SEEK);
2597 assert(bf->location_type == LOCATION_SEEK);
2598
2599 /* If contents and timestamps match, these entries are
2600 * identical, even if the seqnum does not match */
2601 if (sd_id128_equal(af->current_boot_id, bf->current_boot_id) &&
2602 af->current_monotonic == bf->current_monotonic &&
2603 af->current_realtime == bf->current_realtime &&
2604 af->current_xor_hash == bf->current_xor_hash)
2605 return 0;
2606
2607 if (sd_id128_equal(af->header->seqnum_id, bf->header->seqnum_id)) {
2608
2609 /* If this is from the same seqnum source, compare
2610 * seqnums */
2611 r = CMP(af->current_seqnum, bf->current_seqnum);
2612 if (r != 0)
2613 return r;
2614
2615 /* Wow! This is weird, different data but the same
2616 * seqnums? Something is borked, but let's make the
2617 * best of it and compare by time. */
2618 }
2619
2620 if (sd_id128_equal(af->current_boot_id, bf->current_boot_id)) {
2621
2622 /* If the boot id matches, compare monotonic time */
2623 r = CMP(af->current_monotonic, bf->current_monotonic);
2624 if (r != 0)
2625 return r;
2626 }
2627
2628 /* Otherwise, compare UTC time */
2629 r = CMP(af->current_realtime, bf->current_realtime);
2630 if (r != 0)
2631 return r;
2632
2633 /* Finally, compare by contents */
2634 return CMP(af->current_xor_hash, bf->current_xor_hash);
2635 }
2636
2637 static int bump_array_index(uint64_t *i, direction_t direction, uint64_t n) {
2638
2639 /* Increase or decrease the specified index, in the right direction. */
2640
2641 if (direction == DIRECTION_DOWN) {
2642 if (*i >= n - 1)
2643 return 0;
2644
2645 (*i) ++;
2646 } else {
2647 if (*i <= 0)
2648 return 0;
2649
2650 (*i) --;
2651 }
2652
2653 return 1;
2654 }
2655
2656 static bool check_properly_ordered(uint64_t new_offset, uint64_t old_offset, direction_t direction) {
2657
2658 /* Consider it an error if any of the two offsets is uninitialized */
2659 if (old_offset == 0 || new_offset == 0)
2660 return false;
2661
2662 /* If we go down, the new offset must be larger than the old one. */
2663 return direction == DIRECTION_DOWN ?
2664 new_offset > old_offset :
2665 new_offset < old_offset;
2666 }
2667
2668 int journal_file_next_entry(
2669 JournalFile *f,
2670 uint64_t p,
2671 direction_t direction,
2672 Object **ret, uint64_t *offset) {
2673
2674 uint64_t i, n, ofs;
2675 int r;
2676
2677 assert(f);
2678 assert(f->header);
2679
2680 n = le64toh(f->header->n_entries);
2681 if (n <= 0)
2682 return 0;
2683
2684 if (p == 0)
2685 i = direction == DIRECTION_DOWN ? 0 : n - 1;
2686 else {
2687 r = generic_array_bisect(f,
2688 le64toh(f->header->entry_array_offset),
2689 le64toh(f->header->n_entries),
2690 p,
2691 test_object_offset,
2692 DIRECTION_DOWN,
2693 NULL, NULL,
2694 &i);
2695 if (r <= 0)
2696 return r;
2697
2698 r = bump_array_index(&i, direction, n);
2699 if (r <= 0)
2700 return r;
2701 }
2702
2703 /* And jump to it */
2704 for (;;) {
2705 r = generic_array_get(f,
2706 le64toh(f->header->entry_array_offset),
2707 i,
2708 ret, &ofs);
2709 if (r > 0)
2710 break;
2711 if (r != -EBADMSG)
2712 return r;
2713
2714 /* OK, so this entry is borked. Most likely some entry didn't get synced to disk properly, let's see if
2715 * the next one might work for us instead. */
2716 log_debug_errno(r, "Entry item %" PRIu64 " is bad, skipping over it.", i);
2717
2718 r = bump_array_index(&i, direction, n);
2719 if (r <= 0)
2720 return r;
2721 }
2722
2723 /* Ensure our array is properly ordered. */
2724 if (p > 0 && !check_properly_ordered(ofs, p, direction))
2725 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
2726 "%s: entry array not properly ordered at entry %" PRIu64,
2727 f->path, i);
2728
2729 if (offset)
2730 *offset = ofs;
2731
2732 return 1;
2733 }
2734
2735 int journal_file_next_entry_for_data(
2736 JournalFile *f,
2737 Object *o, uint64_t p,
2738 uint64_t data_offset,
2739 direction_t direction,
2740 Object **ret, uint64_t *offset) {
2741
2742 uint64_t i, n, ofs;
2743 Object *d;
2744 int r;
2745
2746 assert(f);
2747 assert(p > 0 || !o);
2748
2749 r = journal_file_move_to_object(f, OBJECT_DATA, data_offset, &d);
2750 if (r < 0)
2751 return r;
2752
2753 n = le64toh(d->data.n_entries);
2754 if (n <= 0)
2755 return n;
2756
2757 if (!o)
2758 i = direction == DIRECTION_DOWN ? 0 : n - 1;
2759 else {
2760 if (o->object.type != OBJECT_ENTRY)
2761 return -EINVAL;
2762
2763 r = generic_array_bisect_plus_one(f,
2764 le64toh(d->data.entry_offset),
2765 le64toh(d->data.entry_array_offset),
2766 le64toh(d->data.n_entries),
2767 p,
2768 test_object_offset,
2769 DIRECTION_DOWN,
2770 NULL, NULL,
2771 &i);
2772
2773 if (r <= 0)
2774 return r;
2775
2776 r = bump_array_index(&i, direction, n);
2777 if (r <= 0)
2778 return r;
2779 }
2780
2781 for (;;) {
2782 r = generic_array_get_plus_one(f,
2783 le64toh(d->data.entry_offset),
2784 le64toh(d->data.entry_array_offset),
2785 i,
2786 ret, &ofs);
2787 if (r > 0)
2788 break;
2789 if (r != -EBADMSG)
2790 return r;
2791
2792 log_debug_errno(r, "Data entry item %" PRIu64 " is bad, skipping over it.", i);
2793
2794 r = bump_array_index(&i, direction, n);
2795 if (r <= 0)
2796 return r;
2797 }
2798
2799 /* Ensure our array is properly ordered. */
2800 if (p > 0 && check_properly_ordered(ofs, p, direction))
2801 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
2802 "%s data entry array not properly ordered at entry %" PRIu64,
2803 f->path, i);
2804
2805 if (offset)
2806 *offset = ofs;
2807
2808 return 1;
2809 }
2810
2811 int journal_file_move_to_entry_by_offset_for_data(
2812 JournalFile *f,
2813 uint64_t data_offset,
2814 uint64_t p,
2815 direction_t direction,
2816 Object **ret, uint64_t *offset) {
2817
2818 int r;
2819 Object *d;
2820
2821 assert(f);
2822
2823 r = journal_file_move_to_object(f, OBJECT_DATA, data_offset, &d);
2824 if (r < 0)
2825 return r;
2826
2827 return generic_array_bisect_plus_one(f,
2828 le64toh(d->data.entry_offset),
2829 le64toh(d->data.entry_array_offset),
2830 le64toh(d->data.n_entries),
2831 p,
2832 test_object_offset,
2833 direction,
2834 ret, offset, NULL);
2835 }
2836
2837 int journal_file_move_to_entry_by_monotonic_for_data(
2838 JournalFile *f,
2839 uint64_t data_offset,
2840 sd_id128_t boot_id,
2841 uint64_t monotonic,
2842 direction_t direction,
2843 Object **ret, uint64_t *offset) {
2844
2845 Object *o, *d;
2846 int r;
2847 uint64_t b, z;
2848
2849 assert(f);
2850
2851 /* First, seek by time */
2852 r = find_data_object_by_boot_id(f, boot_id, &o, &b);
2853 if (r < 0)
2854 return r;
2855 if (r == 0)
2856 return -ENOENT;
2857
2858 r = generic_array_bisect_plus_one(f,
2859 le64toh(o->data.entry_offset),
2860 le64toh(o->data.entry_array_offset),
2861 le64toh(o->data.n_entries),
2862 monotonic,
2863 test_object_monotonic,
2864 direction,
2865 NULL, &z, NULL);
2866 if (r <= 0)
2867 return r;
2868
2869 /* And now, continue seeking until we find an entry that
2870 * exists in both bisection arrays */
2871
2872 for (;;) {
2873 Object *qo;
2874 uint64_t p, q;
2875
2876 r = journal_file_move_to_object(f, OBJECT_DATA, data_offset, &d);
2877 if (r < 0)
2878 return r;
2879
2880 r = generic_array_bisect_plus_one(f,
2881 le64toh(d->data.entry_offset),
2882 le64toh(d->data.entry_array_offset),
2883 le64toh(d->data.n_entries),
2884 z,
2885 test_object_offset,
2886 direction,
2887 NULL, &p, NULL);
2888 if (r <= 0)
2889 return r;
2890
2891 r = journal_file_move_to_object(f, OBJECT_DATA, b, &o);
2892 if (r < 0)
2893 return r;
2894
2895 r = generic_array_bisect_plus_one(f,
2896 le64toh(o->data.entry_offset),
2897 le64toh(o->data.entry_array_offset),
2898 le64toh(o->data.n_entries),
2899 p,
2900 test_object_offset,
2901 direction,
2902 &qo, &q, NULL);
2903
2904 if (r <= 0)
2905 return r;
2906
2907 if (p == q) {
2908 if (ret)
2909 *ret = qo;
2910 if (offset)
2911 *offset = q;
2912
2913 return 1;
2914 }
2915
2916 z = q;
2917 }
2918 }
2919
2920 int journal_file_move_to_entry_by_seqnum_for_data(
2921 JournalFile *f,
2922 uint64_t data_offset,
2923 uint64_t seqnum,
2924 direction_t direction,
2925 Object **ret, uint64_t *offset) {
2926
2927 Object *d;
2928 int r;
2929
2930 assert(f);
2931
2932 r = journal_file_move_to_object(f, OBJECT_DATA, data_offset, &d);
2933 if (r < 0)
2934 return r;
2935
2936 return generic_array_bisect_plus_one(f,
2937 le64toh(d->data.entry_offset),
2938 le64toh(d->data.entry_array_offset),
2939 le64toh(d->data.n_entries),
2940 seqnum,
2941 test_object_seqnum,
2942 direction,
2943 ret, offset, NULL);
2944 }
2945
2946 int journal_file_move_to_entry_by_realtime_for_data(
2947 JournalFile *f,
2948 uint64_t data_offset,
2949 uint64_t realtime,
2950 direction_t direction,
2951 Object **ret, uint64_t *offset) {
2952
2953 Object *d;
2954 int r;
2955
2956 assert(f);
2957
2958 r = journal_file_move_to_object(f, OBJECT_DATA, data_offset, &d);
2959 if (r < 0)
2960 return r;
2961
2962 return generic_array_bisect_plus_one(f,
2963 le64toh(d->data.entry_offset),
2964 le64toh(d->data.entry_array_offset),
2965 le64toh(d->data.n_entries),
2966 realtime,
2967 test_object_realtime,
2968 direction,
2969 ret, offset, NULL);
2970 }
2971
2972 void journal_file_dump(JournalFile *f) {
2973 Object *o;
2974 int r;
2975 uint64_t p;
2976
2977 assert(f);
2978 assert(f->header);
2979
2980 journal_file_print_header(f);
2981
2982 p = le64toh(f->header->header_size);
2983 while (p != 0) {
2984 r = journal_file_move_to_object(f, OBJECT_UNUSED, p, &o);
2985 if (r < 0)
2986 goto fail;
2987
2988 switch (o->object.type) {
2989
2990 case OBJECT_UNUSED:
2991 printf("Type: OBJECT_UNUSED\n");
2992 break;
2993
2994 case OBJECT_DATA:
2995 printf("Type: OBJECT_DATA\n");
2996 break;
2997
2998 case OBJECT_FIELD:
2999 printf("Type: OBJECT_FIELD\n");
3000 break;
3001
3002 case OBJECT_ENTRY:
3003 printf("Type: OBJECT_ENTRY seqnum=%"PRIu64" monotonic=%"PRIu64" realtime=%"PRIu64"\n",
3004 le64toh(o->entry.seqnum),
3005 le64toh(o->entry.monotonic),
3006 le64toh(o->entry.realtime));
3007 break;
3008
3009 case OBJECT_FIELD_HASH_TABLE:
3010 printf("Type: OBJECT_FIELD_HASH_TABLE\n");
3011 break;
3012
3013 case OBJECT_DATA_HASH_TABLE:
3014 printf("Type: OBJECT_DATA_HASH_TABLE\n");
3015 break;
3016
3017 case OBJECT_ENTRY_ARRAY:
3018 printf("Type: OBJECT_ENTRY_ARRAY\n");
3019 break;
3020
3021 case OBJECT_TAG:
3022 printf("Type: OBJECT_TAG seqnum=%"PRIu64" epoch=%"PRIu64"\n",
3023 le64toh(o->tag.seqnum),
3024 le64toh(o->tag.epoch));
3025 break;
3026
3027 default:
3028 printf("Type: unknown (%i)\n", o->object.type);
3029 break;
3030 }
3031
3032 if (o->object.flags & OBJECT_COMPRESSION_MASK)
3033 printf("Flags: %s\n",
3034 object_compressed_to_string(o->object.flags & OBJECT_COMPRESSION_MASK));
3035
3036 if (p == le64toh(f->header->tail_object_offset))
3037 p = 0;
3038 else
3039 p = p + ALIGN64(le64toh(o->object.size));
3040 }
3041
3042 return;
3043 fail:
3044 log_error("File corrupt");
3045 }
3046
3047 static const char* format_timestamp_safe(char *buf, size_t l, usec_t t) {
3048 const char *x;
3049
3050 x = format_timestamp(buf, l, t);
3051 if (x)
3052 return x;
3053 return " --- ";
3054 }
3055
3056 void journal_file_print_header(JournalFile *f) {
3057 char a[33], b[33], c[33], d[33];
3058 char x[FORMAT_TIMESTAMP_MAX], y[FORMAT_TIMESTAMP_MAX], z[FORMAT_TIMESTAMP_MAX];
3059 struct stat st;
3060 char bytes[FORMAT_BYTES_MAX];
3061
3062 assert(f);
3063 assert(f->header);
3064
3065 printf("File Path: %s\n"
3066 "File ID: %s\n"
3067 "Machine ID: %s\n"
3068 "Boot ID: %s\n"
3069 "Sequential Number ID: %s\n"
3070 "State: %s\n"
3071 "Compatible Flags:%s%s\n"
3072 "Incompatible Flags:%s%s%s\n"
3073 "Header size: %"PRIu64"\n"
3074 "Arena size: %"PRIu64"\n"
3075 "Data Hash Table Size: %"PRIu64"\n"
3076 "Field Hash Table Size: %"PRIu64"\n"
3077 "Rotate Suggested: %s\n"
3078 "Head Sequential Number: %"PRIu64" (%"PRIx64")\n"
3079 "Tail Sequential Number: %"PRIu64" (%"PRIx64")\n"
3080 "Head Realtime Timestamp: %s (%"PRIx64")\n"
3081 "Tail Realtime Timestamp: %s (%"PRIx64")\n"
3082 "Tail Monotonic Timestamp: %s (%"PRIx64")\n"
3083 "Objects: %"PRIu64"\n"
3084 "Entry Objects: %"PRIu64"\n",
3085 f->path,
3086 sd_id128_to_string(f->header->file_id, a),
3087 sd_id128_to_string(f->header->machine_id, b),
3088 sd_id128_to_string(f->header->boot_id, c),
3089 sd_id128_to_string(f->header->seqnum_id, d),
3090 f->header->state == STATE_OFFLINE ? "OFFLINE" :
3091 f->header->state == STATE_ONLINE ? "ONLINE" :
3092 f->header->state == STATE_ARCHIVED ? "ARCHIVED" : "UNKNOWN",
3093 JOURNAL_HEADER_SEALED(f->header) ? " SEALED" : "",
3094 (le32toh(f->header->compatible_flags) & ~HEADER_COMPATIBLE_ANY) ? " ???" : "",
3095 JOURNAL_HEADER_COMPRESSED_XZ(f->header) ? " COMPRESSED-XZ" : "",
3096 JOURNAL_HEADER_COMPRESSED_LZ4(f->header) ? " COMPRESSED-LZ4" : "",
3097 (le32toh(f->header->incompatible_flags) & ~HEADER_INCOMPATIBLE_ANY) ? " ???" : "",
3098 le64toh(f->header->header_size),
3099 le64toh(f->header->arena_size),
3100 le64toh(f->header->data_hash_table_size) / sizeof(HashItem),
3101 le64toh(f->header->field_hash_table_size) / sizeof(HashItem),
3102 yes_no(journal_file_rotate_suggested(f, 0)),
3103 le64toh(f->header->head_entry_seqnum), le64toh(f->header->head_entry_seqnum),
3104 le64toh(f->header->tail_entry_seqnum), le64toh(f->header->tail_entry_seqnum),
3105 format_timestamp_safe(x, sizeof(x), le64toh(f->header->head_entry_realtime)), le64toh(f->header->head_entry_realtime),
3106 format_timestamp_safe(y, sizeof(y), le64toh(f->header->tail_entry_realtime)), le64toh(f->header->tail_entry_realtime),
3107 format_timespan(z, sizeof(z), le64toh(f->header->tail_entry_monotonic), USEC_PER_MSEC), le64toh(f->header->tail_entry_monotonic),
3108 le64toh(f->header->n_objects),
3109 le64toh(f->header->n_entries));
3110
3111 if (JOURNAL_HEADER_CONTAINS(f->header, n_data))
3112 printf("Data Objects: %"PRIu64"\n"
3113 "Data Hash Table Fill: %.1f%%\n",
3114 le64toh(f->header->n_data),
3115 100.0 * (double) le64toh(f->header->n_data) / ((double) (le64toh(f->header->data_hash_table_size) / sizeof(HashItem))));
3116
3117 if (JOURNAL_HEADER_CONTAINS(f->header, n_fields))
3118 printf("Field Objects: %"PRIu64"\n"
3119 "Field Hash Table Fill: %.1f%%\n",
3120 le64toh(f->header->n_fields),
3121 100.0 * (double) le64toh(f->header->n_fields) / ((double) (le64toh(f->header->field_hash_table_size) / sizeof(HashItem))));
3122
3123 if (JOURNAL_HEADER_CONTAINS(f->header, n_tags))
3124 printf("Tag Objects: %"PRIu64"\n",
3125 le64toh(f->header->n_tags));
3126 if (JOURNAL_HEADER_CONTAINS(f->header, n_entry_arrays))
3127 printf("Entry Array Objects: %"PRIu64"\n",
3128 le64toh(f->header->n_entry_arrays));
3129
3130 if (fstat(f->fd, &st) >= 0)
3131 printf("Disk usage: %s\n", format_bytes(bytes, sizeof(bytes), (uint64_t) st.st_blocks * 512ULL));
3132 }
3133
3134 static int journal_file_warn_btrfs(JournalFile *f) {
3135 unsigned attrs;
3136 int r;
3137
3138 assert(f);
3139
3140 /* Before we write anything, check if the COW logic is turned
3141 * off on btrfs. Given our write pattern that is quite
3142 * unfriendly to COW file systems this should greatly improve
3143 * performance on COW file systems, such as btrfs, at the
3144 * expense of data integrity features (which shouldn't be too
3145 * bad, given that we do our own checksumming). */
3146
3147 r = btrfs_is_filesystem(f->fd);
3148 if (r < 0)
3149 return log_warning_errno(r, "Failed to determine if journal is on btrfs: %m");
3150 if (!r)
3151 return 0;
3152
3153 r = read_attr_fd(f->fd, &attrs);
3154 if (r < 0)
3155 return log_warning_errno(r, "Failed to read file attributes: %m");
3156
3157 if (attrs & FS_NOCOW_FL) {
3158 log_debug("Detected btrfs file system with copy-on-write disabled, all is good.");
3159 return 0;
3160 }
3161
3162 log_notice("Creating journal file %s on a btrfs file system, and copy-on-write is enabled. "
3163 "This is likely to slow down journal access substantially, please consider turning "
3164 "off the copy-on-write file attribute on the journal directory, using chattr +C.", f->path);
3165
3166 return 1;
3167 }
3168
3169 int journal_file_open(
3170 int fd,
3171 const char *fname,
3172 int flags,
3173 mode_t mode,
3174 bool compress,
3175 uint64_t compress_threshold_bytes,
3176 bool seal,
3177 JournalMetrics *metrics,
3178 MMapCache *mmap_cache,
3179 Set *deferred_closes,
3180 JournalFile *template,
3181 JournalFile **ret) {
3182
3183 bool newly_created = false;
3184 JournalFile *f;
3185 void *h;
3186 int r;
3187 char bytes[FORMAT_BYTES_MAX];
3188
3189 assert(ret);
3190 assert(fd >= 0 || fname);
3191
3192 if (!IN_SET((flags & O_ACCMODE), O_RDONLY, O_RDWR))
3193 return -EINVAL;
3194
3195 if (fname && (flags & O_CREAT) && !endswith(fname, ".journal"))
3196 return -EINVAL;
3197
3198 f = new(JournalFile, 1);
3199 if (!f)
3200 return -ENOMEM;
3201
3202 *f = (JournalFile) {
3203 .fd = fd,
3204 .mode = mode,
3205
3206 .flags = flags,
3207 .prot = prot_from_flags(flags),
3208 .writable = (flags & O_ACCMODE) != O_RDONLY,
3209
3210 #if HAVE_LZ4
3211 .compress_lz4 = compress,
3212 #elif HAVE_XZ
3213 .compress_xz = compress,
3214 #endif
3215 .compress_threshold_bytes = compress_threshold_bytes == (uint64_t) -1 ?
3216 DEFAULT_COMPRESS_THRESHOLD :
3217 MAX(MIN_COMPRESS_THRESHOLD, compress_threshold_bytes),
3218 #if HAVE_GCRYPT
3219 .seal = seal,
3220 #endif
3221 };
3222
3223 log_debug("Journal effective settings seal=%s compress=%s compress_threshold_bytes=%s",
3224 yes_no(f->seal), yes_no(JOURNAL_FILE_COMPRESS(f)),
3225 format_bytes(bytes, sizeof(bytes), f->compress_threshold_bytes));
3226
3227 if (mmap_cache)
3228 f->mmap = mmap_cache_ref(mmap_cache);
3229 else {
3230 f->mmap = mmap_cache_new();
3231 if (!f->mmap) {
3232 r = -ENOMEM;
3233 goto fail;
3234 }
3235 }
3236
3237 if (fname) {
3238 f->path = strdup(fname);
3239 if (!f->path) {
3240 r = -ENOMEM;
3241 goto fail;
3242 }
3243 } else {
3244 assert(fd >= 0);
3245
3246 /* If we don't know the path, fill in something explanatory and vaguely useful */
3247 if (asprintf(&f->path, "/proc/self/%i", fd) < 0) {
3248 r = -ENOMEM;
3249 goto fail;
3250 }
3251 }
3252
3253 f->chain_cache = ordered_hashmap_new(&uint64_hash_ops);
3254 if (!f->chain_cache) {
3255 r = -ENOMEM;
3256 goto fail;
3257 }
3258
3259 if (f->fd < 0) {
3260 /* We pass O_NONBLOCK here, so that in case somebody pointed us to some character device node or FIFO
3261 * or so, we likely fail quickly than block for long. For regular files O_NONBLOCK has no effect, hence
3262 * it doesn't hurt in that case. */
3263
3264 f->fd = open(f->path, f->flags|O_CLOEXEC|O_NONBLOCK, f->mode);
3265 if (f->fd < 0) {
3266 r = -errno;
3267 goto fail;
3268 }
3269
3270 /* fds we opened here by us should also be closed by us. */
3271 f->close_fd = true;
3272
3273 r = fd_nonblock(f->fd, false);
3274 if (r < 0)
3275 goto fail;
3276 }
3277
3278 f->cache_fd = mmap_cache_add_fd(f->mmap, f->fd);
3279 if (!f->cache_fd) {
3280 r = -ENOMEM;
3281 goto fail;
3282 }
3283
3284 r = journal_file_fstat(f);
3285 if (r < 0)
3286 goto fail;
3287
3288 if (f->last_stat.st_size == 0 && f->writable) {
3289
3290 (void) journal_file_warn_btrfs(f);
3291
3292 /* Let's attach the creation time to the journal file, so that the vacuuming code knows the age of this
3293 * file even if the file might end up corrupted one day... Ideally we'd just use the creation time many
3294 * file systems maintain for each file, but the API to query this is very new, hence let's emulate this
3295 * via extended attributes. If extended attributes are not supported we'll just skip this, and rely
3296 * solely on mtime/atime/ctime of the file. */
3297 (void) fd_setcrtime(f->fd, 0);
3298
3299 #if HAVE_GCRYPT
3300 /* Try to load the FSPRG state, and if we can't, then
3301 * just don't do sealing */
3302 if (f->seal) {
3303 r = journal_file_fss_load(f);
3304 if (r < 0)
3305 f->seal = false;
3306 }
3307 #endif
3308
3309 r = journal_file_init_header(f, template);
3310 if (r < 0)
3311 goto fail;
3312
3313 r = journal_file_fstat(f);
3314 if (r < 0)
3315 goto fail;
3316
3317 newly_created = true;
3318 }
3319
3320 if (f->last_stat.st_size < (off_t) HEADER_SIZE_MIN) {
3321 r = -ENODATA;
3322 goto fail;
3323 }
3324
3325 r = mmap_cache_get(f->mmap, f->cache_fd, f->prot, CONTEXT_HEADER, true, 0, PAGE_ALIGN(sizeof(Header)), &f->last_stat, &h, NULL);
3326 if (r == -EINVAL) {
3327 /* Some file systems (jffs2 or p9fs) don't support mmap() properly (or only read-only
3328 * mmap()), and return EINVAL in that case. Let's propagate that as a more recognizable error
3329 * code. */
3330 r = -EAFNOSUPPORT;
3331 goto fail;
3332 }
3333 if (r < 0)
3334 goto fail;
3335
3336 f->header = h;
3337
3338 if (!newly_created) {
3339 set_clear_with_destructor(deferred_closes, journal_file_close);
3340
3341 r = journal_file_verify_header(f);
3342 if (r < 0)
3343 goto fail;
3344 }
3345
3346 #if HAVE_GCRYPT
3347 if (!newly_created && f->writable) {
3348 r = journal_file_fss_load(f);
3349 if (r < 0)
3350 goto fail;
3351 }
3352 #endif
3353
3354 if (f->writable) {
3355 if (metrics) {
3356 journal_default_metrics(metrics, f->fd);
3357 f->metrics = *metrics;
3358 } else if (template)
3359 f->metrics = template->metrics;
3360
3361 r = journal_file_refresh_header(f);
3362 if (r < 0)
3363 goto fail;
3364 }
3365
3366 #if HAVE_GCRYPT
3367 r = journal_file_hmac_setup(f);
3368 if (r < 0)
3369 goto fail;
3370 #endif
3371
3372 if (newly_created) {
3373 r = journal_file_setup_field_hash_table(f);
3374 if (r < 0)
3375 goto fail;
3376
3377 r = journal_file_setup_data_hash_table(f);
3378 if (r < 0)
3379 goto fail;
3380
3381 #if HAVE_GCRYPT
3382 r = journal_file_append_first_tag(f);
3383 if (r < 0)
3384 goto fail;
3385 #endif
3386 }
3387
3388 if (mmap_cache_got_sigbus(f->mmap, f->cache_fd)) {
3389 r = -EIO;
3390 goto fail;
3391 }
3392
3393 if (template && template->post_change_timer) {
3394 r = journal_file_enable_post_change_timer(
3395 f,
3396 sd_event_source_get_event(template->post_change_timer),
3397 template->post_change_timer_period);
3398
3399 if (r < 0)
3400 goto fail;
3401 }
3402
3403 /* The file is opened now successfully, thus we take possession of any passed in fd. */
3404 f->close_fd = true;
3405
3406 *ret = f;
3407 return 0;
3408
3409 fail:
3410 if (f->cache_fd && mmap_cache_got_sigbus(f->mmap, f->cache_fd))
3411 r = -EIO;
3412
3413 (void) journal_file_close(f);
3414
3415 return r;
3416 }
3417
3418 int journal_file_archive(JournalFile *f) {
3419 _cleanup_free_ char *p = NULL;
3420
3421 assert(f);
3422
3423 if (!f->writable)
3424 return -EINVAL;
3425
3426 /* Is this a journal file that was passed to us as fd? If so, we synthesized a path name for it, and we refuse
3427 * rotation, since we don't know the actual path, and couldn't rename the file hence. */
3428 if (path_startswith(f->path, "/proc/self/fd"))
3429 return -EINVAL;
3430
3431 if (!endswith(f->path, ".journal"))
3432 return -EINVAL;
3433
3434 if (asprintf(&p, "%.*s@" SD_ID128_FORMAT_STR "-%016"PRIx64"-%016"PRIx64".journal",
3435 (int) strlen(f->path) - 8, f->path,
3436 SD_ID128_FORMAT_VAL(f->header->seqnum_id),
3437 le64toh(f->header->head_entry_seqnum),
3438 le64toh(f->header->head_entry_realtime)) < 0)
3439 return -ENOMEM;
3440
3441 /* Try to rename the file to the archived version. If the file already was deleted, we'll get ENOENT, let's
3442 * ignore that case. */
3443 if (rename(f->path, p) < 0 && errno != ENOENT)
3444 return -errno;
3445
3446 /* Sync the rename to disk */
3447 (void) fsync_directory_of_file(f->fd);
3448
3449 /* Set as archive so offlining commits w/state=STATE_ARCHIVED. Previously we would set old_file->header->state
3450 * to STATE_ARCHIVED directly here, but journal_file_set_offline() short-circuits when state != STATE_ONLINE,
3451 * which would result in the rotated journal never getting fsync() called before closing. Now we simply queue
3452 * the archive state by setting an archive bit, leaving the state as STATE_ONLINE so proper offlining
3453 * occurs. */
3454 f->archive = true;
3455
3456 /* Currently, btrfs is not very good with out write patterns and fragments heavily. Let's defrag our journal
3457 * files when we archive them */
3458 f->defrag_on_close = true;
3459
3460 return 0;
3461 }
3462
3463 JournalFile* journal_initiate_close(
3464 JournalFile *f,
3465 Set *deferred_closes) {
3466
3467 int r;
3468
3469 assert(f);
3470
3471 if (deferred_closes) {
3472
3473 r = set_put(deferred_closes, f);
3474 if (r < 0)
3475 log_debug_errno(r, "Failed to add file to deferred close set, closing immediately.");
3476 else {
3477 (void) journal_file_set_offline(f, false);
3478 return NULL;
3479 }
3480 }
3481
3482 return journal_file_close(f);
3483 }
3484
3485 int journal_file_rotate(
3486 JournalFile **f,
3487 bool compress,
3488 uint64_t compress_threshold_bytes,
3489 bool seal,
3490 Set *deferred_closes) {
3491
3492 JournalFile *new_file = NULL;
3493 int r;
3494
3495 assert(f);
3496 assert(*f);
3497
3498 r = journal_file_archive(*f);
3499 if (r < 0)
3500 return r;
3501
3502 r = journal_file_open(
3503 -1,
3504 (*f)->path,
3505 (*f)->flags,
3506 (*f)->mode,
3507 compress,
3508 compress_threshold_bytes,
3509 seal,
3510 NULL, /* metrics */
3511 (*f)->mmap,
3512 deferred_closes,
3513 *f, /* template */
3514 &new_file);
3515
3516 journal_initiate_close(*f, deferred_closes);
3517 *f = new_file;
3518
3519 return r;
3520 }
3521
3522 int journal_file_dispose(int dir_fd, const char *fname) {
3523 _cleanup_free_ char *p = NULL;
3524 _cleanup_close_ int fd = -1;
3525
3526 assert(fname);
3527
3528 /* Renames a journal file to *.journal~, i.e. to mark it as corruped or otherwise uncleanly shutdown. Note that
3529 * this is done without looking into the file or changing any of its contents. The idea is that this is called
3530 * whenever something is suspicious and we want to move the file away and make clear that it is not accessed
3531 * for writing anymore. */
3532
3533 if (!endswith(fname, ".journal"))
3534 return -EINVAL;
3535
3536 if (asprintf(&p, "%.*s@%016" PRIx64 "-%016" PRIx64 ".journal~",
3537 (int) strlen(fname) - 8, fname,
3538 now(CLOCK_REALTIME),
3539 random_u64()) < 0)
3540 return -ENOMEM;
3541
3542 if (renameat(dir_fd, fname, dir_fd, p) < 0)
3543 return -errno;
3544
3545 /* btrfs doesn't cope well with our write pattern and fragments heavily. Let's defrag all files we rotate */
3546 fd = openat(dir_fd, p, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW);
3547 if (fd < 0)
3548 log_debug_errno(errno, "Failed to open file for defragmentation/FS_NOCOW_FL, ignoring: %m");
3549 else {
3550 (void) chattr_fd(fd, 0, FS_NOCOW_FL, NULL);
3551 (void) btrfs_defrag_fd(fd);
3552 }
3553
3554 return 0;
3555 }
3556
3557 int journal_file_open_reliably(
3558 const char *fname,
3559 int flags,
3560 mode_t mode,
3561 bool compress,
3562 uint64_t compress_threshold_bytes,
3563 bool seal,
3564 JournalMetrics *metrics,
3565 MMapCache *mmap_cache,
3566 Set *deferred_closes,
3567 JournalFile *template,
3568 JournalFile **ret) {
3569
3570 int r;
3571
3572 r = journal_file_open(-1, fname, flags, mode, compress, compress_threshold_bytes, seal, metrics, mmap_cache,
3573 deferred_closes, template, ret);
3574 if (!IN_SET(r,
3575 -EBADMSG, /* Corrupted */
3576 -ENODATA, /* Truncated */
3577 -EHOSTDOWN, /* Other machine */
3578 -EPROTONOSUPPORT, /* Incompatible feature */
3579 -EBUSY, /* Unclean shutdown */
3580 -ESHUTDOWN, /* Already archived */
3581 -EIO, /* IO error, including SIGBUS on mmap */
3582 -EIDRM, /* File has been deleted */
3583 -ETXTBSY)) /* File is from the future */
3584 return r;
3585
3586 if ((flags & O_ACCMODE) == O_RDONLY)
3587 return r;
3588
3589 if (!(flags & O_CREAT))
3590 return r;
3591
3592 if (!endswith(fname, ".journal"))
3593 return r;
3594
3595 /* The file is corrupted. Rotate it away and try it again (but only once) */
3596 log_warning_errno(r, "File %s corrupted or uncleanly shut down, renaming and replacing.", fname);
3597
3598 r = journal_file_dispose(AT_FDCWD, fname);
3599 if (r < 0)
3600 return r;
3601
3602 return journal_file_open(-1, fname, flags, mode, compress, compress_threshold_bytes, seal, metrics, mmap_cache,
3603 deferred_closes, template, ret);
3604 }
3605
3606 int journal_file_copy_entry(JournalFile *from, JournalFile *to, Object *o, uint64_t p) {
3607 uint64_t i, n;
3608 uint64_t q, xor_hash = 0;
3609 int r;
3610 EntryItem *items;
3611 dual_timestamp ts;
3612 const sd_id128_t *boot_id;
3613
3614 assert(from);
3615 assert(to);
3616 assert(o);
3617 assert(p);
3618
3619 if (!to->writable)
3620 return -EPERM;
3621
3622 ts.monotonic = le64toh(o->entry.monotonic);
3623 ts.realtime = le64toh(o->entry.realtime);
3624 boot_id = &o->entry.boot_id;
3625
3626 n = journal_file_entry_n_items(o);
3627 /* alloca() can't take 0, hence let's allocate at least one */
3628 items = newa(EntryItem, MAX(1u, n));
3629
3630 for (i = 0; i < n; i++) {
3631 uint64_t l, h;
3632 le64_t le_hash;
3633 size_t t;
3634 void *data;
3635 Object *u;
3636
3637 q = le64toh(o->entry.items[i].object_offset);
3638 le_hash = o->entry.items[i].hash;
3639
3640 r = journal_file_move_to_object(from, OBJECT_DATA, q, &o);
3641 if (r < 0)
3642 return r;
3643
3644 if (le_hash != o->data.hash)
3645 return -EBADMSG;
3646
3647 l = le64toh(o->object.size) - offsetof(Object, data.payload);
3648 t = (size_t) l;
3649
3650 /* We hit the limit on 32bit machines */
3651 if ((uint64_t) t != l)
3652 return -E2BIG;
3653
3654 if (o->object.flags & OBJECT_COMPRESSION_MASK) {
3655 #if HAVE_XZ || HAVE_LZ4
3656 size_t rsize = 0;
3657
3658 r = decompress_blob(o->object.flags & OBJECT_COMPRESSION_MASK,
3659 o->data.payload, l, &from->compress_buffer, &from->compress_buffer_size, &rsize, 0);
3660 if (r < 0)
3661 return r;
3662
3663 data = from->compress_buffer;
3664 l = rsize;
3665 #else
3666 return -EPROTONOSUPPORT;
3667 #endif
3668 } else
3669 data = o->data.payload;
3670
3671 r = journal_file_append_data(to, data, l, &u, &h);
3672 if (r < 0)
3673 return r;
3674
3675 xor_hash ^= le64toh(u->data.hash);
3676 items[i].object_offset = htole64(h);
3677 items[i].hash = u->data.hash;
3678
3679 r = journal_file_move_to_object(from, OBJECT_ENTRY, p, &o);
3680 if (r < 0)
3681 return r;
3682 }
3683
3684 r = journal_file_append_entry_internal(to, &ts, boot_id, xor_hash, items, n,
3685 NULL, NULL, NULL);
3686
3687 if (mmap_cache_got_sigbus(to->mmap, to->cache_fd))
3688 return -EIO;
3689
3690 return r;
3691 }
3692
3693 void journal_reset_metrics(JournalMetrics *m) {
3694 assert(m);
3695
3696 /* Set everything to "pick automatic values". */
3697
3698 *m = (JournalMetrics) {
3699 .min_use = (uint64_t) -1,
3700 .max_use = (uint64_t) -1,
3701 .min_size = (uint64_t) -1,
3702 .max_size = (uint64_t) -1,
3703 .keep_free = (uint64_t) -1,
3704 .n_max_files = (uint64_t) -1,
3705 };
3706 }
3707
3708 void journal_default_metrics(JournalMetrics *m, int fd) {
3709 char a[FORMAT_BYTES_MAX], b[FORMAT_BYTES_MAX], c[FORMAT_BYTES_MAX], d[FORMAT_BYTES_MAX], e[FORMAT_BYTES_MAX];
3710 struct statvfs ss;
3711 uint64_t fs_size;
3712
3713 assert(m);
3714 assert(fd >= 0);
3715
3716 if (fstatvfs(fd, &ss) >= 0)
3717 fs_size = ss.f_frsize * ss.f_blocks;
3718 else {
3719 log_debug_errno(errno, "Failed to determine disk size: %m");
3720 fs_size = 0;
3721 }
3722
3723 if (m->max_use == (uint64_t) -1) {
3724
3725 if (fs_size > 0) {
3726 m->max_use = PAGE_ALIGN(fs_size / 10); /* 10% of file system size */
3727
3728 if (m->max_use > DEFAULT_MAX_USE_UPPER)
3729 m->max_use = DEFAULT_MAX_USE_UPPER;
3730
3731 if (m->max_use < DEFAULT_MAX_USE_LOWER)
3732 m->max_use = DEFAULT_MAX_USE_LOWER;
3733 } else
3734 m->max_use = DEFAULT_MAX_USE_LOWER;
3735 } else {
3736 m->max_use = PAGE_ALIGN(m->max_use);
3737
3738 if (m->max_use != 0 && m->max_use < JOURNAL_FILE_SIZE_MIN*2)
3739 m->max_use = JOURNAL_FILE_SIZE_MIN*2;
3740 }
3741
3742 if (m->min_use == (uint64_t) -1)
3743 m->min_use = DEFAULT_MIN_USE;
3744
3745 if (m->min_use > m->max_use)
3746 m->min_use = m->max_use;
3747
3748 if (m->max_size == (uint64_t) -1) {
3749 m->max_size = PAGE_ALIGN(m->max_use / 8); /* 8 chunks */
3750
3751 if (m->max_size > DEFAULT_MAX_SIZE_UPPER)
3752 m->max_size = DEFAULT_MAX_SIZE_UPPER;
3753 } else
3754 m->max_size = PAGE_ALIGN(m->max_size);
3755
3756 if (m->max_size != 0) {
3757 if (m->max_size < JOURNAL_FILE_SIZE_MIN)
3758 m->max_size = JOURNAL_FILE_SIZE_MIN;
3759
3760 if (m->max_use != 0 && m->max_size*2 > m->max_use)
3761 m->max_use = m->max_size*2;
3762 }
3763
3764 if (m->min_size == (uint64_t) -1)
3765 m->min_size = JOURNAL_FILE_SIZE_MIN;
3766 else {
3767 m->min_size = PAGE_ALIGN(m->min_size);
3768
3769 if (m->min_size < JOURNAL_FILE_SIZE_MIN)
3770 m->min_size = JOURNAL_FILE_SIZE_MIN;
3771
3772 if (m->max_size != 0 && m->min_size > m->max_size)
3773 m->max_size = m->min_size;
3774 }
3775
3776 if (m->keep_free == (uint64_t) -1) {
3777
3778 if (fs_size > 0) {
3779 m->keep_free = PAGE_ALIGN(fs_size * 3 / 20); /* 15% of file system size */
3780
3781 if (m->keep_free > DEFAULT_KEEP_FREE_UPPER)
3782 m->keep_free = DEFAULT_KEEP_FREE_UPPER;
3783
3784 } else
3785 m->keep_free = DEFAULT_KEEP_FREE;
3786 }
3787
3788 if (m->n_max_files == (uint64_t) -1)
3789 m->n_max_files = DEFAULT_N_MAX_FILES;
3790
3791 log_debug("Fixed min_use=%s max_use=%s max_size=%s min_size=%s keep_free=%s n_max_files=%" PRIu64,
3792 format_bytes(a, sizeof(a), m->min_use),
3793 format_bytes(b, sizeof(b), m->max_use),
3794 format_bytes(c, sizeof(c), m->max_size),
3795 format_bytes(d, sizeof(d), m->min_size),
3796 format_bytes(e, sizeof(e), m->keep_free),
3797 m->n_max_files);
3798 }
3799
3800 int journal_file_get_cutoff_realtime_usec(JournalFile *f, usec_t *from, usec_t *to) {
3801 assert(f);
3802 assert(f->header);
3803 assert(from || to);
3804
3805 if (from) {
3806 if (f->header->head_entry_realtime == 0)
3807 return -ENOENT;
3808
3809 *from = le64toh(f->header->head_entry_realtime);
3810 }
3811
3812 if (to) {
3813 if (f->header->tail_entry_realtime == 0)
3814 return -ENOENT;
3815
3816 *to = le64toh(f->header->tail_entry_realtime);
3817 }
3818
3819 return 1;
3820 }
3821
3822 int journal_file_get_cutoff_monotonic_usec(JournalFile *f, sd_id128_t boot_id, usec_t *from, usec_t *to) {
3823 Object *o;
3824 uint64_t p;
3825 int r;
3826
3827 assert(f);
3828 assert(from || to);
3829
3830 r = find_data_object_by_boot_id(f, boot_id, &o, &p);
3831 if (r <= 0)
3832 return r;
3833
3834 if (le64toh(o->data.n_entries) <= 0)
3835 return 0;
3836
3837 if (from) {
3838 r = journal_file_move_to_object(f, OBJECT_ENTRY, le64toh(o->data.entry_offset), &o);
3839 if (r < 0)
3840 return r;
3841
3842 *from = le64toh(o->entry.monotonic);
3843 }
3844
3845 if (to) {
3846 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
3847 if (r < 0)
3848 return r;
3849
3850 r = generic_array_get_plus_one(f,
3851 le64toh(o->data.entry_offset),
3852 le64toh(o->data.entry_array_offset),
3853 le64toh(o->data.n_entries)-1,
3854 &o, NULL);
3855 if (r <= 0)
3856 return r;
3857
3858 *to = le64toh(o->entry.monotonic);
3859 }
3860
3861 return 1;
3862 }
3863
3864 bool journal_file_rotate_suggested(JournalFile *f, usec_t max_file_usec) {
3865 assert(f);
3866 assert(f->header);
3867
3868 /* If we gained new header fields we gained new features,
3869 * hence suggest a rotation */
3870 if (le64toh(f->header->header_size) < sizeof(Header)) {
3871 log_debug("%s uses an outdated header, suggesting rotation.", f->path);
3872 return true;
3873 }
3874
3875 /* Let's check if the hash tables grew over a certain fill
3876 * level (75%, borrowing this value from Java's hash table
3877 * implementation), and if so suggest a rotation. To calculate
3878 * the fill level we need the n_data field, which only exists
3879 * in newer versions. */
3880
3881 if (JOURNAL_HEADER_CONTAINS(f->header, n_data))
3882 if (le64toh(f->header->n_data) * 4ULL > (le64toh(f->header->data_hash_table_size) / sizeof(HashItem)) * 3ULL) {
3883 log_debug("Data hash table of %s has a fill level at %.1f (%"PRIu64" of %"PRIu64" items, %llu file size, %"PRIu64" bytes per hash table item), suggesting rotation.",
3884 f->path,
3885 100.0 * (double) le64toh(f->header->n_data) / ((double) (le64toh(f->header->data_hash_table_size) / sizeof(HashItem))),
3886 le64toh(f->header->n_data),
3887 le64toh(f->header->data_hash_table_size) / sizeof(HashItem),
3888 (unsigned long long) f->last_stat.st_size,
3889 f->last_stat.st_size / le64toh(f->header->n_data));
3890 return true;
3891 }
3892
3893 if (JOURNAL_HEADER_CONTAINS(f->header, n_fields))
3894 if (le64toh(f->header->n_fields) * 4ULL > (le64toh(f->header->field_hash_table_size) / sizeof(HashItem)) * 3ULL) {
3895 log_debug("Field hash table of %s has a fill level at %.1f (%"PRIu64" of %"PRIu64" items), suggesting rotation.",
3896 f->path,
3897 100.0 * (double) le64toh(f->header->n_fields) / ((double) (le64toh(f->header->field_hash_table_size) / sizeof(HashItem))),
3898 le64toh(f->header->n_fields),
3899 le64toh(f->header->field_hash_table_size) / sizeof(HashItem));
3900 return true;
3901 }
3902
3903 /* Are the data objects properly indexed by field objects? */
3904 if (JOURNAL_HEADER_CONTAINS(f->header, n_data) &&
3905 JOURNAL_HEADER_CONTAINS(f->header, n_fields) &&
3906 le64toh(f->header->n_data) > 0 &&
3907 le64toh(f->header->n_fields) == 0)
3908 return true;
3909
3910 if (max_file_usec > 0) {
3911 usec_t t, h;
3912
3913 h = le64toh(f->header->head_entry_realtime);
3914 t = now(CLOCK_REALTIME);
3915
3916 if (h > 0 && t > h + max_file_usec)
3917 return true;
3918 }
3919
3920 return false;
3921 }
Unnamed repository; edit this file 'description' to name the repository.