src/journal/journal-def.h

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