[systemd.git] / src / journal / journal-def.h

#pragma once

/***
  This file is part of systemd.

  Copyright 2011 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include "sd-id128.h"

#include "macro.h"
#include "sparse-endian.h"

/*
 * If you change this file you probably should also change its documentation:
 *
 * http://www.freedesktop.org/wiki/Software/systemd/journal-files
 *
 */

typedef struct Header Header;

typedef struct ObjectHeader ObjectHeader;
typedef union Object Object;

typedef struct DataObject DataObject;
typedef struct FieldObject FieldObject;
typedef struct EntryObject EntryObject;
typedef struct HashTableObject HashTableObject;
typedef struct EntryArrayObject EntryArrayObject;
typedef struct TagObject TagObject;

typedef struct EntryItem EntryItem;
typedef struct HashItem HashItem;

typedef struct FSSHeader FSSHeader;

/* Object types */
typedef enum ObjectType {
        OBJECT_UNUSED, /* also serves as "any type" or "additional context" */
        OBJECT_DATA,
        OBJECT_FIELD,
        OBJECT_ENTRY,
        OBJECT_DATA_HASH_TABLE,
        OBJECT_FIELD_HASH_TABLE,
        OBJECT_ENTRY_ARRAY,
        OBJECT_TAG,
        _OBJECT_TYPE_MAX
} ObjectType;

/* Object flags */
enum {
        OBJECT_COMPRESSED_XZ = 1 << 0,
        OBJECT_COMPRESSED_LZ4 = 1 << 1,
        _OBJECT_COMPRESSED_MAX
};

#define OBJECT_COMPRESSION_MASK (OBJECT_COMPRESSED_XZ | OBJECT_COMPRESSED_LZ4)

struct ObjectHeader {
        uint8_t type;
        uint8_t flags;
        uint8_t reserved[6];
        le64_t size;
        uint8_t payload[];
} _packed_;

struct DataObject {
        ObjectHeader object;
        le64_t hash;
        le64_t next_hash_offset;
        le64_t next_field_offset;
        le64_t entry_offset; /* the first array entry we store inline */
        le64_t entry_array_offset;
        le64_t n_entries;
        uint8_t payload[];
} _packed_;

struct FieldObject {
        ObjectHeader object;
        le64_t hash;
        le64_t next_hash_offset;
        le64_t head_data_offset;
        uint8_t payload[];
} _packed_;

struct EntryItem {
        le64_t object_offset;
        le64_t hash;
} _packed_;

struct EntryObject {
        ObjectHeader object;
        le64_t seqnum;
        le64_t realtime;
        le64_t monotonic;
        sd_id128_t boot_id;
        le64_t xor_hash;
        EntryItem items[];
} _packed_;

struct HashItem {
        le64_t head_hash_offset;
        le64_t tail_hash_offset;
} _packed_;

struct HashTableObject {
        ObjectHeader object;
        HashItem items[];
} _packed_;

struct EntryArrayObject {
        ObjectHeader object;
        le64_t next_entry_array_offset;
        le64_t items[];
} _packed_;

#define TAG_LENGTH (256/8)

struct TagObject {
        ObjectHeader object;
        le64_t seqnum;
        le64_t epoch;
        uint8_t tag[TAG_LENGTH]; /* SHA-256 HMAC */
} _packed_;

union Object {
        ObjectHeader object;
        DataObject data;
        FieldObject field;
        EntryObject entry;
        HashTableObject hash_table;
        EntryArrayObject entry_array;
        TagObject tag;
};

enum {
        STATE_OFFLINE = 0,
        STATE_ONLINE = 1,
        STATE_ARCHIVED = 2,
        _STATE_MAX
};

/* Header flags */
enum {
        HEADER_INCOMPATIBLE_COMPRESSED_XZ = 1 << 0,
        HEADER_INCOMPATIBLE_COMPRESSED_LZ4 = 1 << 1,
};

#define HEADER_INCOMPATIBLE_ANY (HEADER_INCOMPATIBLE_COMPRESSED_XZ|HEADER_INCOMPATIBLE_COMPRESSED_LZ4)

#if defined(HAVE_XZ) && defined(HAVE_LZ4)
#  define HEADER_INCOMPATIBLE_SUPPORTED HEADER_INCOMPATIBLE_ANY
#elif defined(HAVE_XZ)
#  define HEADER_INCOMPATIBLE_SUPPORTED HEADER_INCOMPATIBLE_COMPRESSED_XZ
#elif defined(HAVE_LZ4)
#  define HEADER_INCOMPATIBLE_SUPPORTED HEADER_INCOMPATIBLE_COMPRESSED_LZ4
#else
#  define HEADER_INCOMPATIBLE_SUPPORTED 0
#endif

enum {
        HEADER_COMPATIBLE_SEALED = 1
};

#define HEADER_COMPATIBLE_ANY HEADER_COMPATIBLE_SEALED
#ifdef HAVE_GCRYPT
#  define HEADER_COMPATIBLE_SUPPORTED HEADER_COMPATIBLE_SEALED
#else
#  define HEADER_COMPATIBLE_SUPPORTED 0
#endif

#define HEADER_SIGNATURE ((char[]) { 'L', 'P', 'K', 'S', 'H', 'H', 'R', 'H' })

struct Header {
        uint8_t signature[8]; /* "LPKSHHRH" */
        le32_t compatible_flags;
        le32_t incompatible_flags;
        uint8_t state;
        uint8_t reserved[7];
        sd_id128_t file_id;
        sd_id128_t machine_id;
        sd_id128_t boot_id;    /* last writer */
        sd_id128_t seqnum_id;
        le64_t header_size;
        le64_t arena_size;
        le64_t data_hash_table_offset;
        le64_t data_hash_table_size;
        le64_t field_hash_table_offset;
        le64_t field_hash_table_size;
        le64_t tail_object_offset;
        le64_t n_objects;
        le64_t n_entries;
        le64_t tail_entry_seqnum;
        le64_t head_entry_seqnum;
        le64_t entry_array_offset;
        le64_t head_entry_realtime;
        le64_t tail_entry_realtime;
        le64_t tail_entry_monotonic;
        /* Added in 187 */
        le64_t n_data;
        le64_t n_fields;
        /* Added in 189 */
        le64_t n_tags;
        le64_t n_entry_arrays;

        /* Size: 240 */
} _packed_;

#define FSS_HEADER_SIGNATURE ((char[]) { 'K', 'S', 'H', 'H', 'R', 'H', 'L', 'P' })

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