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