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_ZSTD = 1 << 2,
  50         OBJECT_COMPRESSION_MASK = (OBJECT_COMPRESSED_XZ | OBJECT_COMPRESSED_LZ4 | OBJECT_COMPRESSED_ZSTD),
  51         _OBJECT_COMPRESSED_MAX = OBJECT_COMPRESSION_MASK,
  52 };
  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 #define DataObject__contents {                                          \
  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         }
  72
  73 struct DataObject DataObject__contents;
  74 struct DataObject__packed DataObject__contents _packed_;
  75 assert_cc(sizeof(struct DataObject) == sizeof(struct DataObject__packed));
  76
  77 #define FieldObject__contents {                 \
  78         ObjectHeader object;                    \
  79         le64_t hash;                            \
  80         le64_t next_hash_offset;                \
  81         le64_t head_data_offset;                \
  82         uint8_t payload[];                      \
  83 }
  84
  85 struct FieldObject FieldObject__contents;
  86 struct FieldObject__packed FieldObject__contents _packed_;
  87 assert_cc(sizeof(struct FieldObject) == sizeof(struct FieldObject__packed));
  88
  89 struct EntryItem {
  90         le64_t object_offset;
  91         le64_t hash;
  92 } _packed_;
  93
  94 #define EntryObject__contents { \
  95         ObjectHeader object;    \
  96         le64_t seqnum;          \
  97         le64_t realtime;        \
  98         le64_t monotonic;       \
  99         sd_id128_t boot_id;     \
 100         le64_t xor_hash;        \
 101         EntryItem items[];      \
 102         }
 103
 104 struct EntryObject EntryObject__contents;
 105 struct EntryObject__packed EntryObject__contents _packed_;
 106 assert_cc(sizeof(struct EntryObject) == sizeof(struct EntryObject__packed));
 107
 108 struct HashItem {
 109         le64_t head_hash_offset;
 110         le64_t tail_hash_offset;
 111 } _packed_;
 112
 113 struct HashTableObject {
 114         ObjectHeader object;
 115         HashItem items[];
 116 } _packed_;
 117
 118 struct EntryArrayObject {
 119         ObjectHeader object;
 120         le64_t next_entry_array_offset;
 121         le64_t items[];
 122 } _packed_;
 123
 124 #define TAG_LENGTH (256/8)
 125
 126 struct TagObject {
 127         ObjectHeader object;
 128         le64_t seqnum;
 129         le64_t epoch;
 130         uint8_t tag[TAG_LENGTH]; /* SHA-256 HMAC */
 131 } _packed_;
 132
 133 union Object {
 134         ObjectHeader object;
 135         DataObject data;
 136         FieldObject field;
 137         EntryObject entry;
 138         HashTableObject hash_table;
 139         EntryArrayObject entry_array;
 140         TagObject tag;
 141 };
 142
 143 enum {
 144         STATE_OFFLINE = 0,
 145         STATE_ONLINE = 1,
 146         STATE_ARCHIVED = 2,
 147         _STATE_MAX
 148 };
 149
 150 /* Header flags */
 151 enum {
 152         HEADER_INCOMPATIBLE_COMPRESSED_XZ   = 1 << 0,
 153         HEADER_INCOMPATIBLE_COMPRESSED_LZ4  = 1 << 1,
 154         HEADER_INCOMPATIBLE_KEYED_HASH      = 1 << 2,
 155         HEADER_INCOMPATIBLE_COMPRESSED_ZSTD = 1 << 3,
 156 };
 157
 158 #define HEADER_INCOMPATIBLE_ANY               \
 159         (HEADER_INCOMPATIBLE_COMPRESSED_XZ |  \
 160          HEADER_INCOMPATIBLE_COMPRESSED_LZ4 | \
 161          HEADER_INCOMPATIBLE_KEYED_HASH |     \
 162          HEADER_INCOMPATIBLE_COMPRESSED_ZSTD)
 163
 164 #if HAVE_XZ && HAVE_LZ4 && HAVE_ZSTD
 165 #  define HEADER_INCOMPATIBLE_SUPPORTED HEADER_INCOMPATIBLE_ANY
 166 #elif HAVE_XZ && HAVE_LZ4
 167 #  define HEADER_INCOMPATIBLE_SUPPORTED (HEADER_INCOMPATIBLE_COMPRESSED_XZ|HEADER_INCOMPATIBLE_COMPRESSED_LZ4|HEADER_INCOMPATIBLE_KEYED_HASH)
 168 #elif HAVE_XZ && HAVE_ZSTD
 169 #  define HEADER_INCOMPATIBLE_SUPPORTED (HEADER_INCOMPATIBLE_COMPRESSED_XZ|HEADER_INCOMPATIBLE_COMPRESSED_ZSTD|HEADER_INCOMPATIBLE_KEYED_HASH)
 170 #elif HAVE_LZ4 && HAVE_ZSTD
 171 #  define HEADER_INCOMPATIBLE_SUPPORTED (HEADER_INCOMPATIBLE_COMPRESSED_LZ4|HEADER_INCOMPATIBLE_COMPRESSED_ZSTD|HEADER_INCOMPATIBLE_KEYED_HASH)
 172 #elif HAVE_XZ
 173 #  define HEADER_INCOMPATIBLE_SUPPORTED (HEADER_INCOMPATIBLE_COMPRESSED_XZ|HEADER_INCOMPATIBLE_KEYED_HASH)
 174 #elif HAVE_LZ4
 175 #  define HEADER_INCOMPATIBLE_SUPPORTED (HEADER_INCOMPATIBLE_COMPRESSED_LZ4|HEADER_INCOMPATIBLE_KEYED_HASH)
 176 #elif HAVE_ZSTD
 177 #  define HEADER_INCOMPATIBLE_SUPPORTED (HEADER_INCOMPATIBLE_COMPRESSED_ZSTD|HEADER_INCOMPATIBLE_KEYED_HASH)
 178 #else
 179 #  define HEADER_INCOMPATIBLE_SUPPORTED HEADER_INCOMPATIBLE_KEYED_HASH
 180 #endif
 181
 182 enum {
 183         HEADER_COMPATIBLE_SEALED = 1 << 0,
 184 };
 185
 186 #define HEADER_COMPATIBLE_ANY HEADER_COMPATIBLE_SEALED
 187 #if HAVE_GCRYPT
 188 #  define HEADER_COMPATIBLE_SUPPORTED HEADER_COMPATIBLE_SEALED
 189 #else
 190 #  define HEADER_COMPATIBLE_SUPPORTED 0
 191 #endif
 192
 193 #define HEADER_SIGNATURE                                                \
 194         ((const char[]) { 'L', 'P', 'K', 'S', 'H', 'H', 'R', 'H' })
 195
 196 #define struct_Header__contents {                       \
 197         uint8_t signature[8]; /* "LPKSHHRH" */          \
 198         le32_t compatible_flags;                        \
 199         le32_t incompatible_flags;                      \
 200         uint8_t state;                                  \
 201         uint8_t reserved[7];                            \
 202         sd_id128_t file_id;                             \
 203         sd_id128_t machine_id;                          \
 204         sd_id128_t boot_id;    /* last writer */        \
 205         sd_id128_t seqnum_id;                           \
 206         le64_t header_size;                             \
 207         le64_t arena_size;                              \
 208         le64_t data_hash_table_offset;                  \
 209         le64_t data_hash_table_size;                    \
 210         le64_t field_hash_table_offset;                 \
 211         le64_t field_hash_table_size;                   \
 212         le64_t tail_object_offset;                      \
 213         le64_t n_objects;                               \
 214         le64_t n_entries;                               \
 215         le64_t tail_entry_seqnum;                       \
 216         le64_t head_entry_seqnum;                       \
 217         le64_t entry_array_offset;                      \
 218         le64_t head_entry_realtime;                     \
 219         le64_t tail_entry_realtime;                     \
 220         le64_t tail_entry_monotonic;                    \
 221         /* Added in 187 */                              \
 222         le64_t n_data;                                  \
 223         le64_t n_fields;                                \
 224         /* Added in 189 */                              \
 225         le64_t n_tags;                                  \
 226         le64_t n_entry_arrays;                          \
 227         /* Added in 246 */                              \
 228         le64_t data_hash_chain_depth;                   \
 229         le64_t field_hash_chain_depth;                  \
 230         }
 231
 232 struct Header struct_Header__contents;
 233 struct Header__packed struct_Header__contents _packed_;
 234 assert_cc(sizeof(struct Header) == sizeof(struct Header__packed));
 235 assert_cc(sizeof(struct Header) == 256);
 236
 237 #define FSS_HEADER_SIGNATURE                                            \
 238         ((const char[]) { 'K', 'S', 'H', 'H', 'R', 'H', 'L', 'P' })
 239
 240 struct FSSHeader {
 241         uint8_t signature[8]; /* "KSHHRHLP" */
 242         le32_t compatible_flags;
 243         le32_t incompatible_flags;
 244         sd_id128_t machine_id;
 245         sd_id128_t boot_id;    /* last writer */
 246         le64_t header_size;
 247         le64_t start_usec;
 248         le64_t interval_usec;
 249         le16_t fsprg_secpar;
 250         le16_t reserved[3];
 251         le64_t fsprg_state_size;
 252 } _packed_;