src/journal/journal-def.h

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 #pragma once
   3
   4 /***
   5   This file is part of systemd.
   6
   7   Copyright 2011 Lennart Poettering
   8 ***/
   9
  10 #include "sd-id128.h"
  11
  12 #include "macro.h"
  13 #include "sparse-endian.h"
  14
  15 /*
  16  * If you change this file you probably should also change its documentation:
  17  *
  18  * http://www.freedesktop.org/wiki/Software/systemd/journal-files
  19  *
  20  */
  21
  22 typedef struct Header Header;
  23
  24 typedef struct ObjectHeader ObjectHeader;
  25 typedef union Object Object;
  26
  27 typedef struct DataObject DataObject;
  28 typedef struct FieldObject FieldObject;
  29 typedef struct EntryObject EntryObject;
  30 typedef struct HashTableObject HashTableObject;
  31 typedef struct EntryArrayObject EntryArrayObject;
  32 typedef struct TagObject TagObject;
  33
  34 typedef struct EntryItem EntryItem;
  35 typedef struct HashItem HashItem;
  36
  37 typedef struct FSSHeader FSSHeader;
  38
  39 /* Object types */
  40 typedef enum ObjectType {
  41         OBJECT_UNUSED, /* also serves as "any type" or "additional context" */
  42         OBJECT_DATA,
  43         OBJECT_FIELD,
  44         OBJECT_ENTRY,
  45         OBJECT_DATA_HASH_TABLE,
  46         OBJECT_FIELD_HASH_TABLE,
  47         OBJECT_ENTRY_ARRAY,
  48         OBJECT_TAG,
  49         _OBJECT_TYPE_MAX
  50 } ObjectType;
  51
  52 /* Object flags */
  53 enum {
  54         OBJECT_COMPRESSED_XZ = 1 << 0,
  55         OBJECT_COMPRESSED_LZ4 = 1 << 1,
  56         _OBJECT_COMPRESSED_MAX
  57 };
  58
  59 #define OBJECT_COMPRESSION_MASK (OBJECT_COMPRESSED_XZ | OBJECT_COMPRESSED_LZ4)
  60
  61 struct ObjectHeader {
  62         uint8_t type;
  63         uint8_t flags;
  64         uint8_t reserved[6];
  65         le64_t size;
  66         uint8_t payload[];
  67 } _packed_;
  68
  69 struct DataObject {
  70         ObjectHeader object;
  71         le64_t hash;
  72         le64_t next_hash_offset;
  73         le64_t next_field_offset;
  74         le64_t entry_offset; /* the first array entry we store inline */
  75         le64_t entry_array_offset;
  76         le64_t n_entries;
  77         uint8_t payload[];
  78 } _packed_;
  79
  80 struct FieldObject {
  81         ObjectHeader object;
  82         le64_t hash;
  83         le64_t next_hash_offset;
  84         le64_t head_data_offset;
  85         uint8_t payload[];
  86 } _packed_;
  87
  88 struct EntryItem {
  89         le64_t object_offset;
  90         le64_t hash;
  91 } _packed_;
  92
  93 struct EntryObject {
  94         ObjectHeader object;
  95         le64_t seqnum;
  96         le64_t realtime;
  97         le64_t monotonic;
  98         sd_id128_t boot_id;
  99         le64_t xor_hash;
 100         EntryItem items[];
 101 } _packed_;
 102
 103 struct HashItem {
 104         le64_t head_hash_offset;
 105         le64_t tail_hash_offset;
 106 } _packed_;
 107
 108 struct HashTableObject {
 109         ObjectHeader object;
 110         HashItem items[];
 111 } _packed_;
 112
 113 struct EntryArrayObject {
 114         ObjectHeader object;
 115         le64_t next_entry_array_offset;
 116         le64_t items[];
 117 } _packed_;
 118
 119 #define TAG_LENGTH (256/8)
 120
 121 struct TagObject {
 122         ObjectHeader object;
 123         le64_t seqnum;
 124         le64_t epoch;
 125         uint8_t tag[TAG_LENGTH]; /* SHA-256 HMAC */
 126 } _packed_;
 127
 128 union Object {
 129         ObjectHeader object;
 130         DataObject data;
 131         FieldObject field;
 132         EntryObject entry;
 133         HashTableObject hash_table;
 134         EntryArrayObject entry_array;
 135         TagObject tag;
 136 };
 137
 138 enum {
 139         STATE_OFFLINE = 0,
 140         STATE_ONLINE = 1,
 141         STATE_ARCHIVED = 2,
 142         _STATE_MAX
 143 };
 144
 145 /* Header flags */
 146 enum {
 147         HEADER_INCOMPATIBLE_COMPRESSED_XZ = 1 << 0,
 148         HEADER_INCOMPATIBLE_COMPRESSED_LZ4 = 1 << 1,
 149 };
 150
 151 #define HEADER_INCOMPATIBLE_ANY (HEADER_INCOMPATIBLE_COMPRESSED_XZ|HEADER_INCOMPATIBLE_COMPRESSED_LZ4)
 152
 153 #if HAVE_XZ && HAVE_LZ4
 154 #  define HEADER_INCOMPATIBLE_SUPPORTED HEADER_INCOMPATIBLE_ANY
 155 #elif HAVE_XZ
 156 #  define HEADER_INCOMPATIBLE_SUPPORTED HEADER_INCOMPATIBLE_COMPRESSED_XZ
 157 #elif HAVE_LZ4
 158 #  define HEADER_INCOMPATIBLE_SUPPORTED HEADER_INCOMPATIBLE_COMPRESSED_LZ4
 159 #else
 160 #  define HEADER_INCOMPATIBLE_SUPPORTED 0
 161 #endif
 162
 163 enum {
 164         HEADER_COMPATIBLE_SEALED = 1
 165 };
 166
 167 #define HEADER_COMPATIBLE_ANY HEADER_COMPATIBLE_SEALED
 168 #if HAVE_GCRYPT
 169 #  define HEADER_COMPATIBLE_SUPPORTED HEADER_COMPATIBLE_SEALED
 170 #else
 171 #  define HEADER_COMPATIBLE_SUPPORTED 0
 172 #endif
 173
 174 #define HEADER_SIGNATURE ((char[]) { 'L', 'P', 'K', 'S', 'H', 'H', 'R', 'H' })
 175
 176 struct Header {
 177         uint8_t signature[8]; /* "LPKSHHRH" */
 178         le32_t compatible_flags;
 179         le32_t incompatible_flags;
 180         uint8_t state;
 181         uint8_t reserved[7];
 182         sd_id128_t file_id;
 183         sd_id128_t machine_id;
 184         sd_id128_t boot_id;    /* last writer */
 185         sd_id128_t seqnum_id;
 186         le64_t header_size;
 187         le64_t arena_size;
 188         le64_t data_hash_table_offset;
 189         le64_t data_hash_table_size;
 190         le64_t field_hash_table_offset;
 191         le64_t field_hash_table_size;
 192         le64_t tail_object_offset;
 193         le64_t n_objects;
 194         le64_t n_entries;
 195         le64_t tail_entry_seqnum;
 196         le64_t head_entry_seqnum;
 197         le64_t entry_array_offset;
 198         le64_t head_entry_realtime;
 199         le64_t tail_entry_realtime;
 200         le64_t tail_entry_monotonic;
 201         /* Added in 187 */
 202         le64_t n_data;
 203         le64_t n_fields;
 204         /* Added in 189 */
 205         le64_t n_tags;
 206         le64_t n_entry_arrays;
 207
 208         /* Size: 240 */
 209 } _packed_;
 210
 211 #define FSS_HEADER_SIGNATURE ((char[]) { 'K', 'S', 'H', 'H', 'R', 'H', 'L', 'P' })
 212
 213 struct FSSHeader {
 214         uint8_t signature[8]; /* "KSHHRHLP" */
 215         le32_t compatible_flags;
 216         le32_t incompatible_flags;
 217         sd_id128_t machine_id;
 218         sd_id128_t boot_id;    /* last writer */
 219         le64_t header_size;
 220         le64_t start_usec;
 221         le64_t interval_usec;
 222         le16_t fsprg_secpar;
 223         le16_t reserved[3];
 224         le64_t fsprg_state_size;
 225 } _packed_;