[lttng-tools.git] / src / common / trace-chunk.h

/*
 * Copyright (C) 2019 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License, version 2.1 only,
 * as published by the Free Software Foundation.
 *
 * This program 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 this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#ifndef LTTNG_TRACE_CHUNK_H
#define LTTNG_TRACE_CHUNK_H

#include <common/macros.h>
#include <common/credentials.h>
#include <common/compat/directory-handle.h>
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>

/*
 * A trace chunk is a group of directories and files forming a (or a set of)
 * complete and independant trace(s). For instance, a trace archive chunk,
 * a snapshot, or a regular LTTng trace are all instances of a trace archive.
 *
 * A trace chunk is always contained within a session output directory.
 *
 * This facility is used by the session daemon, consumer daemon(s), and relay
 * daemon to:
 *   - Control file (data stream, metadata, and index) creation relative to
 *     a given output directory,
 *   - Track the use of an output directory by other objects in order to
 *     know if/when an output directory can be safely consumed, renamed,
 *     deleted, etc.
 *
 *
 * OWNER VS USER
 * ---
 *
 * A trace chunk can either be a owner or a user of its
 * "chunk output directory".
 *
 * A "user" trace chunk is provided with a handle to the chunk output directory
 * which can then be used to create subdirectories and files.
 *
 * An "owner" chunk, on top of being able to perform the operations of a "user"
 * chunk can perform operations on its chunk output directory, such as renaming
 * or deleting it.
 *
 * A trace chunk becomes an "owner" or "user" chunk based on which of
 * 'lttng_trace_chunk_set_as_owner()' or 'lttng_trace_chunk_set_as_user()' is
 * used. These methods are _exclusive_ and must only be used once on a
 * trace chunk.
 */

struct lttng_trace_chunk;

enum lttng_trace_chunk_status {
        LTTNG_TRACE_CHUNK_STATUS_OK,
	LTTNG_TRACE_CHUNK_STATUS_NONE,
	LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT,
	LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION,
	LTTNG_TRACE_CHUNK_STATUS_ERROR,
	LTTNG_TRACE_CHUNK_STATUS_NO_FILE,
};

enum lttng_trace_chunk_command_type {
	LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED = 0,
	LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION = 1,
	LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE = 2,
	LTTNG_TRACE_CHUNK_COMMAND_TYPE_MAX,
};

LTTNG_HIDDEN
struct lttng_trace_chunk *lttng_trace_chunk_create_anonymous(void);

LTTNG_HIDDEN
struct lttng_trace_chunk *lttng_trace_chunk_create(
		uint64_t chunk_id,
		time_t chunk_creation_time);

/*
 * Copy a trace chunk. The copy that is returned is always a _user_
 * mode chunk even if the source chunk was an _owner_ as there can never be
 * two _owners_ of the same trace output.
 */
LTTNG_HIDDEN
struct lttng_trace_chunk *lttng_trace_chunk_copy(
		struct lttng_trace_chunk *source_chunk);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_get_id(
		struct lttng_trace_chunk *chunk, uint64_t *id);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_get_creation_timestamp(
		struct lttng_trace_chunk *chunk, time_t *creation_ts);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_get_close_timestamp(
		struct lttng_trace_chunk *chunk, time_t *close_ts);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_set_close_timestamp(
		struct lttng_trace_chunk *chunk, time_t close_ts);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_get_name(
		struct lttng_trace_chunk *chunk, const char **name,
		bool *name_overridden);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_override_name(
		struct lttng_trace_chunk *chunk, const char *name);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_get_credentials(
		struct lttng_trace_chunk *chunk,
		struct lttng_credentials *credentials);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_set_credentials(
		struct lttng_trace_chunk *chunk,
		const struct lttng_credentials *credentials);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_set_credentials_current_user(
		struct lttng_trace_chunk *chunk);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_set_as_owner(
		struct lttng_trace_chunk *chunk,
		struct lttng_directory_handle *session_output_directory);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_set_as_user(
		struct lttng_trace_chunk *chunk,
		struct lttng_directory_handle *chunk_directory);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_borrow_chunk_directory_handle(
		struct lttng_trace_chunk *chunk,
		const struct lttng_directory_handle **handle);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_create_subdirectory(
		struct lttng_trace_chunk *chunk,
		const char *subdirectory_path);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_open_file(
		struct lttng_trace_chunk *chunk, const char *filename,
		int flags, mode_t mode, int *out_fd, bool expect_no_file);

LTTNG_HIDDEN
int lttng_trace_chunk_unlink_file(struct lttng_trace_chunk *chunk,
		const char *filename);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_get_close_command(
		struct lttng_trace_chunk *chunk,
		enum lttng_trace_chunk_command_type *command_type);

LTTNG_HIDDEN
enum lttng_trace_chunk_status lttng_trace_chunk_set_close_command(
		struct lttng_trace_chunk *chunk,
		enum lttng_trace_chunk_command_type command_type);

LTTNG_HIDDEN
const char *lttng_trace_chunk_command_type_get_name(
		enum lttng_trace_chunk_command_type command);

/* Returns true on success. */
LTTNG_HIDDEN
bool lttng_trace_chunk_get(struct lttng_trace_chunk *chunk);

LTTNG_HIDDEN
void lttng_trace_chunk_put(struct lttng_trace_chunk *chunk);

#endif /* LTTNG_TRACE_CHUNK_H */
Commit	Line	Data
2c5ff4e4 JG	1	/*
	2	* Copyright (C) 2019 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU Lesser General Public License, version 2.1 only,
	6	* as published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
	11	* for more details.
	12	*
	13	* You should have received a copy of the GNU Lesser General Public License
	14	* along with this program; if not, write to the Free Software Foundation,
	15	* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	16	*/
	17
	18	#ifndef LTTNG_TRACE_CHUNK_H
	19	#define LTTNG_TRACE_CHUNK_H
	20
	21	#include <common/macros.h>
	22	#include <common/credentials.h>
	23	#include <common/compat/directory-handle.h>
	24	#include <stddef.h>
	25	#include <stdint.h>
	26	#include <stdbool.h>
	27
	28	/*
	29	* A trace chunk is a group of directories and files forming a (or a set of)
	30	* complete and independant trace(s). For instance, a trace archive chunk,
	31	* a snapshot, or a regular LTTng trace are all instances of a trace archive.
	32	*
	33	* A trace chunk is always contained within a session output directory.
	34	*
	35	* This facility is used by the session daemon, consumer daemon(s), and relay
	36	* daemon to:
	37	* - Control file (data stream, metadata, and index) creation relative to
	38	* a given output directory,
	39	* - Track the use of an output directory by other objects in order to
	40	* know if/when an output directory can be safely consumed, renamed,
	41	* deleted, etc.
	42	*
	43	*
	44	* OWNER VS USER
	45	* ---
	46	*
	47	* A trace chunk can either be a owner or a user of its
	48	* "chunk output directory".
	49	*
	50	* A "user" trace chunk is provided with a handle to the chunk output directory
	51	* which can then be used to create subdirectories and files.
	52	*
	53	* An "owner" chunk, on top of being able to perform the operations of a "user"
	54	* chunk can perform operations on its chunk output directory, such as renaming
	55	* or deleting it.
	56	*
	57	* A trace chunk becomes an "owner" or "user" chunk based on which of
	58	* 'lttng_trace_chunk_set_as_owner()' or 'lttng_trace_chunk_set_as_user()' is
	59	* used. These methods are _exclusive_ and must only be used once on a
	60	* trace chunk.
	61	*/
	62
	63	struct lttng_trace_chunk;
	64
65	enum lttng_trace_chunk_status {
66	LTTNG_TRACE_CHUNK_STATUS_OK,
67	LTTNG_TRACE_CHUNK_STATUS_NONE,
68	LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT,
69	LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION,
70	LTTNG_TRACE_CHUNK_STATUS_ERROR,
3ff5c5db	71	LTTNG_TRACE_CHUNK_STATUS_NO_FILE,
2c5ff4e4 JG	72	};
	73
	74	enum lttng_trace_chunk_command_type {
	75	LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED = 0,
343defc2 MD	76	LTTNG_TRACE_CHUNK_COMMAND_TYPE_NO_OPERATION = 1,
	77	LTTNG_TRACE_CHUNK_COMMAND_TYPE_DELETE = 2,
	78	LTTNG_TRACE_CHUNK_COMMAND_TYPE_MAX,
2c5ff4e4 JG	79	};
	80
	81	LTTNG_HIDDEN
	82	struct lttng_trace_chunk *lttng_trace_chunk_create_anonymous(void);
	83
	84	LTTNG_HIDDEN
	85	struct lttng_trace_chunk *lttng_trace_chunk_create(
	86	uint64_t chunk_id,
	87	time_t chunk_creation_time);
	88
1a414e3a JG	89	/*
	90	* Copy a trace chunk. The copy that is returned is always a _user_
	91	* mode chunk even if the source chunk was an _owner_ as there can never be
	92	* two _owners_ of the same trace output.
	93	*/
	94	LTTNG_HIDDEN
	95	struct lttng_trace_chunk *lttng_trace_chunk_copy(
	96	struct lttng_trace_chunk *source_chunk);
	97
2c5ff4e4 JG	98	LTTNG_HIDDEN
	99	enum lttng_trace_chunk_status lttng_trace_chunk_get_id(
	100	struct lttng_trace_chunk chunk, uint64_t id);
	101
	102	LTTNG_HIDDEN
	103	enum lttng_trace_chunk_status lttng_trace_chunk_get_creation_timestamp(
	104	struct lttng_trace_chunk chunk, time_t creation_ts);
	105
	106	LTTNG_HIDDEN
	107	enum lttng_trace_chunk_status lttng_trace_chunk_get_close_timestamp(
	108	struct lttng_trace_chunk chunk, time_t close_ts);
	109
	110	LTTNG_HIDDEN
	111	enum lttng_trace_chunk_status lttng_trace_chunk_set_close_timestamp(
	112	struct lttng_trace_chunk *chunk, time_t close_ts);
	113
	114	LTTNG_HIDDEN
	115	enum lttng_trace_chunk_status lttng_trace_chunk_get_name(
	116	struct lttng_trace_chunk chunk, const char *name,
913a542b	117	bool *name_overridden);
2c5ff4e4 JG	118
	119	LTTNG_HIDDEN
	120	enum lttng_trace_chunk_status lttng_trace_chunk_override_name(
	121	struct lttng_trace_chunk chunk, const char name);
	122
	123	LTTNG_HIDDEN
	124	enum lttng_trace_chunk_status lttng_trace_chunk_get_credentials(
	125	struct lttng_trace_chunk *chunk,
	126	struct lttng_credentials *credentials);
	127
	128	LTTNG_HIDDEN
	129	enum lttng_trace_chunk_status lttng_trace_chunk_set_credentials(
	130	struct lttng_trace_chunk *chunk,
	131	const struct lttng_credentials *credentials);
	132
	133	LTTNG_HIDDEN
	134	enum lttng_trace_chunk_status lttng_trace_chunk_set_credentials_current_user(
	135	struct lttng_trace_chunk *chunk);
	136
2c5ff4e4 JG	137	LTTNG_HIDDEN
	138	enum lttng_trace_chunk_status lttng_trace_chunk_set_as_owner(
	139	struct lttng_trace_chunk *chunk,
	140	struct lttng_directory_handle *session_output_directory);
	141
2c5ff4e4 JG	142	LTTNG_HIDDEN
	143	enum lttng_trace_chunk_status lttng_trace_chunk_set_as_user(
	144	struct lttng_trace_chunk *chunk,
	145	struct lttng_directory_handle *chunk_directory);
	146
	147	LTTNG_HIDDEN
cbf53d23	148	enum lttng_trace_chunk_status lttng_trace_chunk_borrow_chunk_directory_handle(
2c5ff4e4 JG	149	struct lttng_trace_chunk *chunk,
	150	const struct lttng_directory_handle **handle);
	151
	152	LTTNG_HIDDEN
	153	enum lttng_trace_chunk_status lttng_trace_chunk_create_subdirectory(
	154	struct lttng_trace_chunk *chunk,
	155	const char *subdirectory_path);
	156
	157	LTTNG_HIDDEN
	158	enum lttng_trace_chunk_status lttng_trace_chunk_open_file(
	159	struct lttng_trace_chunk chunk, const char filename,
3ff5c5db	160	int flags, mode_t mode, int *out_fd, bool expect_no_file);
2c5ff4e4 JG	161
	162	LTTNG_HIDDEN
	163	int lttng_trace_chunk_unlink_file(struct lttng_trace_chunk *chunk,
	164	const char *filename);
	165
bbc4768c JG	166	LTTNG_HIDDEN
	167	enum lttng_trace_chunk_status lttng_trace_chunk_get_close_command(
	168	struct lttng_trace_chunk *chunk,
	169	enum lttng_trace_chunk_command_type *command_type);
	170
2c5ff4e4 JG	171	LTTNG_HIDDEN
	172	enum lttng_trace_chunk_status lttng_trace_chunk_set_close_command(
	173	struct lttng_trace_chunk *chunk,
	174	enum lttng_trace_chunk_command_type command_type);
	175
bbc4768c JG	176	LTTNG_HIDDEN
	177	const char *lttng_trace_chunk_command_type_get_name(
	178	enum lttng_trace_chunk_command_type command);
	179
2c5ff4e4 JG	180	/* Returns true on success. */
	181	LTTNG_HIDDEN
	182	bool lttng_trace_chunk_get(struct lttng_trace_chunk *chunk);
	183
	184	LTTNG_HIDDEN
	185	void lttng_trace_chunk_put(struct lttng_trace_chunk *chunk);
	186
	187	#endif /* LTTNG_TRACE_CHUNK_H */