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