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 #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
 105 struct HashItem {
 106         le64_t head_hash_offset;
 107         le64_t tail_hash_offset;
 108 } _packed_;
 109
 110 struct HashTableObject {
 111         ObjectHeader object;
 112         HashItem items[];
 113 } _packed_;
 114
 115 struct EntryArrayObject {
 116         ObjectHeader object;
 117         le64_t next_entry_array_offset;
 118         le64_t items[];
 119 } _packed_;
 120
 121 #define TAG_LENGTH (256/8)
 122
 123 struct TagObject {
 124         ObjectHeader object;
 125         le64_t seqnum;
 126         le64_t epoch;
 127         uint8_t tag[TAG_LENGTH]; /* SHA-256 HMAC */
 128 } _packed_;
 129
 130 union Object {
 131         ObjectHeader object;
 132         DataObject data;
 133         FieldObject field;
 134         EntryObject entry;
 135         HashTableObject hash_table;
 136         EntryArrayObject entry_array;
 137         TagObject tag;
 138 };
 139
 140 enum {
 141         STATE_OFFLINE = 0,
 142         STATE_ONLINE = 1,
 143         STATE_ARCHIVED = 2,
 144         _STATE_MAX
 145 };
 146
 147 /* Header flags */
 148 enum {
 149         HEADER_INCOMPATIBLE_COMPRESSED_XZ = 1 << 0,
 150         HEADER_INCOMPATIBLE_COMPRESSED_LZ4 = 1 << 1,
 151 };
 152
 153 #define HEADER_INCOMPATIBLE_ANY (HEADER_INCOMPATIBLE_COMPRESSED_XZ|HEADER_INCOMPATIBLE_COMPRESSED_LZ4)
 154
 155 #if HAVE_XZ && HAVE_LZ4
 156 #  define HEADER_INCOMPATIBLE_SUPPORTED HEADER_INCOMPATIBLE_ANY
 157 #elif HAVE_XZ
 158 #  define HEADER_INCOMPATIBLE_SUPPORTED HEADER_INCOMPATIBLE_COMPRESSED_XZ
 159 #elif HAVE_LZ4
 160 #  define HEADER_INCOMPATIBLE_SUPPORTED HEADER_INCOMPATIBLE_COMPRESSED_LZ4
 161 #else
 162 #  define HEADER_INCOMPATIBLE_SUPPORTED 0
 163 #endif
 164
 165 enum {
 166         HEADER_COMPATIBLE_SEALED = 1
 167 };
 168
 169 #define HEADER_COMPATIBLE_ANY HEADER_COMPATIBLE_SEALED
 170 #if HAVE_GCRYPT
 171 #  define HEADER_COMPATIBLE_SUPPORTED HEADER_COMPATIBLE_SEALED
 172 #else
 173 #  define HEADER_COMPATIBLE_SUPPORTED 0
 174 #endif
 175
 176 #define HEADER_SIGNATURE ((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 ((char[]) { 'K', 'S', 'H', 'H', 'R', 'H', 'L', 'P' })
 217
 218 struct FSSHeader {
 219         uint8_t signature[8]; /* "KSHHRHLP" */
 220         le32_t compatible_flags;
 221         le32_t incompatible_flags;
 222         sd_id128_t machine_id;
 223         sd_id128_t boot_id;    /* last writer */
 224         le64_t header_size;
 225         le64_t start_usec;
 226         le64_t interval_usec;
 227         le16_t fsprg_secpar;
 228         le16_t reserved[3];
 229         le64_t fsprg_state_size;
 230 } _packed_;