src/journal/journal-def.h

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