X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fjournal%2Fjournal-file.c;h=b7e5cf0ab5bff9576aa74b2e155874f62e80612b;hp=13fc8edea9ff25c923d819924b662cca35c22ea9;hb=fa28bc2df724e4aff46d19cb7aa732cc64c71061;hpb=f274ece0f76b5709408821e317e87aef76123db6 diff --git a/src/journal/journal-file.c b/src/journal/journal-file.c index 13fc8edea..b7e5cf0ab 100644 --- a/src/journal/journal-file.c +++ b/src/journal/journal-file.c @@ -44,7 +44,7 @@ #define COMPRESSION_SIZE_THRESHOLD (512ULL) /* This is the minimum journal file size */ -#define JOURNAL_FILE_SIZE_MIN (64ULL*1024ULL) /* 64 KiB */ +#define JOURNAL_FILE_SIZE_MIN (4ULL*1024ULL*1024ULL) /* 4 MiB */ /* These are the lower and upper bounds if we deduce the max_use value * from the file system size */ @@ -68,6 +68,53 @@ /* How many entries to keep in the entry array chain cache at max */ #define CHAIN_CACHE_MAX 20 +/* How much to increase the journal file size at once each time we allocate something new. */ +#define FILE_SIZE_INCREASE (8ULL*1024ULL*1024ULL) /* 8MB */ + +static int journal_file_set_online(JournalFile *f) { + assert(f); + + if (!f->writable) + return -EPERM; + + if (!(f->fd >= 0 && f->header)) + return -EINVAL; + + switch(f->header->state) { + case STATE_ONLINE: + return 0; + + case STATE_OFFLINE: + f->header->state = STATE_ONLINE; + fsync(f->fd); + return 0; + + default: + return -EINVAL; + } +} + +int journal_file_set_offline(JournalFile *f) { + assert(f); + + if (!f->writable) + return -EPERM; + + if (!(f->fd >= 0 && f->header)) + return -EINVAL; + + if (f->header->state != STATE_ONLINE) + return 0; + + fsync(f->fd); + + f->header->state = STATE_OFFLINE; + + fsync(f->fd); + + return 0; +} + void journal_file_close(JournalFile *f) { assert(f); @@ -81,16 +128,10 @@ void journal_file_close(JournalFile *f) { if (f->mmap && f->fd >= 0) mmap_cache_close_fd(f->mmap, f->fd); - if (f->writable && f->fd >= 0) - fdatasync(f->fd); - - if (f->header) { - /* Mark the file offline. Don't override the archived state if it already is set */ - if (f->writable && f->header->state == STATE_ONLINE) - f->header->state = STATE_OFFLINE; + journal_file_set_offline(f); + if (f->header) munmap(f->header, PAGE_ALIGN(sizeof(Header))); - } if (f->fd >= 0) close_nointr_nofail(f->fd); @@ -177,11 +218,10 @@ static int journal_file_refresh_header(JournalFile *f) { f->header->boot_id = boot_id; - f->header->state = STATE_ONLINE; + journal_file_set_online(f); /* Sync the online state to disk */ - msync(f->header, PAGE_ALIGN(sizeof(Header)), MS_SYNC); - fdatasync(f->fd); + fsync(f->fd); return 0; } @@ -295,12 +335,10 @@ static int journal_file_allocate(JournalFile *f, uint64_t offset, uint64_t size) if (new_size <= old_size) return 0; - if (f->metrics.max_size > 0 && - new_size > f->metrics.max_size) + if (f->metrics.max_size > 0 && new_size > f->metrics.max_size) return -E2BIG; - if (new_size > f->metrics.min_size && - f->metrics.keep_free > 0) { + if (new_size > f->metrics.min_size && f->metrics.keep_free > 0) { struct statvfs svfs; if (fstatvfs(f->fd, &svfs) >= 0) { @@ -318,6 +356,11 @@ static int journal_file_allocate(JournalFile *f, uint64_t offset, uint64_t size) } } + /* Increase by larger blocks at once */ + new_size = ((new_size+FILE_SIZE_INCREASE-1) / FILE_SIZE_INCREASE) * FILE_SIZE_INCREASE; + if (f->metrics.max_size > 0 && new_size > f->metrics.max_size) + new_size = f->metrics.max_size; + /* Note that the glibc fallocate() fallback is very inefficient, hence we try to minimize the allocation area as we can. */ @@ -355,7 +398,7 @@ static int journal_file_move_to(JournalFile *f, int context, bool keep_always, u static uint64_t minimum_header_size(Object *o) { - static uint64_t table[] = { + static const uint64_t table[] = { [OBJECT_DATA] = sizeof(DataObject), [OBJECT_FIELD] = sizeof(FieldObject), [OBJECT_ENTRY] = sizeof(EntryObject), @@ -457,6 +500,10 @@ int journal_file_append_object(JournalFile *f, int type, uint64_t size, Object * assert(offset); assert(ret); + r = journal_file_set_online(f); + if (r < 0) + return r; + p = le64toh(f->header->tail_object_offset); if (p == 0) p = le64toh(f->header->header_size); @@ -507,7 +554,7 @@ static int journal_file_setup_data_hash_table(JournalFile *f) { if (s < DEFAULT_DATA_HASH_TABLE_SIZE) s = DEFAULT_DATA_HASH_TABLE_SIZE; - log_debug("Reserving %llu entries in hash table.", (unsigned long long) (s / sizeof(HashItem))); + log_debug("Reserving %"PRIu64" entries in hash table.", s / sizeof(HashItem)); r = journal_file_append_object(f, OBJECT_DATA_HASH_TABLE, @@ -865,6 +912,8 @@ static int journal_file_append_field( osize = offsetof(Object, field.payload) + size; r = journal_file_append_object(f, OBJECT_FIELD, osize, &o, &p); + if (r < 0) + return r; o->field.hash = htole64(hash); memcpy(o->field.payload, field, size); @@ -943,7 +992,7 @@ static int journal_file_append_data( o->object.size = htole64(offsetof(Object, data.payload) + rsize); o->object.flags |= OBJECT_COMPRESSED; - log_debug("Compressed data object %lu -> %lu", (unsigned long) size, (unsigned long) rsize); + log_debug("Compressed data object %"PRIu64" -> %"PRIu64, size, rsize); } } #endif @@ -961,7 +1010,10 @@ static int journal_file_append_data( if (r < 0) return r; - eq = memchr(data, '=', size); + if (!data) + eq = NULL; + else + eq = memchr(data, '=', size); if (eq && eq > data) { uint64_t fp; Object *fo; @@ -1164,7 +1216,7 @@ static int journal_file_link_entry(JournalFile *f, Object *o, uint64_t offset) { if (r < 0) return r; - /* log_debug("=> %s seqnr=%lu n_entries=%lu", f->path, (unsigned long) o->entry.seqnum, (unsigned long) f->header->n_entries); */ + /* log_debug("=> %s seqnr=%"PRIu64" n_entries=%"PRIu64, f->path, o->entry.seqnum, f->header->n_entries); */ if (f->header->head_entry_realtime == 0) f->header->head_entry_realtime = o->entry.realtime; @@ -1267,9 +1319,6 @@ int journal_file_append_entry(JournalFile *f, const dual_timestamp *ts, const st assert(f); assert(iovec || n_iovec == 0); - if (!f->writable) - return -EPERM; - if (!ts) { dual_timestamp_get(&_ts); ts = &_ts; @@ -1286,7 +1335,7 @@ int journal_file_append_entry(JournalFile *f, const dual_timestamp *ts, const st #endif /* alloca() can't take 0, hence let's allocate at least one */ - items = alloca(sizeof(EntryItem) * MAX(1, n_iovec)); + items = alloca(sizeof(EntryItem) * MAX(1u, n_iovec)); for (i = 0; i < n_iovec; i++) { uint64_t p; @@ -1303,7 +1352,7 @@ int journal_file_append_entry(JournalFile *f, const dual_timestamp *ts, const st /* Order by the position on disk, in order to improve seek * times for rotating media. */ - qsort(items, n_iovec, sizeof(EntryItem), entry_item_cmp); + qsort_safe(items, n_iovec, sizeof(EntryItem), entry_item_cmp); r = journal_file_append_entry_internal(f, ts, xor_hash, items, n_iovec, seqnum, ret, offset); @@ -1317,6 +1366,7 @@ typedef struct ChainCacheItem { uint64_t array; /* the cached array */ uint64_t begin; /* the first item in the cached array */ uint64_t total; /* the total number of items in all arrays before this one in the chain */ + uint64_t last_index; /* the last index we looked at, to optimize locality when bisecting */ } ChainCacheItem; static void chain_cache_put( @@ -1325,7 +1375,8 @@ static void chain_cache_put( uint64_t first, uint64_t array, uint64_t begin, - uint64_t total) { + uint64_t total, + uint64_t last_index) { if (!ci) { /* If the chain item to cache for this chain is the @@ -1353,12 +1404,14 @@ static void chain_cache_put( ci->array = array; ci->begin = begin; ci->total = total; + ci->last_index = last_index; } -static int generic_array_get(JournalFile *f, - uint64_t first, - uint64_t i, - Object **ret, uint64_t *offset) { +static int generic_array_get( + JournalFile *f, + uint64_t first, + uint64_t i, + Object **ret, uint64_t *offset) { Object *o; uint64_t p = 0, a, t = 0; @@ -1399,7 +1452,7 @@ static int generic_array_get(JournalFile *f, found: /* Let's cache this item for the next invocation */ - chain_cache_put(f->chain_cache, ci, first, a, o->entry_array.items[0], t); + chain_cache_put(f->chain_cache, ci, first, a, o->entry_array.items[0], t, i); r = journal_file_move_to_object(f, OBJECT_ENTRY, p, &o); if (r < 0) @@ -1414,11 +1467,12 @@ found: return 1; } -static int generic_array_get_plus_one(JournalFile *f, - uint64_t extra, - uint64_t first, - uint64_t i, - Object **ret, uint64_t *offset) { +static int generic_array_get_plus_one( + JournalFile *f, + uint64_t extra, + uint64_t first, + uint64_t i, + Object **ret, uint64_t *offset) { Object *o; @@ -1449,17 +1503,18 @@ enum { TEST_RIGHT }; -static int generic_array_bisect(JournalFile *f, - uint64_t first, - uint64_t n, - uint64_t needle, - int (*test_object)(JournalFile *f, uint64_t p, uint64_t needle), - direction_t direction, - Object **ret, - uint64_t *offset, - uint64_t *idx) { - - uint64_t a, p, t = 0, i = 0, last_p = 0; +static int generic_array_bisect( + JournalFile *f, + uint64_t first, + uint64_t n, + uint64_t needle, + int (*test_object)(JournalFile *f, uint64_t p, uint64_t needle), + direction_t direction, + Object **ret, + uint64_t *offset, + uint64_t *idx) { + + uint64_t a, p, t = 0, i = 0, last_p = 0, last_index = (uint64_t) -1; bool subtract_one = false; Object *o, *array = NULL; int r; @@ -1484,7 +1539,7 @@ static int generic_array_bisect(JournalFile *f, return r; if (r == TEST_LEFT) { - /* OK, what we are looking for is right of th + /* OK, what we are looking for is right of the * begin of this EntryArray, so let's jump * straight to previously cached array in the * chain */ @@ -1492,6 +1547,7 @@ static int generic_array_bisect(JournalFile *f, a = ci->array; n -= ci->total; t = ci->total; + last_index = ci->last_index; } } @@ -1522,6 +1578,58 @@ static int generic_array_bisect(JournalFile *f, if (r == TEST_RIGHT) { left = 0; right -= 1; + + if (last_index != (uint64_t) -1) { + assert(last_index <= right); + + /* If we cached the last index we + * looked at, let's try to not to jump + * too wildly around and see if we can + * limit the range to look at early to + * the immediate neighbors of the last + * index we looked at. */ + + if (last_index > 0) { + uint64_t x = last_index - 1; + + p = le64toh(array->entry_array.items[x]); + if (p <= 0) + return -EBADMSG; + + r = test_object(f, p, needle); + if (r < 0) + return r; + + if (r == TEST_FOUND) + r = direction == DIRECTION_DOWN ? TEST_RIGHT : TEST_LEFT; + + if (r == TEST_RIGHT) + right = x; + else + left = x + 1; + } + + if (last_index < right) { + uint64_t y = last_index + 1; + + p = le64toh(array->entry_array.items[y]); + if (p <= 0) + return -EBADMSG; + + r = test_object(f, p, needle); + if (r < 0) + return r; + + if (r == TEST_FOUND) + r = direction == DIRECTION_DOWN ? TEST_RIGHT : TEST_LEFT; + + if (r == TEST_RIGHT) + right = y; + else + left = y + 1; + } + } + for (;;) { if (left == right) { if (direction == DIRECTION_UP) @@ -1532,8 +1640,8 @@ static int generic_array_bisect(JournalFile *f, } assert(left < right); - i = (left + right) / 2; + p = le64toh(array->entry_array.items[i]); if (p <= 0) return -EBADMSG; @@ -1566,6 +1674,7 @@ static int generic_array_bisect(JournalFile *f, n -= k; t += k; + last_index = (uint64_t) -1; a = le64toh(array->entry_array.next_entry_array_offset); } @@ -1576,7 +1685,7 @@ found: return 0; /* Let's cache this item for the next invocation */ - chain_cache_put(f->chain_cache, ci, first, a, array->entry_array.items[0], t); + chain_cache_put(f->chain_cache, ci, first, a, array->entry_array.items[0], t, subtract_one ? (i > 0 ? i-1 : (uint64_t) -1) : i); if (subtract_one && i == 0) p = last_p; @@ -1601,16 +1710,18 @@ found: return 1; } -static int generic_array_bisect_plus_one(JournalFile *f, - uint64_t extra, - uint64_t first, - uint64_t n, - uint64_t needle, - int (*test_object)(JournalFile *f, uint64_t p, uint64_t needle), - direction_t direction, - Object **ret, - uint64_t *offset, - uint64_t *idx) { + +static int generic_array_bisect_plus_one( + JournalFile *f, + uint64_t extra, + uint64_t first, + uint64_t n, + uint64_t needle, + int (*test_object)(JournalFile *f, uint64_t p, uint64_t needle), + direction_t direction, + Object **ret, + uint64_t *offset, + uint64_t *idx) { int r; bool step_back = false; @@ -1673,7 +1784,7 @@ found: return 1; } -static int test_object_offset(JournalFile *f, uint64_t p, uint64_t needle) { +_pure_ static int test_object_offset(JournalFile *f, uint64_t p, uint64_t needle) { assert(f); assert(p > 0); @@ -1791,6 +1902,17 @@ static int test_object_monotonic(JournalFile *f, uint64_t p, uint64_t needle) { return TEST_RIGHT; } +static inline int find_data_object_by_boot_id( + JournalFile *f, + sd_id128_t boot_id, + Object **o, + uint64_t *b) { + char t[sizeof("_BOOT_ID=")-1 + 32 + 1] = "_BOOT_ID="; + + sd_id128_to_string(boot_id, t + 9); + return journal_file_find_data_object(f, t, sizeof(t) - 1, o, b); +} + int journal_file_move_to_entry_by_monotonic( JournalFile *f, sd_id128_t boot_id, @@ -1799,14 +1921,12 @@ int journal_file_move_to_entry_by_monotonic( Object **ret, uint64_t *offset) { - char t[9+32+1] = "_BOOT_ID="; Object *o; int r; assert(f); - sd_id128_to_string(boot_id, t + 9); - r = journal_file_find_data_object(f, t, strlen(t), &o, NULL); + r = find_data_object_by_boot_id(f, boot_id, &o, NULL); if (r < 0) return r; if (r == 0) @@ -2020,7 +2140,6 @@ int journal_file_move_to_entry_by_monotonic_for_data( direction_t direction, Object **ret, uint64_t *offset) { - char t[9+32+1] = "_BOOT_ID="; Object *o, *d; int r; uint64_t b, z; @@ -2028,8 +2147,7 @@ int journal_file_move_to_entry_by_monotonic_for_data( assert(f); /* First, seek by time */ - sd_id128_to_string(boot_id, t + 9); - r = journal_file_find_data_object(f, t, strlen(t), &o, &b); + r = find_data_object_by_boot_id(f, boot_id, &o, &b); if (r < 0) return r; if (r == 0) @@ -2181,10 +2299,10 @@ void journal_file_dump(JournalFile *f) { break; case OBJECT_ENTRY: - printf("Type: OBJECT_ENTRY seqnum=%llu monotonic=%llu realtime=%llu\n", - (unsigned long long) le64toh(o->entry.seqnum), - (unsigned long long) le64toh(o->entry.monotonic), - (unsigned long long) le64toh(o->entry.realtime)); + printf("Type: OBJECT_ENTRY seqnum=%"PRIu64" monotonic=%"PRIu64" realtime=%"PRIu64"\n", + le64toh(o->entry.seqnum), + le64toh(o->entry.monotonic), + le64toh(o->entry.realtime)); break; case OBJECT_FIELD_HASH_TABLE: @@ -2200,9 +2318,9 @@ void journal_file_dump(JournalFile *f) { break; case OBJECT_TAG: - printf("Type: OBJECT_TAG seqnum=%llu epoch=%llu\n", - (unsigned long long) le64toh(o->tag.seqnum), - (unsigned long long) le64toh(o->tag.epoch)); + printf("Type: OBJECT_TAG seqnum=%"PRIu64" epoch=%"PRIu64"\n", + le64toh(o->tag.seqnum), + le64toh(o->tag.epoch)); break; default: @@ -2224,9 +2342,18 @@ fail: log_error("File corrupt"); } +static const char* format_timestamp_safe(char *buf, size_t l, usec_t t) { + const char *x; + + x = format_timestamp(buf, l, t); + if (x) + return x; + return " --- "; +} + void journal_file_print_header(JournalFile *f) { - char a[33], b[33], c[33]; - char x[FORMAT_TIMESTAMP_MAX], y[FORMAT_TIMESTAMP_MAX]; + char a[33], b[33], c[33], d[33]; + char x[FORMAT_TIMESTAMP_MAX], y[FORMAT_TIMESTAMP_MAX], z[FORMAT_TIMESTAMP_MAX]; struct stat st; char bytes[FORMAT_BYTES_MAX]; @@ -2240,22 +2367,23 @@ void journal_file_print_header(JournalFile *f) { "State: %s\n" "Compatible Flags:%s%s\n" "Incompatible Flags:%s%s\n" - "Header size: %llu\n" - "Arena size: %llu\n" - "Data Hash Table Size: %llu\n" - "Field Hash Table Size: %llu\n" + "Header size: %"PRIu64"\n" + "Arena size: %"PRIu64"\n" + "Data Hash Table Size: %"PRIu64"\n" + "Field Hash Table Size: %"PRIu64"\n" "Rotate Suggested: %s\n" - "Head Sequential Number: %llu\n" - "Tail Sequential Number: %llu\n" + "Head Sequential Number: %"PRIu64"\n" + "Tail Sequential Number: %"PRIu64"\n" "Head Realtime Timestamp: %s\n" "Tail Realtime Timestamp: %s\n" - "Objects: %llu\n" - "Entry Objects: %llu\n", + "Tail Monotonic Timestamp: %s\n" + "Objects: %"PRIu64"\n" + "Entry Objects: %"PRIu64"\n", f->path, sd_id128_to_string(f->header->file_id, a), sd_id128_to_string(f->header->machine_id, b), sd_id128_to_string(f->header->boot_id, c), - sd_id128_to_string(f->header->seqnum_id, c), + sd_id128_to_string(f->header->seqnum_id, d), f->header->state == STATE_OFFLINE ? "OFFLINE" : f->header->state == STATE_ONLINE ? "ONLINE" : f->header->state == STATE_ARCHIVED ? "ARCHIVED" : "UNKNOWN", @@ -2263,36 +2391,37 @@ void journal_file_print_header(JournalFile *f) { (le32toh(f->header->compatible_flags) & ~HEADER_COMPATIBLE_SEALED) ? " ???" : "", JOURNAL_HEADER_COMPRESSED(f->header) ? " COMPRESSED" : "", (le32toh(f->header->incompatible_flags) & ~HEADER_INCOMPATIBLE_COMPRESSED) ? " ???" : "", - (unsigned long long) le64toh(f->header->header_size), - (unsigned long long) le64toh(f->header->arena_size), - (unsigned long long) le64toh(f->header->data_hash_table_size) / sizeof(HashItem), - (unsigned long long) le64toh(f->header->field_hash_table_size) / sizeof(HashItem), + le64toh(f->header->header_size), + le64toh(f->header->arena_size), + le64toh(f->header->data_hash_table_size) / sizeof(HashItem), + le64toh(f->header->field_hash_table_size) / sizeof(HashItem), yes_no(journal_file_rotate_suggested(f, 0)), - (unsigned long long) le64toh(f->header->head_entry_seqnum), - (unsigned long long) le64toh(f->header->tail_entry_seqnum), - format_timestamp(x, sizeof(x), le64toh(f->header->head_entry_realtime)), - format_timestamp(y, sizeof(y), le64toh(f->header->tail_entry_realtime)), - (unsigned long long) le64toh(f->header->n_objects), - (unsigned long long) le64toh(f->header->n_entries)); + le64toh(f->header->head_entry_seqnum), + le64toh(f->header->tail_entry_seqnum), + format_timestamp_safe(x, sizeof(x), le64toh(f->header->head_entry_realtime)), + format_timestamp_safe(y, sizeof(y), le64toh(f->header->tail_entry_realtime)), + format_timespan(z, sizeof(z), le64toh(f->header->tail_entry_monotonic), USEC_PER_MSEC), + le64toh(f->header->n_objects), + le64toh(f->header->n_entries)); if (JOURNAL_HEADER_CONTAINS(f->header, n_data)) - printf("Data Objects: %llu\n" + printf("Data Objects: %"PRIu64"\n" "Data Hash Table Fill: %.1f%%\n", - (unsigned long long) le64toh(f->header->n_data), + le64toh(f->header->n_data), 100.0 * (double) le64toh(f->header->n_data) / ((double) (le64toh(f->header->data_hash_table_size) / sizeof(HashItem)))); if (JOURNAL_HEADER_CONTAINS(f->header, n_fields)) - printf("Field Objects: %llu\n" + printf("Field Objects: %"PRIu64"\n" "Field Hash Table Fill: %.1f%%\n", - (unsigned long long) le64toh(f->header->n_fields), + le64toh(f->header->n_fields), 100.0 * (double) le64toh(f->header->n_fields) / ((double) (le64toh(f->header->field_hash_table_size) / sizeof(HashItem)))); if (JOURNAL_HEADER_CONTAINS(f->header, n_tags)) - printf("Tag Objects: %llu\n", - (unsigned long long) le64toh(f->header->n_tags)); + printf("Tag Objects: %"PRIu64"\n", + le64toh(f->header->n_tags)); if (JOURNAL_HEADER_CONTAINS(f->header, n_entry_arrays)) - printf("Entry Array Objects: %llu\n", - (unsigned long long) le64toh(f->header->n_entry_arrays)); + printf("Entry Array Objects: %"PRIu64"\n", + le64toh(f->header->n_entry_arrays)); if (fstat(f->fd, &st) >= 0) printf("Disk usage: %s\n", format_bytes(bytes, sizeof(bytes), (off_t) st.st_blocks * 512ULL)); @@ -2492,7 +2621,7 @@ fail: } int journal_file_rotate(JournalFile **f, bool compress, bool seal) { - char *p; + _cleanup_free_ char *p = NULL; size_t l; JournalFile *old_file, *new_file = NULL; int r; @@ -2509,22 +2638,15 @@ int journal_file_rotate(JournalFile **f, bool compress, bool seal) { return -EINVAL; l = strlen(old_file->path); - - p = new(char, l + 1 + 32 + 1 + 16 + 1 + 16 + 1); - if (!p) + r = asprintf(&p, "%.*s@" SD_ID128_FORMAT_STR "-%016"PRIx64"-%016"PRIx64".journal", + (int) l - 8, old_file->path, + SD_ID128_FORMAT_VAL(old_file->header->seqnum_id), + le64toh((*f)->header->head_entry_seqnum), + le64toh((*f)->header->head_entry_realtime)); + if (r < 0) return -ENOMEM; - memcpy(p, old_file->path, l - 8); - p[l-8] = '@'; - sd_id128_to_string(old_file->header->seqnum_id, p + l - 8 + 1); - snprintf(p + l - 8 + 1 + 32, 1 + 16 + 1 + 16 + 8 + 1, - "-%016llx-%016llx.journal", - (unsigned long long) le64toh((*f)->header->head_entry_seqnum), - (unsigned long long) le64toh((*f)->header->head_entry_realtime)); - r = rename(old_file->path, p); - free(p); - if (r < 0) return -errno; @@ -2550,7 +2672,7 @@ int journal_file_open_reliably( int r; size_t l; - char *p; + _cleanup_free_ char *p = NULL; r = journal_file_open(fname, flags, mode, compress, seal, metrics, mmap_cache, template, ret); @@ -2575,13 +2697,12 @@ int journal_file_open_reliably( l = strlen(fname); if (asprintf(&p, "%.*s@%016llx-%016llx.journal~", - (int) (l-8), fname, + (int) l - 8, fname, (unsigned long long) now(CLOCK_REALTIME), random_ull()) < 0) return -ENOMEM; r = rename(fname, p); - free(p); if (r < 0) return -errno; @@ -2609,12 +2730,9 @@ int journal_file_copy_entry(JournalFile *from, JournalFile *to, Object *o, uint6 ts.monotonic = le64toh(o->entry.monotonic); ts.realtime = le64toh(o->entry.realtime); - if (to->tail_entry_monotonic_valid && - ts.monotonic < le64toh(to->header->tail_entry_monotonic)) - return -EINVAL; - n = journal_file_entry_n_items(o); - items = alloca(sizeof(EntryItem) * n); + /* alloca() can't take 0, hence let's allocate at least one */ + items = alloca(sizeof(EntryItem) * MAX(1u, n)); for (i = 0; i < n; i++) { uint64_t l, h; @@ -2730,7 +2848,7 @@ void journal_default_metrics(JournalMetrics *m, int fd) { if (m->keep_free == (uint64_t) -1) { if (fs_size > 0) { - m->keep_free = PAGE_ALIGN(fs_size / 20); /* 5% of file system size */ + m->keep_free = PAGE_ALIGN(fs_size * 3 / 20); /* 15% of file system size */ if (m->keep_free > DEFAULT_KEEP_FREE_UPPER) m->keep_free = DEFAULT_KEEP_FREE_UPPER; @@ -2768,7 +2886,6 @@ int journal_file_get_cutoff_realtime_usec(JournalFile *f, usec_t *from, usec_t * } int journal_file_get_cutoff_monotonic_usec(JournalFile *f, sd_id128_t boot_id, usec_t *from, usec_t *to) { - char t[9+32+1] = "_BOOT_ID="; Object *o; uint64_t p; int r; @@ -2776,9 +2893,7 @@ int journal_file_get_cutoff_monotonic_usec(JournalFile *f, sd_id128_t boot_id, u assert(f); assert(from || to); - sd_id128_to_string(boot_id, t + 9); - - r = journal_file_find_data_object(f, t, strlen(t), &o, &p); + r = find_data_object_by_boot_id(f, boot_id, &o, &p); if (r <= 0) return r; @@ -2830,23 +2945,23 @@ bool journal_file_rotate_suggested(JournalFile *f, usec_t max_file_usec) { if (JOURNAL_HEADER_CONTAINS(f->header, n_data)) if (le64toh(f->header->n_data) * 4ULL > (le64toh(f->header->data_hash_table_size) / sizeof(HashItem)) * 3ULL) { - log_debug("Data hash table of %s has a fill level at %.1f (%llu of %llu items, %llu file size, %llu bytes per hash table item), suggesting rotation.", + 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.", f->path, 100.0 * (double) le64toh(f->header->n_data) / ((double) (le64toh(f->header->data_hash_table_size) / sizeof(HashItem))), - (unsigned long long) le64toh(f->header->n_data), - (unsigned long long) (le64toh(f->header->data_hash_table_size) / sizeof(HashItem)), - (unsigned long long) (f->last_stat.st_size), - (unsigned long long) (f->last_stat.st_size / le64toh(f->header->n_data))); + le64toh(f->header->n_data), + le64toh(f->header->data_hash_table_size) / sizeof(HashItem), + (unsigned long long) f->last_stat.st_size, + f->last_stat.st_size / le64toh(f->header->n_data)); return true; } if (JOURNAL_HEADER_CONTAINS(f->header, n_fields)) if (le64toh(f->header->n_fields) * 4ULL > (le64toh(f->header->field_hash_table_size) / sizeof(HashItem)) * 3ULL) { - log_debug("Field hash table of %s has a fill level at %.1f (%llu of %llu items), suggesting rotation.", + log_debug("Field hash table of %s has a fill level at %.1f (%"PRIu64" of %"PRIu64" items), suggesting rotation.", f->path, 100.0 * (double) le64toh(f->header->n_fields) / ((double) (le64toh(f->header->field_hash_table_size) / sizeof(HashItem))), - (unsigned long long) le64toh(f->header->n_fields), - (unsigned long long) (le64toh(f->header->field_hash_table_size) / sizeof(HashItem))); + le64toh(f->header->n_fields), + le64toh(f->header->field_hash_table_size) / sizeof(HashItem)); return true; }