]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/journal/journal-file.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
man: move non-target units together (#6934)
[thirdparty/systemd.git] / src / journal / journal-file.c
CommitLineData
cec736d2
LP		 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
5430f7f2
LP		 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
cec736d2
LP		 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
5430f7f2 14 Lesser General Public License for more details.
cec736d2 15
5430f7f2 16 You should have received a copy of the GNU Lesser General Public License
cec736d2
LP		 17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
18***/
19
cec736d2 20#include <errno.h>
cec736d2 21#include <fcntl.h>
11689d2a 22#include <linux/fs.h>
ac2e41f5 23#include <pthread.h>
07630cea
LP		 24#include <stddef.h>
25#include <sys/mman.h>
26#include <sys/statvfs.h>
27#include <sys/uio.h>
28#include <unistd.h>
fb0951b0 29
b5efdb8a 30#include "alloc-util.h"
f27a3864 31#include "btrfs-util.h"
c8b3094d 32#include "chattr-util.h"
07630cea 33#include "compress.h"
3ffd4af2 34#include "fd-util.h"
0284adc6 35#include "journal-authenticate.h"
cec736d2
LP		 36#include "journal-def.h"
37#include "journal-file.h"
38#include "lookup3.h"
6bedfcbb 39#include "parse-util.h"
5d1ce257 40#include "path-util.h"
3df3e884 41#include "random-util.h"
7a24f3bf 42#include "sd-event.h"
b58c888f 43#include "set.h"
07630cea 44#include "string-util.h"
4761fd0f 45#include "strv.h"
89a5a90c 46#include "xattr-util.h"
cec736d2 47
4a92baf3
LP		 48#define DEFAULT_DATA_HASH_TABLE_SIZE (2047ULL*sizeof(HashItem))
49#define DEFAULT_FIELD_HASH_TABLE_SIZE (333ULL*sizeof(HashItem))
cec736d2 50
be19b7df 51#define COMPRESSION_SIZE_THRESHOLD (512ULL)
807e17f0 52
babfc091 53/* This is the minimum journal file size */
16098e93 54#define JOURNAL_FILE_SIZE_MIN (512ULL*1024ULL) /* 512 KiB */
babfc091
LP		 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
8580d1f7
LP		 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
babfc091 64/* This is the upper bound if we deduce max_size from max_use */
71100051 65#define DEFAULT_MAX_SIZE_UPPER (128ULL*1024ULL*1024ULL) /* 128 MiB */
babfc091
LP		 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
8580d1f7
LP		 75/* This is the default maximum number of journal files to keep around. */
76#define DEFAULT_N_MAX_FILES (100)
77
dca6219e
LP		 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))
cec736d2 80
a4bcff5b
LP		 81/* How many entries to keep in the entry array chain cache at max */
82#define CHAIN_CACHE_MAX 20
83
a676e665
LP		 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
2678031a
LP		 87/* Reread fstat() of the file for detecting deletions at least this often */
88#define LAST_STAT_REFRESH_USEC (5*USEC_PER_SEC)
89
fa6ac760
LP		 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
ac2e41f5
VC		 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(). */
96static void journal_file_set_offline_internal(JournalFile *f) {
26687bf8 97 assert(f);
ac2e41f5
VC		 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);
26687bf8 120
ac2e41f5
VC		 121 if (!__sync_bool_compare_and_swap(&f->offline_state, OFFLINE_SYNCING, OFFLINE_OFFLINING))
122 continue;
26687bf8 123
8eb85171 124 f->header->state = f->archive ? STATE_ARCHIVED : STATE_OFFLINE;
ac2e41f5
VC		 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
143static 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
151static 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;
26687bf8 164
be7cdd8e 165 if (mmap_cache_got_sigbus(f->mmap, f->cache_fd))
fa6ac760
LP		 166 return -EIO;
167
ac2e41f5
VC		 168 return 0;
169}
26687bf8 170
ac2e41f5
VC		 171/* Trigger a restart if the offline thread is mid-flight in a restartable state. */
172static 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;
26687bf8
OS		 193
194 default:
ac2e41f5
VC		 195 return false;
196 }
26687bf8
OS		 197 }
198}
199
ac2e41f5
VC		 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 */
210int journal_file_set_offline(JournalFile *f, bool wait) {
211 bool restarted;
212 int r;
213
26687bf8
OS		 214 assert(f);
215
216 if (!f->writable)
217 return -EPERM;
218
219 if (!(f->fd >= 0 && f->header))
220 return -EINVAL;
221
b8f99e27
VC		 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);
26687bf8 226
ac2e41f5
VC		 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 }
26687bf8 234
ac2e41f5
VC		 235 if (restarted)
236 return 0;
237
238 /* Initiate a new offline. */
239 f->offline_state = OFFLINE_SYNCING;
fa6ac760 240
ac2e41f5
VC		 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);
ec9ffa2c
VC		 245 if (r > 0) {
246 f->offline_state = OFFLINE_JOINED;
ac2e41f5 247 return -r;
ec9ffa2c 248 }
ac2e41f5
VC		 249 }
250
251 return 0;
252}
253
254static 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
ec251fe7 289 /* fall through */
ac2e41f5
VC		 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 }
26687bf8 302
be7cdd8e 303 if (mmap_cache_got_sigbus(f->mmap, f->cache_fd))
fa6ac760
LP		 304 return -EIO;
305
ac2e41f5
VC		 306 switch (f->header->state) {
307 case STATE_ONLINE:
308 return 0;
26687bf8 309
ac2e41f5
VC		 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 }
26687bf8
OS		 318}
319
b58c888f
VC		 320bool 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
804ae586 332JournalFile* journal_file_close(JournalFile *f) {
de190aef 333 assert(f);
cec736d2 334
feb12d3e 335#ifdef HAVE_GCRYPT
b0af6f41 336 /* Write the final tag */
43cd8794
FB		 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 }
feb12d3e 344#endif
b0af6f41 345
7a24f3bf
VC		 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
e167d7fd 353 (void) sd_event_source_set_enabled(f->post_change_timer, SD_EVENT_OFF);
7a24f3bf
VC		 354 sd_event_source_unref(f->post_change_timer);
355 }
356
ac2e41f5 357 journal_file_set_offline(f, true);
cec736d2 358
be7cdd8e
VC		 359 if (f->mmap && f->cache_fd)
360 mmap_cache_free_fd(f->mmap, f->cache_fd);
cec736d2 361
11689d2a
LP		 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
1ed8f8c1 370 (void) chattr_fd(f->fd, 0, FS_NOCOW_FL);
11689d2a
LP		 371 (void) btrfs_defrag_fd(f->fd);
372 }
f27a3864 373
5d1ce257
LP		 374 if (f->close_fd)
375 safe_close(f->fd);
cec736d2 376 free(f->path);
807e17f0 377
f649045c 378 mmap_cache_unref(f->mmap);
16e9f408 379
4743015d 380 ordered_hashmap_free_free(f->chain_cache);
a4bcff5b 381
d89c8fdf 382#if defined(HAVE_XZ) || defined(HAVE_LZ4)
807e17f0
LP		 383 free(f->compress_buffer);
384#endif
385
7560fffc 386#ifdef HAVE_GCRYPT
baed47c3
LP		 387 if (f->fss_file)
388 munmap(f->fss_file, PAGE_ALIGN(f->fss_file_size));
dc4ebc07 389 else
b7c9ae91
LP		 390 free(f->fsprg_state);
391
392 free(f->fsprg_seed);
7560fffc
LP		 393
394 if (f->hmac)
395 gcry_md_close(f->hmac);
396#endif
397
6b430fdb 398 return mfree(f);
cec736d2
LP		 399}
400
b58c888f
VC		 401void 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
0ac38b70 410static int journal_file_init_header(JournalFile *f, JournalFile *template) {
d89c8fdf 411 Header h = {};
cec736d2
LP		 412 ssize_t k;
413 int r;
414
415 assert(f);
416
7560fffc 417 memcpy(h.signature, HEADER_SIGNATURE, 8);
23b0b2b2 418 h.header_size = htole64(ALIGN64(sizeof(h)));
cec736d2 419
d89c8fdf
ZJS		 420 h.incompatible_flags |= htole32(
421 f->compress_xz * HEADER_INCOMPATIBLE_COMPRESSED_XZ |
422 f->compress_lz4 * HEADER_INCOMPATIBLE_COMPRESSED_LZ4);
7560fffc 423
d89c8fdf
ZJS		 424 h.compatible_flags = htole32(
425 f->seal * HEADER_COMPATIBLE_SEALED);
7560fffc 426
cec736d2
LP		 427 r = sd_id128_randomize(&h.file_id);
428 if (r < 0)
429 return r;
430
0ac38b70
LP		 431 if (template) {
432 h.seqnum_id = template->header->seqnum_id;
beec0085 433 h.tail_entry_seqnum = template->header->tail_entry_seqnum;
0ac38b70
LP		 434 } else
435 h.seqnum_id = h.file_id;
cec736d2
LP		 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
a0fe2a2d
LP		 447static 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
cec736d2 480static int journal_file_refresh_header(JournalFile *f) {
de190aef 481 sd_id128_t boot_id;
fa6ac760 482 int r;
cec736d2
LP		 483
484 assert(f);
c88cc6af 485 assert(f->header);
cec736d2
LP		 486
487 r = sd_id128_get_machine(&f->header->machine_id);
488 if (r < 0)
489 return r;
490
de190aef 491 r = sd_id128_get_boot(&boot_id);
cec736d2
LP		 492 if (r < 0)
493 return r;
494
de190aef
LP		 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
fa6ac760 500 r = journal_file_set_online(f);
b788cc23 501
7560fffc 502 /* Sync the online state to disk */
fb426037 503 (void) fsync(f->fd);
b788cc23 504
a0fe2a2d
LP		 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
fa6ac760 508 return r;
cec736d2
LP		 509}
510
4214009f
ZJS		 511static 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";
d89c8fdf
ZJS		 515 uint32_t flags;
516
4214009f
ZJS		 517 flags = le32toh(compatible ? f->header->compatible_flags : f->header->incompatible_flags);
518
519 if (flags & ~supported) {
520 if (flags & ~any)
4761fd0f 521 log_debug("Journal file %s has unknown %s flags 0x%"PRIx32,
4214009f
ZJS		 522 f->path, type, flags & ~any);
523 flags = (flags & any) & ~supported;
4761fd0f
ZJS		 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 }
4214009f
ZJS		 542 return true;
543 }
544
545 return false;
546}
547
548static int journal_file_verify_header(JournalFile *f) {
6f94e420
TS		 549 uint64_t arena_size, header_size;
550
cec736d2 551 assert(f);
c88cc6af 552 assert(f->header);
cec736d2 553
7560fffc 554 if (memcmp(f->header->signature, HEADER_SIGNATURE, 8))
cec736d2
LP		 555 return -EBADMSG;
556
4214009f
ZJS		 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))
cec736d2
LP		 560 return -EPROTONOSUPPORT;
561
4214009f
ZJS		 562 /* When open for writing we refuse to open files with compatible flags, too. */
563 if (f->writable && warn_wrong_flags(f, true))
d89c8fdf 564 return -EPROTONOSUPPORT;
7560fffc 565
db11ac1a
LP		 566 if (f->header->state >= _STATE_MAX)
567 return -EBADMSG;
568
6f94e420
TS		 569 header_size = le64toh(f->header->header_size);
570
dca6219e 571 /* The first addition was n_data, so check that we are at least this large */
6f94e420 572 if (header_size < HEADER_SIZE_MIN)
23b0b2b2
LP		 573 return -EBADMSG;
574
8088cbd3 575 if (JOURNAL_HEADER_SEALED(f->header) && !JOURNAL_HEADER_CONTAINS(f->header, n_entry_arrays))
beec0085
LP		 576 return -EBADMSG;
577
6f94e420
TS		 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)
db11ac1a
LP		 581 return -ENODATA;
582
6f94e420 583 if (le64toh(f->header->tail_object_offset) > header_size + arena_size)
db11ac1a
LP		 584 return -ENODATA;
585
7762e02b
LP		 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
cec736d2 592 if (f->writable) {
cec736d2 593 sd_id128_t machine_id;
ae739cc1 594 uint8_t state;
cec736d2
LP		 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
de190aef 604 state = f->header->state;
cec736d2 605
b288cdeb
ZJS		 606 if (state == STATE_ARCHIVED)
607 return -ESHUTDOWN; /* Already archived */
608 else if (state == STATE_ONLINE) {
71fa6f00
LP		 609 log_debug("Journal file %s is already online. Assuming unclean closing.", f->path);
610 return -EBUSY;
b288cdeb 611 } else if (state != STATE_OFFLINE) {
8facc349 612 log_debug("Journal file %s has unknown state %i.", f->path, state);
71fa6f00
LP		 613 return -EBUSY;
614 }
ae739cc1 615
5b3cc0c8
YN		 616 if (f->header->field_hash_table_size == 0 || f->header->data_hash_table_size == 0)
617 return -EBADMSG;
618
ae739cc1
LP		 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 }
cec736d2
LP		 626 }
627
d89c8fdf
ZJS		 628 f->compress_xz = JOURNAL_HEADER_COMPRESSED_XZ(f->header);
629 f->compress_lz4 = JOURNAL_HEADER_COMPRESSED_LZ4(f->header);
c586dbf1 630
f1889c91 631 f->seal = JOURNAL_HEADER_SEALED(f->header);
7560fffc 632
cec736d2
LP		 633 return 0;
634}
635
2678031a
LP		 636static 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
cec736d2 652static int journal_file_allocate(JournalFile *f, uint64_t offset, uint64_t size) {
eda4b58b 653 uint64_t old_size, new_size;
fec2aa2f 654 int r;
cec736d2
LP		 655
656 assert(f);
c88cc6af 657 assert(f->header);
cec736d2 658
cec736d2 659 /* We assume that this file is not sparse, and we know that
38ac38b2 660 * for sure, since we always call posix_fallocate()
cec736d2
LP		 661 * ourselves */
662
be7cdd8e 663 if (mmap_cache_got_sigbus(f->mmap, f->cache_fd))
fa6ac760
LP		 664 return -EIO;
665
cec736d2 666 old_size =
23b0b2b2 667 le64toh(f->header->header_size) +
cec736d2
LP		 668 le64toh(f->header->arena_size);
669
bc85bfee 670 new_size = PAGE_ALIGN(offset + size);
23b0b2b2
LP		 671 if (new_size < le64toh(f->header->header_size))
672 new_size = le64toh(f->header->header_size);
bc85bfee 673
2678031a
LP		 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. */
cec736d2 689
a676e665 690 if (f->metrics.max_size > 0 && new_size > f->metrics.max_size)
bc85bfee 691 return -E2BIG;
cec736d2 692
a676e665 693 if (new_size > f->metrics.min_size && f->metrics.keep_free > 0) {
cec736d2
LP		 694 struct statvfs svfs;
695
696 if (fstatvfs(f->fd, &svfs) >= 0) {
697 uint64_t available;
698
070052ab 699 available = LESS_BY((uint64_t) svfs.f_bfree * (uint64_t) svfs.f_bsize, f->metrics.keep_free);
cec736d2
LP		 700
701 if (new_size - old_size > available)
702 return -E2BIG;
703 }
704 }
705
eda4b58b
LP		 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
bc85bfee
LP		 711 /* Note that the glibc fallocate() fallback is very
712 inefficient, hence we try to minimize the allocation area
713 as we can. */
fec2aa2f
GV		 714 r = posix_fallocate(f->fd, old_size, new_size - old_size);
715 if (r != 0)
716 return -r;
cec736d2 717
23b0b2b2 718 f->header->arena_size = htole64(new_size - le64toh(f->header->header_size));
cec736d2 719
2678031a 720 return journal_file_fstat(f);
cec736d2
LP		 721}
722
78519831 723static unsigned type_to_context(ObjectType type) {
d3d3208f 724 /* One context for each type, plus one catch-all for the rest */
69adae51 725 assert_cc(_OBJECT_TYPE_MAX <= MMAP_CACHE_MAX_CONTEXTS);
fa6ac760 726 assert_cc(CONTEXT_HEADER < MMAP_CACHE_MAX_CONTEXTS);
d05089d8 727 return type > OBJECT_UNUSED && type < _OBJECT_TYPE_MAX ? type : 0;
d3d3208f
MS		 728}
729
b439282e 730static int journal_file_move_to(JournalFile *f, ObjectType type, bool keep_always, uint64_t offset, uint64_t size, void **ret, size_t *ret_size) {
2678031a
LP		 731 int r;
732
cec736d2 733 assert(f);
cec736d2
LP		 734 assert(ret);
735
7762e02b
LP		 736 if (size <= 0)
737 return -EINVAL;
738
2a59ea54 739 /* Avoid SIGBUS on invalid accesses */
4bbdcdb3
LP		 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
2678031a
LP		 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)
4bbdcdb3
LP		 749 return -EADDRNOTAVAIL;
750 }
751
b439282e 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);
cec736d2
LP		 753}
754
16e9f408
LP		 755static uint64_t minimum_header_size(Object *o) {
756
b8e891e6 757 static const uint64_t table[] = {
16e9f408
LP		 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
24754f36
TR		 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. */
775static 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,
10e8445b 784 le64toh(o->data.n_entries), offset);
24754f36
TR		 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
10e8445b
TR		 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))) {
24754f36
TR		 800 log_debug("Invalid offset, next_hash_offset="OFSfmt", next_field_offset="OFSfmt
801 ", entry_offset="OFSfmt", entry_array_offset="OFSfmt": %"PRIu64,
10e8445b
TR		 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),
24754f36
TR		 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
10e8445b
TR		 823 if (!VALID64(le64toh(o->field.next_hash_offset)) ||
824 !VALID64(le64toh(o->field.head_data_offset))) {
24754f36
TR		 825 log_debug(
826 "Invalid offset, next_hash_offset="OFSfmt
827 ", head_data_offset="OFSfmt": %"PRIu64,
10e8445b
TR		 828 le64toh(o->field.next_hash_offset),
829 le64toh(o->field.head_data_offset),
24754f36
TR		 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
10e8445b 903 if (!VALID64(le64toh(o->entry_array.next_entry_array_offset))) {
24754f36
TR		 904 log_debug(
905 "Invalid object entry array next_entry_array_offset: "OFSfmt": %"PRIu64,
10e8445b 906 le64toh(o->entry_array.next_entry_array_offset),
24754f36
TR		 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
10e8445b 922 if (!VALID_EPOCH(le64toh(o->tag.epoch))) {
24754f36
TR		 923 log_debug(
924 "Invalid object tag epoch: %"PRIu64": %"PRIu64,
10e8445b 925 le64toh(o->tag.epoch),
24754f36
TR		 926 offset);
927 return -EBADMSG;
928 }
929
930 break;
931 }
932
933 return 0;
934}
935
78519831 936int journal_file_move_to_object(JournalFile *f, ObjectType type, uint64_t offset, Object **ret) {
cec736d2
LP		 937 int r;
938 void *t;
b439282e 939 size_t tsize;
cec736d2
LP		 940 Object *o;
941 uint64_t s;
942
943 assert(f);
944 assert(ret);
945
db11ac1a 946 /* Objects may only be located at multiple of 64 bit */
202fd896
LP		 947 if (!VALID64(offset)) {
948 log_debug("Attempt to move to object at non-64bit boundary: %" PRIu64, offset);
bd30fdf2 949 return -EBADMSG;
202fd896 950 }
db11ac1a 951
50809d7a 952 /* Object may not be located in the file header */
202fd896
LP		 953 if (offset < le64toh(f->header->header_size)) {
954 log_debug("Attempt to move to object located in file header: %" PRIu64, offset);
50809d7a 955 return -EBADMSG;
202fd896 956 }
50809d7a 957
b439282e 958 r = journal_file_move_to(f, type, false, offset, sizeof(ObjectHeader), &t, &tsize);
cec736d2
LP		 959 if (r < 0)
960 return r;
961
962 o = (Object*) t;
963 s = le64toh(o->object.size);
964
1c69f096
LP		 965 if (s == 0) {
966 log_debug("Attempt to move to uninitialized object: %" PRIu64, offset);
967 return -EBADMSG;
968 }
202fd896
LP		 969 if (s < sizeof(ObjectHeader)) {
970 log_debug("Attempt to move to overly short object: %" PRIu64, offset);
cec736d2 971 return -EBADMSG;
202fd896 972 }
cec736d2 973
202fd896
LP		 974 if (o->object.type <= OBJECT_UNUSED) {
975 log_debug("Attempt to move to object with invalid type: %" PRIu64, offset);
16e9f408 976 return -EBADMSG;
202fd896 977 }
16e9f408 978
202fd896
LP		 979 if (s < minimum_header_size(o)) {
980 log_debug("Attempt to move to truncated object: %" PRIu64, offset);
16e9f408 981 return -EBADMSG;
202fd896 982 }
16e9f408 983
202fd896
LP		 984 if (type > OBJECT_UNUSED && o->object.type != type) {
985 log_debug("Attempt to move to object of unexpected type: %" PRIu64, offset);
cec736d2 986 return -EBADMSG;
202fd896 987 }
cec736d2 988
b439282e
VC		 989 if (s > tsize) {
990 r = journal_file_move_to(f, type, false, offset, s, &t, NULL);
cec736d2
LP		 991 if (r < 0)
992 return r;
993
994 o = (Object*) t;
995 }
996
24754f36
TR		 997 r = journal_file_check_object(f, offset, o);
998 if (r < 0)
999 return r;
1000
cec736d2
LP		 1001 *ret = o;
1002 return 0;
1003}
1004
d98cc1f2 1005static uint64_t journal_file_entry_seqnum(JournalFile *f, uint64_t *seqnum) {
cec736d2
LP		 1006 uint64_t r;
1007
1008 assert(f);
c88cc6af 1009 assert(f->header);
cec736d2 1010
beec0085 1011 r = le64toh(f->header->tail_entry_seqnum) + 1;
c2373f84
LP		 1012
1013 if (seqnum) {
de190aef 1014 /* If an external seqnum counter was passed, we update
c2373f84
LP		 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
beec0085 1024 f->header->tail_entry_seqnum = htole64(r);
cec736d2 1025
beec0085
LP		 1026 if (f->header->head_entry_seqnum == 0)
1027 f->header->head_entry_seqnum = htole64(r);
de190aef 1028
cec736d2
LP		 1029 return r;
1030}
1031
78519831 1032int journal_file_append_object(JournalFile *f, ObjectType type, uint64_t size, Object **ret, uint64_t *offset) {
cec736d2
LP		 1033 int r;
1034 uint64_t p;
1035 Object *tail, *o;
1036 void *t;
1037
1038 assert(f);
c88cc6af 1039 assert(f->header);
d05089d8 1040 assert(type > OBJECT_UNUSED && type < _OBJECT_TYPE_MAX);
cec736d2
LP		 1041 assert(size >= sizeof(ObjectHeader));
1042 assert(offset);
1043 assert(ret);
1044
26687bf8
OS		 1045 r = journal_file_set_online(f);
1046 if (r < 0)
1047 return r;
1048
cec736d2 1049 p = le64toh(f->header->tail_object_offset);
cec736d2 1050 if (p == 0)
23b0b2b2 1051 p = le64toh(f->header->header_size);
cec736d2 1052 else {
d05089d8 1053 r = journal_file_move_to_object(f, OBJECT_UNUSED, p, &tail);
cec736d2
LP		 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
b439282e 1064 r = journal_file_move_to(f, type, false, p, size, &t, NULL);
cec736d2
LP		 1065 if (r < 0)
1066 return r;
1067
1068 o = (Object*) t;
1069
1070 zero(o->object);
de190aef 1071 o->object.type = type;
cec736d2
LP		 1072 o->object.size = htole64(size);
1073
1074 f->header->tail_object_offset = htole64(p);
cec736d2
LP		 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
de190aef 1083static int journal_file_setup_data_hash_table(JournalFile *f) {
cec736d2
LP		 1084 uint64_t s, p;
1085 Object *o;
1086 int r;
1087
1088 assert(f);
c88cc6af 1089 assert(f->header);
cec736d2 1090
070052ab
LP		 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. */
4a92baf3 1095
dfabe643 1096 s = (f->metrics.max_size * 4 / 768 / 3) * sizeof(HashItem);
4a92baf3
LP		 1097 if (s < DEFAULT_DATA_HASH_TABLE_SIZE)
1098 s = DEFAULT_DATA_HASH_TABLE_SIZE;
1099
507f22bd 1100 log_debug("Reserving %"PRIu64" entries in hash table.", s / sizeof(HashItem));
4a92baf3 1101
de190aef
LP		 1102 r = journal_file_append_object(f,
1103 OBJECT_DATA_HASH_TABLE,
1104 offsetof(Object, hash_table.items) + s,
1105 &o, &p);
cec736d2
LP		 1106 if (r < 0)
1107 return r;
1108
29804cc1 1109 memzero(o->hash_table.items, s);
cec736d2 1110
de190aef
LP		 1111 f->header->data_hash_table_offset = htole64(p + offsetof(Object, hash_table.items));
1112 f->header->data_hash_table_size = htole64(s);
cec736d2
LP		 1113
1114 return 0;
1115}
1116
de190aef 1117static int journal_file_setup_field_hash_table(JournalFile *f) {
cec736d2
LP		 1118 uint64_t s, p;
1119 Object *o;
1120 int r;
1121
1122 assert(f);
c88cc6af 1123 assert(f->header);
cec736d2 1124
3c1668da
LP		 1125 /* We use a fixed size hash table for the fields as this
1126 * number should grow very slowly only */
1127
de190aef
LP		 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);
cec736d2
LP		 1133 if (r < 0)
1134 return r;
1135
29804cc1 1136 memzero(o->hash_table.items, s);
cec736d2 1137
de190aef
LP		 1138 f->header->field_hash_table_offset = htole64(p + offsetof(Object, hash_table.items));
1139 f->header->field_hash_table_size = htole64(s);
cec736d2
LP		 1140
1141 return 0;
1142}
1143
dade37d4 1144int journal_file_map_data_hash_table(JournalFile *f) {
cec736d2
LP		 1145 uint64_t s, p;
1146 void *t;
1147 int r;
1148
1149 assert(f);
c88cc6af 1150 assert(f->header);
cec736d2 1151
dade37d4
LP		 1152 if (f->data_hash_table)
1153 return 0;
1154
de190aef
LP		 1155 p = le64toh(f->header->data_hash_table_offset);
1156 s = le64toh(f->header->data_hash_table_size);
cec736d2 1157
de190aef 1158 r = journal_file_move_to(f,
16e9f408 1159 OBJECT_DATA_HASH_TABLE,
fcde2389 1160 true,
de190aef 1161 p, s,
b42549ad 1162 &t, NULL);
cec736d2
LP		 1163 if (r < 0)
1164 return r;
1165
de190aef 1166 f->data_hash_table = t;
cec736d2
LP		 1167 return 0;
1168}
1169
dade37d4 1170int journal_file_map_field_hash_table(JournalFile *f) {
cec736d2
LP		 1171 uint64_t s, p;
1172 void *t;
1173 int r;
1174
1175 assert(f);
c88cc6af 1176 assert(f->header);
cec736d2 1177
dade37d4
LP		 1178 if (f->field_hash_table)
1179 return 0;
1180
de190aef
LP		 1181 p = le64toh(f->header->field_hash_table_offset);
1182 s = le64toh(f->header->field_hash_table_size);
cec736d2 1183
de190aef 1184 r = journal_file_move_to(f,
16e9f408 1185 OBJECT_FIELD_HASH_TABLE,
fcde2389 1186 true,
de190aef 1187 p, s,
b42549ad 1188 &t, NULL);
cec736d2
LP		 1189 if (r < 0)
1190 return r;
1191
de190aef 1192 f->field_hash_table = t;
cec736d2
LP		 1193 return 0;
1194}
1195
3c1668da
LP		 1196static int journal_file_link_field(
1197 JournalFile *f,
1198 Object *o,
1199 uint64_t offset,
1200 uint64_t hash) {
1201
805d1486 1202 uint64_t p, h, m;
3c1668da
LP		 1203 int r;
1204
1205 assert(f);
c88cc6af 1206 assert(f->header);
90d222c1 1207 assert(f->field_hash_table);
3c1668da
LP		 1208 assert(o);
1209 assert(offset > 0);
1210
1211 if (o->object.type != OBJECT_FIELD)
1212 return -EINVAL;
1213
805d1486
LP		 1214 m = le64toh(f->header->field_hash_table_size) / sizeof(HashItem);
1215 if (m <= 0)
1216 return -EBADMSG;
3c1668da 1217
805d1486 1218 /* This might alter the window we are looking at */
3c1668da
LP		 1219 o->field.next_hash_offset = o->field.head_data_offset = 0;
1220
805d1486 1221 h = hash % m;
3c1668da
LP		 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
1241static int journal_file_link_data(
1242 JournalFile *f,
1243 Object *o,
1244 uint64_t offset,
1245 uint64_t hash) {
1246
805d1486 1247 uint64_t p, h, m;
cec736d2
LP		 1248 int r;
1249
1250 assert(f);
c88cc6af 1251 assert(f->header);
90d222c1 1252 assert(f->data_hash_table);
cec736d2
LP		 1253 assert(o);
1254 assert(offset > 0);
b588975f
LP		 1255
1256 if (o->object.type != OBJECT_DATA)
1257 return -EINVAL;
cec736d2 1258
805d1486
LP		 1259 m = le64toh(f->header->data_hash_table_size) / sizeof(HashItem);
1260 if (m <= 0)
1261 return -EBADMSG;
48496df6 1262
805d1486 1263 /* This might alter the window we are looking at */
de190aef
LP		 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;
cec736d2 1267
805d1486 1268 h = hash % m;
8db4213e 1269 p = le64toh(f->data_hash_table[h].tail_hash_offset);
3c1668da 1270 if (p == 0)
cec736d2 1271 /* Only entry in the hash table is easy */
de190aef 1272 f->data_hash_table[h].head_hash_offset = htole64(offset);
3c1668da 1273 else {
48496df6
LP		 1274 /* Move back to the previous data object, to patch in
1275 * pointer */
cec736d2 1276
de190aef 1277 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
cec736d2
LP		 1278 if (r < 0)
1279 return r;
1280
de190aef 1281 o->data.next_hash_offset = htole64(offset);
cec736d2
LP		 1282 }
1283
de190aef 1284 f->data_hash_table[h].tail_hash_offset = htole64(offset);
cec736d2 1285
dca6219e
LP		 1286 if (JOURNAL_HEADER_CONTAINS(f->header, n_data))
1287 f->header->n_data = htole64(le64toh(f->header->n_data) + 1);
1288
cec736d2
LP		 1289 return 0;
1290}
1291
3c1668da
LP		 1292int 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
805d1486 1297 uint64_t p, osize, h, m;
3c1668da
LP		 1298 int r;
1299
1300 assert(f);
c88cc6af 1301 assert(f->header);
3c1668da
LP		 1302 assert(field && size > 0);
1303
dade37d4
LP		 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
3c1668da
LP		 1313 osize = offsetof(Object, field.payload) + size;
1314
805d1486 1315 m = le64toh(f->header->field_hash_table_size) / sizeof(HashItem);
805d1486 1316 if (m <= 0)
3c1668da
LP		 1317 return -EBADMSG;
1318
805d1486 1319 h = hash % m;
3c1668da
LP		 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
1347int 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
de190aef
LP		 1364int 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) {
48496df6 1368
805d1486 1369 uint64_t p, osize, h, m;
cec736d2
LP		 1370 int r;
1371
1372 assert(f);
c88cc6af 1373 assert(f->header);
cec736d2
LP		 1374 assert(data || size == 0);
1375
dade37d4
LP		 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
cec736d2
LP		 1385 osize = offsetof(Object, data.payload) + size;
1386
805d1486
LP		 1387 m = le64toh(f->header->data_hash_table_size) / sizeof(HashItem);
1388 if (m <= 0)
bc85bfee
LP		 1389 return -EBADMSG;
1390
805d1486 1391 h = hash % m;
de190aef 1392 p = le64toh(f->data_hash_table[h].head_hash_offset);
cec736d2 1393
de190aef
LP		 1394 while (p > 0) {
1395 Object *o;
cec736d2 1396
de190aef 1397 r = journal_file_move_to_object(f, OBJECT_DATA, p, &o);
cec736d2
LP		 1398 if (r < 0)
1399 return r;
1400
807e17f0 1401 if (le64toh(o->data.hash) != hash)
85a131e8 1402 goto next;
807e17f0 1403
d89c8fdf 1404 if (o->object.flags & OBJECT_COMPRESSION_MASK) {
3b1a55e1 1405#if defined(HAVE_XZ) || defined(HAVE_LZ4)
fa1c4b51 1406 uint64_t l;
a7f7d1bd 1407 size_t rsize = 0;
cec736d2 1408
807e17f0
LP		 1409 l = le64toh(o->object.size);
1410 if (l <= offsetof(Object, data.payload))
cec736d2
LP		 1411 return -EBADMSG;
1412
807e17f0
LP		 1413 l -= offsetof(Object, data.payload);
1414
d89c8fdf
ZJS		 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;
807e17f0 1419
b785c858 1420 if (rsize == size &&
807e17f0
LP		 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 }
3b1a55e1
ZJS		 1431#else
1432 return -EPROTONOSUPPORT;
1433#endif
807e17f0
LP		 1434 } else if (le64toh(o->object.size) == osize &&
1435 memcmp(o->data.payload, data, size) == 0) {
1436
cec736d2
LP		 1437 if (ret)
1438 *ret = o;
1439
1440 if (offset)
1441 *offset = p;
1442
de190aef 1443 return 1;
cec736d2
LP		 1444 }
1445
85a131e8 1446 next:
cec736d2
LP		 1447 p = le64toh(o->data.next_hash_offset);
1448 }
1449
de190aef
LP		 1450 return 0;
1451}
1452
1453int 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
3c1668da
LP		 1470static 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);
8c92d4bb
LP		 1501 if (r < 0)
1502 return r;
3c1668da
LP		 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
48496df6
LP		 1532static int journal_file_append_data(
1533 JournalFile *f,
1534 const void *data, uint64_t size,
1535 Object **ret, uint64_t *offset) {
1536
de190aef
LP		 1537 uint64_t hash, p;
1538 uint64_t osize;
1539 Object *o;
d89c8fdf 1540 int r, compression = 0;
3c1668da 1541 const void *eq;
de190aef
LP		 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;
0240c603 1551 if (r > 0) {
de190aef
LP		 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);
cec736d2
LP		 1564 if (r < 0)
1565 return r;
1566
cec736d2 1567 o->data.hash = htole64(hash);
807e17f0 1568
d89c8fdf 1569#if defined(HAVE_XZ) || defined(HAVE_LZ4)
d1afbcd2 1570 if (JOURNAL_FILE_COMPRESS(f) && size >= COMPRESSION_SIZE_THRESHOLD) {
a7f7d1bd 1571 size_t rsize = 0;
807e17f0 1572
5d6f46b6 1573 compression = compress_blob(data, size, o->data.payload, size - 1, &rsize);
807e17f0 1574
d1afbcd2 1575 if (compression >= 0) {
807e17f0 1576 o->object.size = htole64(offsetof(Object, data.payload) + rsize);
d89c8fdf 1577 o->object.flags |= compression;
807e17f0 1578
fa1c4b51 1579 log_debug("Compressed data object %"PRIu64" -> %zu using %s",
d89c8fdf 1580 size, rsize, object_compressed_to_string(compression));
d1afbcd2
LP		 1581 } else
1582 /* Compression didn't work, we don't really care why, let's continue without compression */
1583 compression = 0;
807e17f0
LP		 1584 }
1585#endif
1586
75f32f04
ZJS		 1587 if (compression == 0)
1588 memcpy_safe(o->data.payload, data, size);
cec736d2 1589
de190aef 1590 r = journal_file_link_data(f, o, p, hash);
cec736d2
LP		 1591 if (r < 0)
1592 return r;
1593
33685a5a
FB		 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
48496df6
LP		 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
08c6f819
SL		 1606 if (!data)
1607 eq = NULL;
1608 else
1609 eq = memchr(data, '=', size);
3c1668da 1610 if (eq && eq > data) {
748db592 1611 Object *fo = NULL;
3c1668da 1612 uint64_t fp;
3c1668da
LP		 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
cec736d2
LP		 1624 if (ret)
1625 *ret = o;
1626
1627 if (offset)
de190aef 1628 *offset = p;
cec736d2
LP		 1629
1630 return 0;
1631}
1632
1633uint64_t journal_file_entry_n_items(Object *o) {
1634 assert(o);
b588975f
LP		 1635
1636 if (o->object.type != OBJECT_ENTRY)
1637 return 0;
cec736d2
LP		 1638
1639 return (le64toh(o->object.size) - offsetof(Object, entry.items)) / sizeof(EntryItem);
1640}
1641
0284adc6 1642uint64_t journal_file_entry_array_n_items(Object *o) {
de190aef 1643 assert(o);
b588975f
LP		 1644
1645 if (o->object.type != OBJECT_ENTRY_ARRAY)
1646 return 0;
de190aef
LP		 1647
1648 return (le64toh(o->object.size) - offsetof(Object, entry_array.items)) / sizeof(uint64_t);
1649}
1650
fb9a24b6
LP		 1651uint64_t journal_file_hash_table_n_items(Object *o) {
1652 assert(o);
b588975f
LP		 1653
1654 if (o->object.type != OBJECT_DATA_HASH_TABLE &&
1655 o->object.type != OBJECT_FIELD_HASH_TABLE)
1656 return 0;
fb9a24b6
LP		 1657
1658 return (le64toh(o->object.size) - offsetof(Object, hash_table.items)) / sizeof(HashItem);
1659}
1660
de190aef 1661static int link_entry_into_array(JournalFile *f,
4fd052ae
FC		 1662 le64_t *first,
1663 le64_t *idx,
de190aef 1664 uint64_t p) {
cec736d2 1665 int r;
de190aef
LP		 1666 uint64_t n = 0, ap = 0, q, i, a, hidx;
1667 Object *o;
1668
cec736d2 1669 assert(f);
c88cc6af 1670 assert(f->header);
de190aef
LP		 1671 assert(first);
1672 assert(idx);
1673 assert(p > 0);
cec736d2 1674
de190aef
LP		 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;
cec736d2 1682
de190aef
LP		 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 }
cec736d2 1689
de190aef
LP		 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);
cec736d2
LP		 1706 if (r < 0)
1707 return r;
1708
feb12d3e 1709#ifdef HAVE_GCRYPT
5996c7c2 1710 r = journal_file_hmac_put_object(f, OBJECT_ENTRY_ARRAY, o, q);
b0af6f41
LP		 1711 if (r < 0)
1712 return r;
feb12d3e 1713#endif
b0af6f41 1714
de190aef 1715 o->entry_array.items[i] = htole64(p);
cec736d2 1716
de190aef 1717 if (ap == 0)
7be3aa17 1718 *first = htole64(q);
cec736d2 1719 else {
de190aef 1720 r = journal_file_move_to_object(f, OBJECT_ENTRY_ARRAY, ap, &o);
cec736d2
LP		 1721 if (r < 0)
1722 return r;
1723
de190aef
LP		 1724 o->entry_array.next_entry_array_offset = htole64(q);
1725 }
cec736d2 1726
2dee23eb
LP		 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
de190aef
LP		 1730 *idx = htole64(hidx + 1);
1731
1732 return 0;
1733}
cec736d2 1734
de190aef 1735static int link_entry_into_array_plus_one(JournalFile *f,
4fd052ae
FC		 1736 le64_t *extra,
1737 le64_t *first,
1738 le64_t *idx,
de190aef
LP		 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 {
4fd052ae 1752 le64_t i;
de190aef 1753
7be3aa17 1754 i = htole64(le64toh(*idx) - 1);
de190aef
LP		 1755 r = link_entry_into_array(f, first, &i, p);
1756 if (r < 0)
1757 return r;
cec736d2
LP		 1758 }
1759
de190aef
LP		 1760 *idx = htole64(le64toh(*idx) + 1);
1761 return 0;
1762}
1763
1764static 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);
cec736d2
LP		 1776 if (r < 0)
1777 return r;
1778
de190aef
LP		 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);
cec736d2
LP		 1784}
1785
1786static int journal_file_link_entry(JournalFile *f, Object *o, uint64_t offset) {
de190aef 1787 uint64_t n, i;
cec736d2
LP		 1788 int r;
1789
1790 assert(f);
c88cc6af 1791 assert(f->header);
cec736d2
LP		 1792 assert(o);
1793 assert(offset > 0);
b588975f
LP		 1794
1795 if (o->object.type != OBJECT_ENTRY)
1796 return -EINVAL;
cec736d2 1797
b788cc23
LP		 1798 __sync_synchronize();
1799
cec736d2 1800 /* Link up the entry itself */
de190aef
LP		 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;
cec736d2 1807
507f22bd 1808 /* log_debug("=> %s seqnr=%"PRIu64" n_entries=%"PRIu64, f->path, o->entry.seqnum, f->header->n_entries); */
cec736d2 1809
de190aef 1810 if (f->header->head_entry_realtime == 0)
0ac38b70 1811 f->header->head_entry_realtime = o->entry.realtime;
cec736d2 1812
0ac38b70 1813 f->header->tail_entry_realtime = o->entry.realtime;
de190aef
LP		 1814 f->header->tail_entry_monotonic = o->entry.monotonic;
1815
1816 f->tail_entry_monotonic_valid = true;
cec736d2
LP		 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
cec736d2
LP		 1826 return 0;
1827}
1828
1829static 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,
de190aef 1834 uint64_t *seqnum,
cec736d2
LP		 1835 Object **ret, uint64_t *offset) {
1836 uint64_t np;
1837 uint64_t osize;
1838 Object *o;
1839 int r;
1840
1841 assert(f);
c88cc6af 1842 assert(f->header);
cec736d2 1843 assert(items || n_items == 0);
de190aef 1844 assert(ts);
cec736d2
LP		 1845
1846 osize = offsetof(Object, entry.items) + (n_items * sizeof(EntryItem));
1847
de190aef 1848 r = journal_file_append_object(f, OBJECT_ENTRY, osize, &o, &np);
cec736d2
LP		 1849 if (r < 0)
1850 return r;
1851
d98cc1f2 1852 o->entry.seqnum = htole64(journal_file_entry_seqnum(f, seqnum));
75f32f04 1853 memcpy_safe(o->entry.items, items, n_items * sizeof(EntryItem));
de190aef
LP		 1854 o->entry.realtime = htole64(ts->realtime);
1855 o->entry.monotonic = htole64(ts->monotonic);
cec736d2
LP		 1856 o->entry.xor_hash = htole64(xor_hash);
1857 o->entry.boot_id = f->header->boot_id;
1858
feb12d3e 1859#ifdef HAVE_GCRYPT
5996c7c2 1860 r = journal_file_hmac_put_object(f, OBJECT_ENTRY, o, np);
b0af6f41
LP		 1861 if (r < 0)
1862 return r;
feb12d3e 1863#endif
b0af6f41 1864
cec736d2
LP		 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
cf244689 1878void journal_file_post_change(JournalFile *f) {
50f20cfd
LP		 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
bc85bfee
LP		 1886 __sync_synchronize();
1887
50f20cfd 1888 if (ftruncate(f->fd, f->last_stat.st_size) < 0)
e167d7fd 1889 log_debug_errno(errno, "Failed to truncate file to its own size: %m");
50f20cfd
LP		 1890}
1891
7a24f3bf
VC		 1892static 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
1900static 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) {
e167d7fd
LP		 1912 log_debug_errno(r, "Failed to get ftruncate timer state: %m");
1913 goto fail;
7a24f3bf
VC		 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) {
e167d7fd
LP		 1921 log_debug_errno(r, "Failed to get clock's now for scheduling ftruncate: %m");
1922 goto fail;
7a24f3bf
VC		 1923 }
1924
1925 r = sd_event_source_set_time(timer, now+f->post_change_timer_period);
1926 if (r < 0) {
e167d7fd
LP		 1927 log_debug_errno(r, "Failed to set time for scheduling ftruncate: %m");
1928 goto fail;
7a24f3bf
VC		 1929 }
1930
1931 r = sd_event_source_set_enabled(timer, SD_EVENT_ONESHOT);
1932 if (r < 0) {
e167d7fd
LP		 1933 log_debug_errno(r, "Failed to enable scheduled ftruncate: %m");
1934 goto fail;
7a24f3bf 1935 }
e167d7fd
LP		 1936
1937 return;
1938
1939fail:
1940 /* On failure, let's simply post the change immediately. */
1941 journal_file_post_change(f);
7a24f3bf
VC		 1942}
1943
1944/* Enable coalesced change posting in a timer on the provided sd_event instance */
1945int 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
1f2da9ec
LP		 1969static 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
de190aef 1979int 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) {
cec736d2
LP		 1980 unsigned i;
1981 EntryItem *items;
1982 int r;
1983 uint64_t xor_hash = 0;
de190aef 1984 struct dual_timestamp _ts;
cec736d2
LP		 1985
1986 assert(f);
c88cc6af 1987 assert(f->header);
cec736d2
LP		 1988 assert(iovec || n_iovec == 0);
1989
de190aef
LP		 1990 if (!ts) {
1991 dual_timestamp_get(&_ts);
1992 ts = &_ts;
1993 }
1994
feb12d3e 1995#ifdef HAVE_GCRYPT
7560fffc
LP		 1996 r = journal_file_maybe_append_tag(f, ts->realtime);
1997 if (r < 0)
1998 return r;
feb12d3e 1999#endif
7560fffc 2000
64825d3c 2001 /* alloca() can't take 0, hence let's allocate at least one */
9607d947 2002 items = alloca(sizeof(EntryItem) * MAX(1u, n_iovec));
cec736d2
LP		 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)
cf244689 2010 return r;
cec736d2
LP		 2011
2012 xor_hash ^= le64toh(o->data.hash);
2013 items[i].object_offset = htole64(p);
de7b95cd 2014 items[i].hash = o->data.hash;
cec736d2
LP		 2015 }
2016
1f2da9ec
LP		 2017 /* Order by the position on disk, in order to improve seek
2018 * times for rotating media. */
7ff7394d 2019 qsort_safe(items, n_iovec, sizeof(EntryItem), entry_item_cmp);
1f2da9ec 2020
de190aef 2021 r = journal_file_append_entry_internal(f, ts, xor_hash, items, n_iovec, seqnum, ret, offset);
cec736d2 2022
fa6ac760
LP		 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
be7cdd8e 2028 if (mmap_cache_got_sigbus(f->mmap, f->cache_fd))
fa6ac760
LP		 2029 r = -EIO;
2030
7a24f3bf
VC		 2031 if (f->post_change_timer)
2032 schedule_post_change(f);
2033 else
2034 journal_file_post_change(f);
50f20cfd 2035
cec736d2
LP		 2036 return r;
2037}
2038
a4bcff5b 2039typedef struct ChainCacheItem {
fb099c8d 2040 uint64_t first; /* the array at the beginning of the chain */
a4bcff5b
LP		 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 */
f268980d 2044 uint64_t last_index; /* the last index we looked at, to optimize locality when bisecting */
a4bcff5b
LP		 2045} ChainCacheItem;
2046
2047static void chain_cache_put(
4743015d 2048 OrderedHashmap *h,
a4bcff5b
LP		 2049 ChainCacheItem *ci,
2050 uint64_t first,
2051 uint64_t array,
2052 uint64_t begin,
f268980d
LP		 2053 uint64_t total,
2054 uint64_t last_index) {
a4bcff5b
LP		 2055
2056 if (!ci) {
34741aa3
LP		 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
29433089 2062 if (ordered_hashmap_size(h) >= CHAIN_CACHE_MAX) {
4743015d 2063 ci = ordered_hashmap_steal_first(h);
29433089
LP		 2064 assert(ci);
2065 } else {
a4bcff5b
LP		 2066 ci = new(ChainCacheItem, 1);
2067 if (!ci)
2068 return;
2069 }
2070
2071 ci->first = first;
2072
4743015d 2073 if (ordered_hashmap_put(h, &ci->first, ci) < 0) {
a4bcff5b
LP		 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;
f268980d 2083 ci->last_index = last_index;
a4bcff5b
LP		 2084}
2085
f268980d
LP		 2086static int generic_array_get(
2087 JournalFile *f,
2088 uint64_t first,
2089 uint64_t i,
2090 Object **ret, uint64_t *offset) {
de190aef 2091
cec736d2 2092 Object *o;
a4bcff5b 2093 uint64_t p = 0, a, t = 0;
cec736d2 2094 int r;
a4bcff5b 2095 ChainCacheItem *ci;
cec736d2
LP		 2096
2097 assert(f);
2098
de190aef 2099 a = first;
a4bcff5b
LP		 2100
2101 /* Try the chain cache first */
4743015d 2102 ci = ordered_hashmap_get(f->chain_cache, &first);
a4bcff5b
LP		 2103 if (ci && i > ci->total) {
2104 a = ci->array;
2105 i -= ci->total;
2106 t = ci->total;
2107 }
2108
de190aef 2109 while (a > 0) {
a4bcff5b 2110 uint64_t k;
cec736d2 2111
de190aef
LP		 2112 r = journal_file_move_to_object(f, OBJECT_ENTRY_ARRAY, a, &o);
2113 if (r < 0)
2114 return r;
cec736d2 2115
a4bcff5b
LP		 2116 k = journal_file_entry_array_n_items(o);
2117 if (i < k) {
de190aef 2118 p = le64toh(o->entry_array.items[i]);
a4bcff5b 2119 goto found;
cec736d2
LP		 2120 }
2121
a4bcff5b
LP		 2122 i -= k;
2123 t += k;
de190aef
LP		 2124 a = le64toh(o->entry_array.next_entry_array_offset);
2125 }
2126
a4bcff5b
LP		 2127 return 0;
2128
2129found:
2130 /* Let's cache this item for the next invocation */
af13a6b0 2131 chain_cache_put(f->chain_cache, ci, first, a, le64toh(o->entry_array.items[0]), t, i);
de190aef
LP		 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
f268980d
LP		 2146static 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) {
de190aef
LP		 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);
cec736d2
LP		 2161 if (r < 0)
2162 return r;
2163
de190aef
LP		 2164 if (ret)
2165 *ret = o;
cec736d2 2166
de190aef
LP		 2167 if (offset)
2168 *offset = extra;
cec736d2 2169
de190aef 2170 return 1;
cec736d2
LP		 2171 }
2172
de190aef
LP		 2173 return generic_array_get(f, first, i-1, ret, offset);
2174}
cec736d2 2175
de190aef
LP		 2176enum {
2177 TEST_FOUND,
2178 TEST_LEFT,
2179 TEST_RIGHT
2180};
cec736d2 2181
f268980d
LP		 2182static 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;
de190aef
LP		 2194 bool subtract_one = false;
2195 Object *o, *array = NULL;
2196 int r;
a4bcff5b 2197 ChainCacheItem *ci;
cec736d2 2198
de190aef
LP		 2199 assert(f);
2200 assert(test_object);
cec736d2 2201
a4bcff5b 2202 /* Start with the first array in the chain */
de190aef 2203 a = first;
a4bcff5b 2204
4743015d 2205 ci = ordered_hashmap_get(f->chain_cache, &first);
a4bcff5b
LP		 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) {
f268980d 2218 /* OK, what we are looking for is right of the
a4bcff5b
LP		 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;
f268980d 2226 last_index = ci->last_index;
a4bcff5b
LP		 2227 }
2228 }
2229
de190aef
LP		 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);
cec736d2
LP		 2234 if (r < 0)
2235 return r;
2236
de190aef
LP		 2237 k = journal_file_entry_array_n_items(array);
2238 right = MIN(k, n);
2239 if (right <= 0)
2240 return 0;
cec736d2 2241
de190aef
LP		 2242 i = right - 1;
2243 lp = p = le64toh(array->entry_array.items[i]);
2244 if (p <= 0)
bee6a291
LP		 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 }
de190aef
LP		 2253 if (r < 0)
2254 return r;
cec736d2 2255
de190aef
LP		 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;
f268980d
LP		 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 }
f268980d
LP		 2312 }
2313
de190aef
LP		 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);
de190aef 2324 i = (left + right) / 2;
f268980d 2325
de190aef
LP		 2326 p = le64toh(array->entry_array.items[i]);
2327 if (p <= 0)
bee6a291
LP		 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 }
de190aef
LP		 2336 if (r < 0)
2337 return r;
cec736d2 2338
de190aef
LP		 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
2173cbf8 2349 if (k >= n) {
cbdca852
LP		 2350 if (direction == DIRECTION_UP) {
2351 i = n;
2352 subtract_one = true;
2353 goto found;
2354 }
2355
cec736d2 2356 return 0;
cbdca852 2357 }
cec736d2 2358
de190aef
LP		 2359 last_p = lp;
2360
2361 n -= k;
2362 t += k;
f268980d 2363 last_index = (uint64_t) -1;
de190aef 2364 a = le64toh(array->entry_array.next_entry_array_offset);
cec736d2
LP		 2365 }
2366
2367 return 0;
de190aef
LP		 2368
2369found:
2370 if (subtract_one && t == 0 && i == 0)
2371 return 0;
2372
a4bcff5b 2373 /* Let's cache this item for the next invocation */
af13a6b0 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);
a4bcff5b 2375
de190aef
LP		 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)
cbdca852 2394 *idx = t + i + (subtract_one ? -1 : 0);
de190aef
LP		 2395
2396 return 1;
cec736d2
LP		 2397}
2398
f268980d
LP		 2399static 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) {
de190aef 2410
cec736d2 2411 int r;
cbdca852
LP		 2412 bool step_back = false;
2413 Object *o;
cec736d2
LP		 2414
2415 assert(f);
de190aef 2416 assert(test_object);
cec736d2 2417
de190aef
LP		 2418 if (n <= 0)
2419 return 0;
cec736d2 2420
de190aef
LP		 2421 /* This bisects the array in object 'first', but first checks
2422 * an extra */
de190aef
LP		 2423 r = test_object(f, extra, needle);
2424 if (r < 0)
2425 return r;
a536e261
LP		 2426
2427 if (r == TEST_FOUND)
2428 r = direction == DIRECTION_DOWN ? TEST_RIGHT : TEST_LEFT;
2429
cbdca852
LP		 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;
de190aef 2437
cbdca852
LP		 2438 if (r == TEST_RIGHT) {
2439 if (direction == DIRECTION_DOWN)
2440 goto found;
2441 else
2442 return 0;
a536e261 2443 }
cec736d2 2444
de190aef
LP		 2445 r = generic_array_bisect(f, first, n-1, needle, test_object, direction, ret, offset, idx);
2446
cbdca852
LP		 2447 if (r == 0 && step_back)
2448 goto found;
2449
ecf68b1d 2450 if (r > 0 && idx)
313cefa1 2451 (*idx)++;
de190aef
LP		 2452
2453 return r;
cbdca852
LP		 2454
2455found:
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
44a6b1b6 2472_pure_ static int test_object_offset(JournalFile *f, uint64_t p, uint64_t needle) {
cbdca852
LP		 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
de190aef
LP		 2484static 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);
cec736d2
LP		 2492 if (r < 0)
2493 return r;
2494
de190aef
LP		 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}
cec736d2 2502
de190aef
LP		 2503int 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) {
c88cc6af
VC		 2509 assert(f);
2510 assert(f->header);
de190aef
LP		 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}
cec736d2 2520
de190aef
LP		 2521static 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;
cec736d2
LP		 2538}
2539
de190aef
LP		 2540int 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) {
c88cc6af
VC		 2546 assert(f);
2547 assert(f->header);
de190aef
LP		 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
2558static 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
2a560338 2577static int find_data_object_by_boot_id(
47838ab3
ZJS		 2578 JournalFile *f,
2579 sd_id128_t boot_id,
2580 Object **o,
2581 uint64_t *b) {
2a560338 2582
47838ab3
ZJS		 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
de190aef
LP		 2589int 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
de190aef
LP		 2597 Object *o;
2598 int r;
2599
cbdca852 2600 assert(f);
de190aef 2601
47838ab3 2602 r = find_data_object_by_boot_id(f, boot_id, &o, NULL);
de190aef
LP		 2603 if (r < 0)
2604 return r;
cbdca852 2605 if (r == 0)
de190aef
LP		 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
1fc605b0 2618void journal_file_reset_location(JournalFile *f) {
6573ef05 2619 f->location_type = LOCATION_HEAD;
1fc605b0 2620 f->current_offset = 0;
6573ef05
MS		 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
950c07d4 2628void journal_file_save_location(JournalFile *f, Object *o, uint64_t offset) {
6573ef05
MS		 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);
1fc605b0
MS		 2636}
2637
d8ae66d7
MS		 2638int journal_file_compare_locations(JournalFile *af, JournalFile *bf) {
2639 assert(af);
c88cc6af 2640 assert(af->header);
d8ae66d7 2641 assert(bf);
c88cc6af 2642 assert(bf->header);
d8ae66d7
MS		 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
aa598ba5
LP		 2692static 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
b6da4ed0
LP		 2711static 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
de190aef
LP		 2723int journal_file_next_entry(
2724 JournalFile *f,
f534928a 2725 uint64_t p,
de190aef
LP		 2726 direction_t direction,
2727 Object **ret, uint64_t *offset) {
2728
fb099c8d 2729 uint64_t i, n, ofs;
cec736d2
LP		 2730 int r;
2731
2732 assert(f);
c88cc6af 2733 assert(f->header);
de190aef
LP		 2734
2735 n = le64toh(f->header->n_entries);
2736 if (n <= 0)
2737 return 0;
cec736d2 2738
f534928a 2739 if (p == 0)
de190aef 2740 i = direction == DIRECTION_DOWN ? 0 : n - 1;
cec736d2 2741 else {
de190aef
LP		 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
aa598ba5
LP		 2753 r = bump_array_index(&i, direction, n);
2754 if (r <= 0)
2755 return r;
cec736d2
LP		 2756 }
2757
de190aef 2758 /* And jump to it */
989793d3
LP		 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;
caeab8f6 2776 }
fb099c8d 2777
b6da4ed0
LP		 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);
fb099c8d
ZJS		 2781 return -EBADMSG;
2782 }
2783
2784 if (offset)
2785 *offset = ofs;
2786
2787 return 1;
de190aef 2788}
cec736d2 2789
de190aef
LP		 2790int 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
ded5034e 2797 uint64_t i, n, ofs;
de190aef 2798 Object *d;
989793d3 2799 int r;
cec736d2
LP		 2800
2801 assert(f);
de190aef 2802 assert(p > 0 || !o);
cec736d2 2803
de190aef 2804 r = journal_file_move_to_object(f, OBJECT_DATA, data_offset, &d);
466ccd92 2805 if (r < 0)
de190aef 2806 return r;
cec736d2 2807
de190aef
LP		 2808 n = le64toh(d->data.n_entries);
2809 if (n <= 0)
2810 return n;
cec736d2 2811
de190aef
LP		 2812 if (!o)
2813 i = direction == DIRECTION_DOWN ? 0 : n - 1;
2814 else {
2815 if (o->object.type != OBJECT_ENTRY)
2816 return -EINVAL;
cec736d2 2817
de190aef
LP		 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)
cec736d2
LP		 2829 return r;
2830
aa598ba5
LP		 2831 r = bump_array_index(&i, direction, n);
2832 if (r <= 0)
2833 return r;
de190aef 2834 }
cec736d2 2835
989793d3
LP		 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 }
ded5034e
LP		 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;
de190aef 2864}
cec736d2 2865
cbdca852
LP		 2866int 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
2892int 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
cbdca852
LP		 2900 Object *o, *d;
2901 int r;
2902 uint64_t b, z;
2903
2904 assert(f);
2905
2906 /* First, seek by time */
47838ab3 2907 r = find_data_object_by_boot_id(f, boot_id, &o, &b);
cbdca852
LP		 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 }
cbdca852
LP		 2973}
2974
de190aef
LP		 2975int 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) {
cec736d2 2981
de190aef
LP		 2982 Object *d;
2983 int r;
cec736d2 2984
91a31dde
LP		 2985 assert(f);
2986
de190aef 2987 r = journal_file_move_to_object(f, OBJECT_DATA, data_offset, &d);
91a31dde 2988 if (r < 0)
de190aef 2989 return r;
cec736d2 2990
de190aef
LP		 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}
cec736d2 3000
de190aef
LP		 3001int 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
91a31dde
LP		 3011 assert(f);
3012
de190aef 3013 r = journal_file_move_to_object(f, OBJECT_DATA, data_offset, &d);
91a31dde 3014 if (r < 0)
de190aef
LP		 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);
cec736d2
LP		 3025}
3026
0284adc6 3027void journal_file_dump(JournalFile *f) {
7560fffc 3028 Object *o;
7560fffc 3029 int r;
0284adc6 3030 uint64_t p;
7560fffc
LP		 3031
3032 assert(f);
c88cc6af 3033 assert(f->header);
7560fffc 3034
0284adc6 3035 journal_file_print_header(f);
7560fffc 3036
0284adc6
LP		 3037 p = le64toh(f->header->header_size);
3038 while (p != 0) {
d05089d8 3039 r = journal_file_move_to_object(f, OBJECT_UNUSED, p, &o);
0284adc6
LP		 3040 if (r < 0)
3041 goto fail;
7560fffc 3042
0284adc6 3043 switch (o->object.type) {
d98cc1f2 3044
0284adc6
LP		 3045 case OBJECT_UNUSED:
3046 printf("Type: OBJECT_UNUSED\n");
3047 break;
d98cc1f2 3048
0284adc6
LP		 3049 case OBJECT_DATA:
3050 printf("Type: OBJECT_DATA\n");
3051 break;
7560fffc 3052
3c1668da
LP		 3053 case OBJECT_FIELD:
3054 printf("Type: OBJECT_FIELD\n");
3055 break;
3056
0284adc6 3057 case OBJECT_ENTRY:
507f22bd
ZJS		 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));
0284adc6 3062 break;
7560fffc 3063
0284adc6
LP		 3064 case OBJECT_FIELD_HASH_TABLE:
3065 printf("Type: OBJECT_FIELD_HASH_TABLE\n");
3066 break;
7560fffc 3067
0284adc6
LP		 3068 case OBJECT_DATA_HASH_TABLE:
3069 printf("Type: OBJECT_DATA_HASH_TABLE\n");
3070 break;
7560fffc 3071
0284adc6
LP		 3072 case OBJECT_ENTRY_ARRAY:
3073 printf("Type: OBJECT_ENTRY_ARRAY\n");
3074 break;
7560fffc 3075
0284adc6 3076 case OBJECT_TAG:
507f22bd
ZJS		 3077 printf("Type: OBJECT_TAG seqnum=%"PRIu64" epoch=%"PRIu64"\n",
3078 le64toh(o->tag.seqnum),
3079 le64toh(o->tag.epoch));
0284adc6 3080 break;
3c1668da
LP		 3081
3082 default:
8facc349 3083 printf("Type: unknown (%i)\n", o->object.type);
3c1668da 3084 break;
0284adc6 3085 }
7560fffc 3086
d89c8fdf
ZJS		 3087 if (o->object.flags & OBJECT_COMPRESSION_MASK)
3088 printf("Flags: %s\n",
3089 object_compressed_to_string(o->object.flags & OBJECT_COMPRESSION_MASK));
7560fffc 3090
0284adc6
LP		 3091 if (p == le64toh(f->header->tail_object_offset))
3092 p = 0;
3093 else
3094 p = p + ALIGN64(le64toh(o->object.size));
3095 }
7560fffc 3096
0284adc6
LP		 3097 return;
3098fail:
3099 log_error("File corrupt");
7560fffc
LP		 3100}
3101
718fe4b1
ZJS		 3102static 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
0284adc6 3111void journal_file_print_header(JournalFile *f) {
2765b7bb 3112 char a[33], b[33], c[33], d[33];
ed375beb 3113 char x[FORMAT_TIMESTAMP_MAX], y[FORMAT_TIMESTAMP_MAX], z[FORMAT_TIMESTAMP_MAX];
a1a03e30
LP		 3114 struct stat st;
3115 char bytes[FORMAT_BYTES_MAX];
7560fffc
LP		 3116
3117 assert(f);
c88cc6af 3118 assert(f->header);
7560fffc 3119
0284adc6
LP		 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"
d89c8fdf 3127 "Incompatible Flags:%s%s%s\n"
507f22bd
ZJS		 3128 "Header size: %"PRIu64"\n"
3129 "Arena size: %"PRIu64"\n"
3130 "Data Hash Table Size: %"PRIu64"\n"
3131 "Field Hash Table Size: %"PRIu64"\n"
0284adc6 3132 "Rotate Suggested: %s\n"
0808b92f
LP		 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"
507f22bd
ZJS		 3138 "Objects: %"PRIu64"\n"
3139 "Entry Objects: %"PRIu64"\n",
0284adc6
LP		 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),
2765b7bb 3144 sd_id128_to_string(f->header->seqnum_id, d),
3223f44f
LP		 3145 f->header->state == STATE_OFFLINE ? "OFFLINE" :
3146 f->header->state == STATE_ONLINE ? "ONLINE" :
3147 f->header->state == STATE_ARCHIVED ? "ARCHIVED" : "UNKNOWN",
8088cbd3 3148 JOURNAL_HEADER_SEALED(f->header) ? " SEALED" : "",
d89c8fdf
ZJS		 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) ? " ???" : "",
507f22bd
ZJS		 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),
fb0951b0 3157 yes_no(journal_file_rotate_suggested(f, 0)),
0808b92f
LP		 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),
507f22bd
ZJS		 3163 le64toh(f->header->n_objects),
3164 le64toh(f->header->n_entries));
7560fffc 3165
0284adc6 3166 if (JOURNAL_HEADER_CONTAINS(f->header, n_data))
507f22bd 3167 printf("Data Objects: %"PRIu64"\n"
0284adc6 3168 "Data Hash Table Fill: %.1f%%\n",
507f22bd 3169 le64toh(f->header->n_data),
0284adc6 3170 100.0 * (double) le64toh(f->header->n_data) / ((double) (le64toh(f->header->data_hash_table_size) / sizeof(HashItem))));
7560fffc 3171
0284adc6 3172 if (JOURNAL_HEADER_CONTAINS(f->header, n_fields))
507f22bd 3173 printf("Field Objects: %"PRIu64"\n"
0284adc6 3174 "Field Hash Table Fill: %.1f%%\n",
507f22bd 3175 le64toh(f->header->n_fields),
0284adc6 3176 100.0 * (double) le64toh(f->header->n_fields) / ((double) (le64toh(f->header->field_hash_table_size) / sizeof(HashItem))));
3223f44f
LP		 3177
3178 if (JOURNAL_HEADER_CONTAINS(f->header, n_tags))
507f22bd
ZJS		 3179 printf("Tag Objects: %"PRIu64"\n",
3180 le64toh(f->header->n_tags));
3223f44f 3181 if (JOURNAL_HEADER_CONTAINS(f->header, n_entry_arrays))
507f22bd
ZJS		 3182 printf("Entry Array Objects: %"PRIu64"\n",
3183 le64toh(f->header->n_entry_arrays));
a1a03e30
LP		 3184
3185 if (fstat(f->fd, &st) >= 0)
59f448cf 3186 printf("Disk usage: %s\n", format_bytes(bytes, sizeof(bytes), (uint64_t) st.st_blocks * 512ULL));
7560fffc
LP		 3187}
3188
fc68c929
LP		 3189static 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
0284adc6 3224int journal_file_open(
5d1ce257 3225 int fd,
0284adc6
LP		 3226 const char *fname,
3227 int flags,
3228 mode_t mode,
3229 bool compress,
baed47c3 3230 bool seal,
0284adc6
LP		 3231 JournalMetrics *metrics,
3232 MMapCache *mmap_cache,
b58c888f 3233 Set *deferred_closes,
0284adc6
LP		 3234 JournalFile *template,
3235 JournalFile **ret) {
7560fffc 3236
fa6ac760 3237 bool newly_created = false;
0284adc6 3238 JournalFile *f;
fa6ac760 3239 void *h;
0284adc6 3240 int r;
7560fffc 3241
0559d3a5 3242 assert(ret);
5d1ce257 3243 assert(fd >= 0 || fname);
7560fffc 3244
0284adc6
LP		 3245 if ((flags & O_ACCMODE) != O_RDONLY &&
3246 (flags & O_ACCMODE) != O_RDWR)
3247 return -EINVAL;
7560fffc 3248
5d1ce257
LP		 3249 if (fname) {
3250 if (!endswith(fname, ".journal") &&
3251 !endswith(fname, ".journal~"))
3252 return -EINVAL;
3253 }
7560fffc 3254
0284adc6
LP		 3255 f = new0(JournalFile, 1);
3256 if (!f)
3257 return -ENOMEM;
7560fffc 3258
5d1ce257 3259 f->fd = fd;
0284adc6 3260 f->mode = mode;
7560fffc 3261
0284adc6
LP		 3262 f->flags = flags;
3263 f->prot = prot_from_flags(flags);
3264 f->writable = (flags & O_ACCMODE) != O_RDONLY;
92261977 3265#if defined(HAVE_LZ4)
d89c8fdf
ZJS		 3266 f->compress_lz4 = compress;
3267#elif defined(HAVE_XZ)
3268 f->compress_xz = compress;
48b61739 3269#endif
49a32d43 3270#ifdef HAVE_GCRYPT
baed47c3 3271 f->seal = seal;
49a32d43 3272#endif
7560fffc 3273
0284adc6
LP		 3274 if (mmap_cache)
3275 f->mmap = mmap_cache_ref(mmap_cache);
3276 else {
84168d80 3277 f->mmap = mmap_cache_new();
0284adc6
LP		 3278 if (!f->mmap) {
3279 r = -ENOMEM;
3280 goto fail;
3281 }
3282 }
7560fffc 3283
7645c77b 3284 if (fname) {
5d1ce257 3285 f->path = strdup(fname);
7645c77b
ZJS		 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 }
0284adc6 3296 }
7560fffc 3297
4743015d 3298 f->chain_cache = ordered_hashmap_new(&uint64_hash_ops);
a4bcff5b
LP		 3299 if (!f->chain_cache) {
3300 r = -ENOMEM;
3301 goto fail;
3302 }
3303
0284adc6 3304 if (f->fd < 0) {
5d1ce257
LP		 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;
7560fffc 3313 }
7560fffc 3314
be7cdd8e
VC		 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
2678031a
LP		 3321 r = journal_file_fstat(f);
3322 if (r < 0)
0284adc6 3323 goto fail;
7560fffc 3324
0284adc6 3325 if (f->last_stat.st_size == 0 && f->writable) {
11689d2a 3326
fc68c929 3327 (void) journal_file_warn_btrfs(f);
11689d2a 3328
fb0951b0
LP		 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,
7517e174 3337 * and rely solely on mtime/atime/ctime of the file. */
fb0951b0 3338
d61b600d 3339 fd_setcrtime(f->fd, 0);
7560fffc 3340
feb12d3e 3341#ifdef HAVE_GCRYPT
0284adc6 3342 /* Try to load the FSPRG state, and if we can't, then
baed47c3 3343 * just don't do sealing */
49a32d43
LP		 3344 if (f->seal) {
3345 r = journal_file_fss_load(f);
3346 if (r < 0)
3347 f->seal = false;
3348 }
feb12d3e 3349#endif
7560fffc 3350
0284adc6
LP		 3351 r = journal_file_init_header(f, template);
3352 if (r < 0)
3353 goto fail;
7560fffc 3354
2678031a
LP		 3355 r = journal_file_fstat(f);
3356 if (r < 0)
0284adc6 3357 goto fail;
fb0951b0
LP		 3358
3359 newly_created = true;
0284adc6 3360 }
7560fffc 3361
0284adc6 3362 if (f->last_stat.st_size < (off_t) HEADER_SIZE_MIN) {
cfb571f3 3363 r = -ENODATA;
0284adc6
LP		 3364 goto fail;
3365 }
7560fffc 3366
b42549ad 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);
977eaa1e 3368 if (r < 0)
0284adc6 3369 goto fail;
7560fffc 3370
fa6ac760
LP		 3371 f->header = h;
3372
0284adc6 3373 if (!newly_created) {
b58c888f
VC		 3374 if (deferred_closes)
3375 journal_file_close_set(deferred_closes);
3376
0284adc6
LP		 3377 r = journal_file_verify_header(f);
3378 if (r < 0)
3379 goto fail;
3380 }
7560fffc 3381
feb12d3e 3382#ifdef HAVE_GCRYPT
0284adc6 3383 if (!newly_created && f->writable) {
baed47c3 3384 r = journal_file_fss_load(f);
0284adc6
LP		 3385 if (r < 0)
3386 goto fail;
3387 }
feb12d3e 3388#endif
cec736d2
LP		 3389
3390 if (f->writable) {
4a92baf3
LP		 3391 if (metrics) {
3392 journal_default_metrics(metrics, f->fd);
3393 f->metrics = *metrics;
3394 } else if (template)
3395 f->metrics = template->metrics;
3396
cec736d2
LP		 3397 r = journal_file_refresh_header(f);
3398 if (r < 0)
3399 goto fail;
3400 }
3401
feb12d3e 3402#ifdef HAVE_GCRYPT
baed47c3 3403 r = journal_file_hmac_setup(f);
14d10188
LP		 3404 if (r < 0)
3405 goto fail;
feb12d3e 3406#endif
14d10188 3407
cec736d2 3408 if (newly_created) {
de190aef 3409 r = journal_file_setup_field_hash_table(f);
cec736d2
LP		 3410 if (r < 0)
3411 goto fail;
3412
de190aef 3413 r = journal_file_setup_data_hash_table(f);
cec736d2
LP		 3414 if (r < 0)
3415 goto fail;
7560fffc 3416
feb12d3e 3417#ifdef HAVE_GCRYPT
7560fffc
LP		 3418 r = journal_file_append_first_tag(f);
3419 if (r < 0)
3420 goto fail;
feb12d3e 3421#endif
cec736d2
LP		 3422 }
3423
be7cdd8e 3424 if (mmap_cache_got_sigbus(f->mmap, f->cache_fd)) {
fa6ac760
LP		 3425 r = -EIO;
3426 goto fail;
3427 }
3428
7a24f3bf 3429 if (template && template->post_change_timer) {
e167d7fd
LP		 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);
7a24f3bf 3434
7a24f3bf
VC		 3435 if (r < 0)
3436 goto fail;
3437 }
3438
f8e2f4d6 3439 /* The file is opened now successfully, thus we take possession of any passed in fd. */
5d1ce257
LP		 3440 f->close_fd = true;
3441
0559d3a5 3442 *ret = f;
cec736d2
LP		 3443 return 0;
3444
3445fail:
be7cdd8e 3446 if (f->cache_fd && mmap_cache_got_sigbus(f->mmap, f->cache_fd))
fa6ac760
LP		 3447 r = -EIO;
3448
69a3a6fd 3449 (void) journal_file_close(f);
cec736d2
LP		 3450
3451 return r;
3452}
0ac38b70 3453
b58c888f 3454int journal_file_rotate(JournalFile **f, bool compress, bool seal, Set *deferred_closes) {
57535f47 3455 _cleanup_free_ char *p = NULL;
0ac38b70
LP		 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
5d1ce257 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
13e785f7 3469 * rotation, since we don't know the actual path, and couldn't rename the file hence. */
5d1ce257
LP		 3470 if (path_startswith(old_file->path, "/proc/self/fd"))
3471 return -EINVAL;
3472
0ac38b70
LP		 3473 if (!endswith(old_file->path, ".journal"))
3474 return -EINVAL;
3475
3476 l = strlen(old_file->path);
57535f47
ZJS		 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)
0ac38b70
LP		 3483 return -ENOMEM;
3484
2678031a
LP		 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. */
0ac38b70 3488 r = rename(old_file->path, p);
2678031a 3489 if (r < 0 && errno != ENOENT)
0ac38b70
LP		 3490 return -errno;
3491
1fcefd88
LP		 3492 /* Sync the rename to disk */
3493 (void) fsync_directory_of_file(old_file->fd);
3494
8eb85171
VC		 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;
0ac38b70 3502
f27a3864
LP		 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
5d1ce257 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);
b58c888f
VC		 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);
0ac38b70
LP		 3515
3516 *f = new_file;
3517 return r;
3518}
3519
9447a7f1
LP		 3520int journal_file_open_reliably(
3521 const char *fname,
3522 int flags,
3523 mode_t mode,
7560fffc 3524 bool compress,
baed47c3 3525 bool seal,
4a92baf3 3526 JournalMetrics *metrics,
27370278 3527 MMapCache *mmap_cache,
b58c888f 3528 Set *deferred_closes,
9447a7f1
LP		 3529 JournalFile *template,
3530 JournalFile **ret) {
3531
3532 int r;
3533 size_t l;
ed375beb 3534 _cleanup_free_ char *p = NULL;
9447a7f1 3535
5d1ce257 3536 r = journal_file_open(-1, fname, flags, mode, compress, seal, metrics, mmap_cache, deferred_closes, template, ret);
288359db 3537 if (!IN_SET(r,
b288cdeb
ZJS		 3538 -EBADMSG, /* Corrupted */
3539 -ENODATA, /* Truncated */
3540 -EHOSTDOWN, /* Other machine */
3541 -EPROTONOSUPPORT, /* Incompatible feature */
3542 -EBUSY, /* Unclean shutdown */
3543 -ESHUTDOWN, /* Already archived */
288359db 3544 -EIO, /* IO error, including SIGBUS on mmap */
ae739cc1
LP		 3545 -EIDRM, /* File has been deleted */
3546 -ETXTBSY)) /* File is from the future */
9447a7f1
LP		 3547 return r;
3548
3549 if ((flags & O_ACCMODE) == O_RDONLY)
3550 return r;
3551
3552 if (!(flags & O_CREAT))
3553 return r;
3554
7560fffc
LP		 3555 if (!endswith(fname, ".journal"))
3556 return r;
3557
5c70eab4
LP		 3558 /* The file is corrupted. Rotate it away and try it again (but only once) */
3559
9447a7f1 3560 l = strlen(fname);
d587eca5 3561 if (asprintf(&p, "%.*s@%016"PRIx64 "-%016"PRIx64 ".journal~",
57535f47 3562 (int) l - 8, fname,
d587eca5 3563 now(CLOCK_REALTIME),
9bf3b535 3564 random_u64()) < 0)
9447a7f1
LP		 3565 return -ENOMEM;
3566
65089b82 3567 if (rename(fname, p) < 0)
9447a7f1
LP		 3568 return -errno;
3569
f27a3864
LP		 3570 /* btrfs doesn't cope well with our write pattern and
3571 * fragments heavily. Let's defrag all files we rotate */
11689d2a 3572
a67d68b8 3573 (void) chattr_path(p, 0, FS_NOCOW_FL);
f27a3864
LP		 3574 (void) btrfs_defrag(p);
3575
65089b82 3576 log_warning_errno(r, "File %s corrupted or uncleanly shut down, renaming and replacing.", fname);
9447a7f1 3577
5d1ce257 3578 return journal_file_open(-1, fname, flags, mode, compress, seal, metrics, mmap_cache, deferred_closes, template, ret);
9447a7f1
LP		 3579}
3580
cf244689
LP		 3581int 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
cf244689 3599 n = journal_file_entry_n_items(o);
4faa7004
TA		 3600 /* alloca() can't take 0, hence let's allocate at least one */
3601 items = alloca(sizeof(EntryItem) * MAX(1u, n));
cf244689
LP		 3602
3603 for (i = 0; i < n; i++) {
4fd052ae
FC		 3604 uint64_t l, h;
3605 le64_t le_hash;
cf244689
LP		 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
d89c8fdf 3627 if (o->object.flags & OBJECT_COMPRESSION_MASK) {
3b1a55e1 3628#if defined(HAVE_XZ) || defined(HAVE_LZ4)
a7f7d1bd 3629 size_t rsize = 0;
cf244689 3630
d89c8fdf
ZJS		 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;
cf244689
LP		 3635
3636 data = from->compress_buffer;
3637 l = rsize;
3b1a55e1
ZJS		 3638#else
3639 return -EPROTONOSUPPORT;
3640#endif
cf244689
LP		 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
fa6ac760
LP		 3657 r = journal_file_append_entry_internal(to, &ts, xor_hash, items, n, seqnum, ret, offset);
3658
be7cdd8e 3659 if (mmap_cache_got_sigbus(to->mmap, to->cache_fd))
fa6ac760
LP		 3660 return -EIO;
3661
3662 return r;
cf244689 3663}
babfc091 3664
8580d1f7
LP		 3665void 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
babfc091 3680void journal_default_metrics(JournalMetrics *m, int fd) {
8580d1f7 3681 char a[FORMAT_BYTES_MAX], b[FORMAT_BYTES_MAX], c[FORMAT_BYTES_MAX], d[FORMAT_BYTES_MAX], e[FORMAT_BYTES_MAX];
babfc091 3682 struct statvfs ss;
8580d1f7 3683 uint64_t fs_size;
babfc091
LP		 3684
3685 assert(m);
3686 assert(fd >= 0);
3687
3688 if (fstatvfs(fd, &ss) >= 0)
3689 fs_size = ss.f_frsize * ss.f_blocks;
8580d1f7
LP		 3690 else {
3691 log_debug_errno(errno, "Failed to detremine disk size: %m");
3692 fs_size = 0;
3693 }
babfc091
LP		 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
8580d1f7 3710 if (m->max_use != 0 && m->max_use < JOURNAL_FILE_SIZE_MIN*2)
babfc091
LP		 3711 m->max_use = JOURNAL_FILE_SIZE_MIN*2;
3712 }
3713
8580d1f7
LP		 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
babfc091
LP		 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
8580d1f7
LP		 3728 if (m->max_size != 0) {
3729 if (m->max_size < JOURNAL_FILE_SIZE_MIN)
3730 m->max_size = JOURNAL_FILE_SIZE_MIN;
babfc091 3731
8580d1f7
LP		 3732 if (m->max_use != 0 && m->max_size*2 > m->max_use)
3733 m->max_use = m->max_size*2;
3734 }
babfc091
LP		 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
8580d1f7 3744 if (m->max_size != 0 && m->min_size > m->max_size)
babfc091
LP		 3745 m->max_size = m->min_size;
3746 }
3747
3748 if (m->keep_free == (uint64_t) -1) {
3749
3750 if (fs_size > 0) {
8621b110 3751 m->keep_free = PAGE_ALIGN(fs_size * 3 / 20); /* 15% of file system size */
babfc091
LP		 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
8580d1f7
LP		 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);
babfc091 3770}
08984293
LP		 3771
3772int journal_file_get_cutoff_realtime_usec(JournalFile *f, usec_t *from, usec_t *to) {
08984293 3773 assert(f);
c88cc6af 3774 assert(f->header);
08984293
LP		 3775 assert(from || to);
3776
3777 if (from) {
162566a4
LP		 3778 if (f->header->head_entry_realtime == 0)
3779 return -ENOENT;
08984293 3780
162566a4 3781 *from = le64toh(f->header->head_entry_realtime);
08984293
LP		 3782 }
3783
3784 if (to) {
162566a4
LP		 3785 if (f->header->tail_entry_realtime == 0)
3786 return -ENOENT;
08984293 3787
162566a4 3788 *to = le64toh(f->header->tail_entry_realtime);
08984293
LP		 3789 }
3790
3791 return 1;
3792}
3793
3794int journal_file_get_cutoff_monotonic_usec(JournalFile *f, sd_id128_t boot_id, usec_t *from, usec_t *to) {
08984293
LP		 3795 Object *o;
3796 uint64_t p;
3797 int r;
3798
3799 assert(f);
3800 assert(from || to);
3801
47838ab3 3802 r = find_data_object_by_boot_id(f, boot_id, &o, &p);
08984293
LP		 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}
dca6219e 3835
fb0951b0 3836bool journal_file_rotate_suggested(JournalFile *f, usec_t max_file_usec) {
dca6219e 3837 assert(f);
c88cc6af 3838 assert(f->header);
dca6219e
LP		 3839
3840 /* If we gained new header fields we gained new features,
3841 * hence suggest a rotation */
361f9cbc
LP		 3842 if (le64toh(f->header->header_size) < sizeof(Header)) {
3843 log_debug("%s uses an outdated header, suggesting rotation.", f->path);
dca6219e 3844 return true;
361f9cbc 3845 }
dca6219e
LP		 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))
361f9cbc 3854 if (le64toh(f->header->n_data) * 4ULL > (le64toh(f->header->data_hash_table_size) / sizeof(HashItem)) * 3ULL) {
507f22bd 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.",
361f9cbc
LP		 3856 f->path,
3857 100.0 * (double) le64toh(f->header->n_data) / ((double) (le64toh(f->header->data_hash_table_size) / sizeof(HashItem))),
507f22bd
ZJS		 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));
dca6219e 3862 return true;
361f9cbc 3863 }
dca6219e
LP		 3864
3865 if (JOURNAL_HEADER_CONTAINS(f->header, n_fields))
361f9cbc 3866 if (le64toh(f->header->n_fields) * 4ULL > (le64toh(f->header->field_hash_table_size) / sizeof(HashItem)) * 3ULL) {
507f22bd 3867 log_debug("Field hash table of %s has a fill level at %.1f (%"PRIu64" of %"PRIu64" items), suggesting rotation.",
361f9cbc
LP		 3868 f->path,
3869 100.0 * (double) le64toh(f->header->n_fields) / ((double) (le64toh(f->header->field_hash_table_size) / sizeof(HashItem))),
507f22bd
ZJS		 3870 le64toh(f->header->n_fields),
3871 le64toh(f->header->field_hash_table_size) / sizeof(HashItem));
dca6219e 3872 return true;
361f9cbc 3873 }
dca6219e 3874
0598fd4a
LP		 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
fb0951b0
LP		 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
dca6219e
LP		 3892 return false;
3893}
Unnamed repository; edit this file 'description' to name the repository.