[babeltrace.git] / include / babeltrace / ctfser-internal.h

#ifndef BABELTRACE_CTFSER_INTERNAL_H
#define BABELTRACE_CTFSER_INTERNAL_H

/*
 * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
 * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 * Copyright 2017-2019 Philippe Proulx <pproulx@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * The Common Trace Format (CTF) Specification is available at
 * http://www.efficios.com/ctf
 */

#include <stdlib.h>
#include <stdint.h>
#include <limits.h>
#include <babeltrace/compat/mman-internal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <babeltrace/align-internal.h>
#include <babeltrace/endian-internal.h>
#include <babeltrace/common-internal.h>
#include <babeltrace/mmap-align-internal.h>
#include <babeltrace/types.h>
#include <babeltrace/assert-internal.h>
#include <babeltrace/bitfield-internal.h>
#include <glib.h>

struct bt_ctfser {
	/* Stream file's descriptor */
	int fd;

	/* Offset (bytes) of memory map (current packet) in the stream file */
	off_t mmap_offset;

	/* Offset (bytes) of packet's first byte in the memory map */
	off_t mmap_base_offset;

	/* Current offset (bits) within current packet */
	uint64_t offset_in_cur_packet_bits;

	/* Current packet size (bytes) */
	uint64_t cur_packet_size_bytes;

	/* Previous packet size (bytes) */
	uint64_t prev_packet_size_bytes;

	/* Current stream size (bytes) */
	uint64_t stream_size_bytes;

	/* Memory map base address */
	struct mmap_align *base_mma;

	/* Stream file's path (for debugging) */
	GString *path;
};

/*
 * Initializes a CTF serializer.
 *
 * This function opens the file `path` for writing.
 */
BT_HIDDEN
int bt_ctfser_init(struct bt_ctfser *ctfser, const char *path);

/*
 * Finalizes a CTF serializer.
 *
 * This function truncates the stream file so that there's no extra
 * padding after the last packet, and then closes the file.
 */
BT_HIDDEN
int bt_ctfser_fini(struct bt_ctfser *ctfser);

/*
 * Opens a new packet.
 *
 * All the next writing functions are performed within this new packet.
 */
BT_HIDDEN
int bt_ctfser_open_packet(struct bt_ctfser *ctfser);

/*
 * Closes the current packet, making its size `packet_size_bytes`.
 */
BT_HIDDEN
void bt_ctfser_close_current_packet(struct bt_ctfser *ctfser,
		uint64_t packet_size_bytes);

BT_HIDDEN
int _bt_ctfser_increase_cur_packet_size(struct bt_ctfser *ctfser);

static inline
uint64_t _bt_ctfser_cur_packet_size_bits(struct bt_ctfser *ctfser)
{
	return ctfser->cur_packet_size_bytes * 8;
}

static inline
uint64_t _bt_ctfser_prev_packet_size_bits(struct bt_ctfser *ctfser)
{
	return ctfser->prev_packet_size_bytes * 8;
}

static inline
uint64_t _bt_ctfser_offset_bytes(struct bt_ctfser *ctfser)
{
	return ctfser->offset_in_cur_packet_bits / 8;
}

static inline
uint8_t *_bt_ctfser_get_addr(struct bt_ctfser *ctfser)
{
	/* Only makes sense to get the address after aligning on byte */
	BT_ASSERT(ctfser->offset_in_cur_packet_bits % 8 == 0);
	return ((uint8_t *) mmap_align_addr(ctfser->base_mma)) +
		ctfser->mmap_base_offset + _bt_ctfser_offset_bytes(ctfser);
}

static inline
bool _bt_ctfser_has_space_left(struct bt_ctfser *ctfser, uint64_t size_bits)
{
	bool has_space_left = true;

	if (unlikely((ctfser->offset_in_cur_packet_bits + size_bits >
			_bt_ctfser_cur_packet_size_bits(ctfser)))) {
		has_space_left = false;
		goto end;
	}

	if (unlikely(ctfser->offset_in_cur_packet_bits < 0 || size_bits >
			UINT64_MAX - ctfser->offset_in_cur_packet_bits)) {
		has_space_left = false;
		goto end;
	}

end:
	return has_space_left;
}

static inline
void _bt_ctfser_incr_offset(struct bt_ctfser *ctfser, uint64_t size_bits)
{
	BT_ASSERT(_bt_ctfser_has_space_left(ctfser, size_bits));
	ctfser->offset_in_cur_packet_bits += size_bits;
}

/*
 * Aligns the current offset within the current packet to
 * `alignment_bits` bits (power of two, > 0).
 */
static inline
int bt_ctfser_align_offset_in_current_packet(struct bt_ctfser *ctfser,
		uint64_t alignment_bits)
{
	int ret = 0;
	uint64_t align_size_bits;

	BT_ASSERT(alignment_bits > 0);
	align_size_bits = ALIGN(ctfser->offset_in_cur_packet_bits,
			alignment_bits) - ctfser->offset_in_cur_packet_bits;

	if (unlikely(!_bt_ctfser_has_space_left(ctfser, align_size_bits))) {
		ret = _bt_ctfser_increase_cur_packet_size(ctfser);
		if (unlikely(ret)) {
			goto end;
		}
	}

	_bt_ctfser_incr_offset(ctfser, align_size_bits);

end:
	return ret;
}

static inline
int _bt_ctfser_write_byte_aligned_unsigned_int_no_align(
		struct bt_ctfser *ctfser, uint64_t value,
		unsigned int size_bits, int byte_order)
{
	int ret = 0;

	/* Reverse byte order? */
	bool rbo = byte_order != BYTE_ORDER;

	BT_ASSERT(size_bits % 8 == 0);
	BT_ASSERT(_bt_ctfser_has_space_left(ctfser, size_bits));

	switch (size_bits) {
	case 8:
	{
		uint8_t v = (uint8_t) value;

		memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
		break;
	}
	case 16:
	{
		uint16_t v = (uint16_t) value;

		if (rbo) {
			v = GUINT16_SWAP_LE_BE(v);
		}

		memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
		break;
	}
	case 32:
	{
		uint32_t v = (uint32_t) value;

		if (rbo) {
			v = GUINT32_SWAP_LE_BE(v);
		}

		memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
		break;
	}
	case 64:
	{
		uint64_t v = (uint64_t) value;

		if (rbo) {
			v = GUINT64_SWAP_LE_BE(v);
		}

		memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
		break;
	}
	default:
		abort();
	}

	_bt_ctfser_incr_offset(ctfser, size_bits);
	return ret;
}

static inline
int _bt_ctfser_write_byte_aligned_signed_int_no_align(
		struct bt_ctfser *ctfser, int64_t value,
		unsigned int size_bits, int byte_order)
{
	int ret = 0;

	/* Reverse byte order? */
	bool rbo = byte_order != BYTE_ORDER;

	BT_ASSERT(size_bits % 8 == 0);
	BT_ASSERT(_bt_ctfser_has_space_left(ctfser, size_bits));

	switch (size_bits) {
	case 8:
	{
		int8_t v = (int8_t) value;

		memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
		break;
	}
	case 16:
	{
		int16_t v = (int16_t) value;

		if (rbo) {
			v = GUINT16_SWAP_LE_BE(v);
		}

		memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
		break;
	}
	case 32:
	{
		int32_t v = (int32_t) value;

		if (rbo) {
			v = GUINT32_SWAP_LE_BE(v);
		}

		memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
		break;
	}
	case 64:
	{
		int64_t v = (int64_t) value;

		if (rbo) {
			v = GUINT64_SWAP_LE_BE(v);
		}

		memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
		break;
	}
	default:
		abort();
	}

	_bt_ctfser_incr_offset(ctfser, size_bits);
	return ret;
}

/*
 * Writes an unsigned integer known to have a size that is a multiple of
 * 8 and an alignment that is >= 8 at the current offset within the
 * current packet.
 */
static inline
int bt_ctfser_write_byte_aligned_unsigned_int(struct bt_ctfser *ctfser,
	uint64_t value, unsigned int alignment_bits,
	unsigned int size_bits, int byte_order)
{
	int ret;

	BT_ASSERT(alignment_bits % 8 == 0);
	ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
	if (unlikely(ret)) {
		goto end;
	}

	if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
		ret = _bt_ctfser_increase_cur_packet_size(ctfser);
		if (unlikely(ret)) {
			goto end;
		}
	}

	ret = _bt_ctfser_write_byte_aligned_unsigned_int_no_align(ctfser, value,
		size_bits, byte_order);
	if (unlikely(ret)) {
		goto end;
	}

end:
	return ret;
}

/*
 * Writes a signed integer known to have a size that is a multiple of 8
 * and an alignment that is >= 8 at the current offset within the
 * current packet.
 */
static inline
int bt_ctfser_write_byte_aligned_signed_int(struct bt_ctfser *ctfser,
	int64_t value, unsigned int alignment_bits,
	unsigned int size_bits, int byte_order)
{
	int ret;

	BT_ASSERT(alignment_bits % 8 == 0);
	ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
	if (unlikely(ret)) {
		goto end;
	}

	if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
		ret = _bt_ctfser_increase_cur_packet_size(ctfser);
		if (unlikely(ret)) {
			goto end;
		}
	}

	ret = _bt_ctfser_write_byte_aligned_signed_int_no_align(ctfser, value,
		size_bits, byte_order);
	if (unlikely(ret)) {
		goto end;
	}

end:
	return ret;
}

/*
 * Writes an unsigned integer at the current offset within the current
 * packet.
 */
static inline
int bt_ctfser_write_unsigned_int(struct bt_ctfser *ctfser, uint64_t value,
	unsigned int alignment_bits, unsigned int size_bits,
	int byte_order)
{
	int ret = 0;

	ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
	if (unlikely(ret)) {
		goto end;
	}

	if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
		ret = _bt_ctfser_increase_cur_packet_size(ctfser);
		if (unlikely(ret)) {
			goto end;
		}
	}

	if (alignment_bits % 8 == 0 && size_bits % 8 == 0) {
		ret = _bt_ctfser_write_byte_aligned_unsigned_int_no_align(
			ctfser, value, size_bits, byte_order);
		goto end;
	}

	if (byte_order == LITTLE_ENDIAN) {
		bt_bitfield_write_le(mmap_align_addr(ctfser->base_mma) +
			ctfser->mmap_base_offset, uint8_t,
			ctfser->offset_in_cur_packet_bits, size_bits, value);
	} else {
		bt_bitfield_write_be(mmap_align_addr(ctfser->base_mma) +
			ctfser->mmap_base_offset, uint8_t,
			ctfser->offset_in_cur_packet_bits, size_bits, value);
	}

	_bt_ctfser_incr_offset(ctfser, size_bits);

end:
	return ret;
}

/*
 * Writes a signed integer at the current offset within the current
 * packet.
 */
static inline
int bt_ctfser_write_signed_int(struct bt_ctfser *ctfser, int64_t value,
	unsigned int alignment_bits, unsigned int size_bits,
	int byte_order)
{
	int ret = 0;

	ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
	if (unlikely(ret)) {
		goto end;
	}

	if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
		ret = _bt_ctfser_increase_cur_packet_size(ctfser);
		if (unlikely(ret)) {
			goto end;
		}
	}

	if (alignment_bits % 8 == 0 && size_bits % 8 == 0) {
		ret = _bt_ctfser_write_byte_aligned_signed_int_no_align(
			ctfser, value, size_bits, byte_order);
		goto end;
	}

	if (byte_order == LITTLE_ENDIAN) {
		bt_bitfield_write_le(mmap_align_addr(ctfser->base_mma) +
			ctfser->mmap_base_offset, uint8_t,
			ctfser->offset_in_cur_packet_bits, size_bits, value);
	} else {
		bt_bitfield_write_be(mmap_align_addr(ctfser->base_mma) +
			ctfser->mmap_base_offset, uint8_t,
			ctfser->offset_in_cur_packet_bits, size_bits, value);
	}

	_bt_ctfser_incr_offset(ctfser, size_bits);

end:
	return ret;
}

/*
 * Writes a 32-bit floating point number at the current offset within
 * the current packet.
 */
static inline
int bt_ctfser_write_float32(struct bt_ctfser *ctfser, double value,
	unsigned int alignment_bits, int byte_order)
{
	union u32f {
		uint32_t u;
		float f;
	} u32f;

	u32f.f = (float) value;
	return bt_ctfser_write_unsigned_int(ctfser, (uint64_t) u32f.u,
		alignment_bits, 32, byte_order);
}

/*
 * Writes a 64-bit floating point number at the current offset within
 * the current packet.
 */
static inline
int bt_ctfser_write_float64(struct bt_ctfser *ctfser, double value,
	unsigned int alignment_bits, int byte_order)
{
	union u64f {
		uint64_t u;
		float f;
	} u64f;

	u64f.f = value;
	return bt_ctfser_write_unsigned_int(ctfser, u64f.u, alignment_bits,
		64, byte_order);
}

/*
 * Writes a C string, including the terminating null character, at the
 * current offset within the current packet.
 */
static inline
int bt_ctfser_write_string(struct bt_ctfser *ctfser, const char *value)
{
	int ret = 0;
	const char *at = value;

	ret = bt_ctfser_align_offset_in_current_packet(ctfser, 8);
	if (unlikely(ret)) {
		goto end;
	}

	while (true) {
		if (unlikely(!_bt_ctfser_has_space_left(ctfser, 8))) {
			ret = _bt_ctfser_increase_cur_packet_size(ctfser);
			if (unlikely(ret)) {
				goto end;
			}
		}

		memcpy(_bt_ctfser_get_addr(ctfser), at, sizeof(*at));
		_bt_ctfser_incr_offset(ctfser, 8);

		if (unlikely(*at == '\0')) {
			break;
		}

		at++;
	}

end:
	return ret;
}

/*
 * Returns the current offset within the current packet (bits).
 */
static inline
uint64_t bt_ctfser_get_offset_in_current_packet_bits(struct bt_ctfser *ctfser)
{
	return ctfser->offset_in_cur_packet_bits;
}

/*
 * Sets the current offset within the current packet (bits).
 */
static inline
void bt_ctfser_set_offset_in_current_packet_bits(struct bt_ctfser *ctfser,
		uint64_t offset_bits)
{
	BT_ASSERT(offset_bits <= _bt_ctfser_cur_packet_size_bits(ctfser));
	ctfser->offset_in_cur_packet_bits = offset_bits;
}

#endif /* BABELTRACE_CTFSER_INTERNAL_H */
Commit	Line	Data
013f35c6 PP	1	#ifndef BABELTRACE_CTFSER_INTERNAL_H
	2	#define BABELTRACE_CTFSER_INTERNAL_H
	3
	4	/*
	5	* Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
	6	* Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	7	* Copyright 2017-2019 Philippe Proulx <pproulx@efficios.com>
	8	*
	9	* Permission is hereby granted, free of charge, to any person obtaining a copy
	10	* of this software and associated documentation files (the "Software"), to deal
	11	* in the Software without restriction, including without limitation the rights
	12	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	13	* copies of the Software, and to permit persons to whom the Software is
	14	* furnished to do so, subject to the following conditions:
	15	*
	16	* The above copyright notice and this permission notice shall be included in
	17	* all copies or substantial portions of the Software.
	18	*
	19	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	20	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	21	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	22	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	23	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	24	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	25	* SOFTWARE.
	26	*
	27	* The Common Trace Format (CTF) Specification is available at
	28	* http://www.efficios.com/ctf
	29	*/
	30
	31	#include <stdlib.h>
	32	#include <stdint.h>
	33	#include <limits.h>
	34	#include <babeltrace/compat/mman-internal.h>
	35	#include <sys/types.h>
	36	#include <sys/stat.h>
	37	#include <fcntl.h>
	38	#include <babeltrace/align-internal.h>
	39	#include <babeltrace/endian-internal.h>
	40	#include <babeltrace/common-internal.h>
	41	#include <babeltrace/mmap-align-internal.h>
	42	#include <babeltrace/types.h>
	43	#include <babeltrace/assert-internal.h>
	44	#include <babeltrace/bitfield-internal.h>
	45	#include <glib.h>
	46
	47	struct bt_ctfser {
	48	/* Stream file's descriptor */
	49	int fd;
	50
	51	/* Offset (bytes) of memory map (current packet) in the stream file */
	52	off_t mmap_offset;
	53
	54	/* Offset (bytes) of packet's first byte in the memory map */
	55	off_t mmap_base_offset;
	56
	57	/* Current offset (bits) within current packet */
	58	uint64_t offset_in_cur_packet_bits;
	59
	60	/* Current packet size (bytes) */
	61	uint64_t cur_packet_size_bytes;
	62
	63	/* Previous packet size (bytes) */
	64	uint64_t prev_packet_size_bytes;
65
66	/* Current stream size (bytes) */
67	uint64_t stream_size_bytes;
68
69	/* Memory map base address */
70	struct mmap_align *base_mma;
71
72	/* Stream file's path (for debugging) */
73	GString *path;
74	};
75
013f35c6 PP	76	/*
	77	* Initializes a CTF serializer.
	78	*
	79	* This function opens the file `path` for writing.
	80	*/
	81	BT_HIDDEN
	82	int bt_ctfser_init(struct bt_ctfser ctfser, const char path);
	83
	84	/*
	85	* Finalizes a CTF serializer.
	86	*
	87	* This function truncates the stream file so that there's no extra
	88	* padding after the last packet, and then closes the file.
	89	*/
	90	BT_HIDDEN
	91	int bt_ctfser_fini(struct bt_ctfser *ctfser);
	92
	93	/*
	94	* Opens a new packet.
	95	*
	96	* All the next writing functions are performed within this new packet.
	97	*/
	98	BT_HIDDEN
	99	int bt_ctfser_open_packet(struct bt_ctfser *ctfser);
	100
	101	/*
	102	* Closes the current packet, making its size `packet_size_bytes`.
	103	*/
	104	BT_HIDDEN
	105	void bt_ctfser_close_current_packet(struct bt_ctfser *ctfser,
	106	uint64_t packet_size_bytes);
	107
	108	BT_HIDDEN
	109	int _bt_ctfser_increase_cur_packet_size(struct bt_ctfser *ctfser);
	110
	111	static inline
	112	uint64_t _bt_ctfser_cur_packet_size_bits(struct bt_ctfser *ctfser)
	113	{
	114	return ctfser->cur_packet_size_bytes * 8;
	115	}
	116
	117	static inline
	118	uint64_t _bt_ctfser_prev_packet_size_bits(struct bt_ctfser *ctfser)
	119	{
	120	return ctfser->prev_packet_size_bytes * 8;
	121	}
	122
	123	static inline
	124	uint64_t _bt_ctfser_offset_bytes(struct bt_ctfser *ctfser)
	125	{
	126	return ctfser->offset_in_cur_packet_bits / 8;
	127	}
	128
	129	static inline
	130	uint8_t _bt_ctfser_get_addr(struct bt_ctfser ctfser)
	131	{
	132	/* Only makes sense to get the address after aligning on byte */
	133	BT_ASSERT(ctfser->offset_in_cur_packet_bits % 8 == 0);
	134	return ((uint8_t *) mmap_align_addr(ctfser->base_mma)) +
	135	ctfser->mmap_base_offset + _bt_ctfser_offset_bytes(ctfser);
	136	}
	137
	138	static inline
	139	bool _bt_ctfser_has_space_left(struct bt_ctfser *ctfser, uint64_t size_bits)
140	{
141	bool has_space_left = true;
142
143	if (unlikely((ctfser->offset_in_cur_packet_bits + size_bits >
144	_bt_ctfser_cur_packet_size_bits(ctfser)))) {
145	has_space_left = false;
146	goto end;
147	}
148
149	if (unlikely(ctfser->offset_in_cur_packet_bits < 0 \|\| size_bits >
150	UINT64_MAX - ctfser->offset_in_cur_packet_bits)) {
151	has_space_left = false;
152	goto end;
153	}
154
155	end:
156	return has_space_left;
157	}
158
159	static inline
160	void _bt_ctfser_incr_offset(struct bt_ctfser *ctfser, uint64_t size_bits)
161	{
162	BT_ASSERT(_bt_ctfser_has_space_left(ctfser, size_bits));
163	ctfser->offset_in_cur_packet_bits += size_bits;
164	}
165
166	/*
167	* Aligns the current offset within the current packet to
168	* `alignment_bits` bits (power of two, > 0).
169	*/
170	static inline
171	int bt_ctfser_align_offset_in_current_packet(struct bt_ctfser *ctfser,
172	uint64_t alignment_bits)
173	{
174	int ret = 0;
175	uint64_t align_size_bits;
176
177	BT_ASSERT(alignment_bits > 0);
178	align_size_bits = ALIGN(ctfser->offset_in_cur_packet_bits,
179	alignment_bits) - ctfser->offset_in_cur_packet_bits;
180
181	if (unlikely(!_bt_ctfser_has_space_left(ctfser, align_size_bits))) {
182	ret = _bt_ctfser_increase_cur_packet_size(ctfser);
183	if (unlikely(ret)) {
184	goto end;
185	}
186	}
187
188	_bt_ctfser_incr_offset(ctfser, align_size_bits);
189
190	end:
191	return ret;
192	}
193
194	static inline
d6981059 PP	195	int _bt_ctfser_write_byte_aligned_unsigned_int_no_align(
	196	struct bt_ctfser *ctfser, uint64_t value,
	197	unsigned int size_bits, int byte_order)
013f35c6 PP	198	{
	199	int ret = 0;
	200
	201	/* Reverse byte order? */
	202	bool rbo = byte_order != BYTE_ORDER;
	203
	204	BT_ASSERT(size_bits % 8 == 0);
	205	BT_ASSERT(_bt_ctfser_has_space_left(ctfser, size_bits));
	206
d6981059 PP	207	switch (size_bits) {
	208	case 8:
	209	{
	210	uint8_t v = (uint8_t) value;
	211
	212	memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
	213	break;
	214	}
	215	case 16:
	216	{
	217	uint16_t v = (uint16_t) value;
013f35c6	218
d6981059 PP	219	if (rbo) {
d6981059 PP	220	v = GUINT16_SWAP_LE_BE(v);
013f35c6	221	}
013f35c6	222
d6981059 PP	223	memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
	224	break;
	225	}
	226	case 32:
	227	{
	228	uint32_t v = (uint32_t) value;
013f35c6	229
d6981059 PP	230	if (rbo) {
d6981059 PP	231	v = GUINT32_SWAP_LE_BE(v);
013f35c6	232	}
013f35c6	233
d6981059 PP	234	memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
	235	break;
	236	}
	237	case 64:
	238	{
	239	uint64_t v = (uint64_t) value;
013f35c6	240
d6981059 PP	241	if (rbo) {
d6981059 PP	242	v = GUINT64_SWAP_LE_BE(v);
013f35c6	243	}
013f35c6	244
d6981059 PP	245	memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
	246	break;
	247	}
	248	default:
	249	abort();
	250	}
013f35c6	251
d6981059 PP	252	_bt_ctfser_incr_offset(ctfser, size_bits);
	253	return ret;
	254	}
013f35c6	255
d6981059 PP	256	static inline
	257	int _bt_ctfser_write_byte_aligned_signed_int_no_align(
	258	struct bt_ctfser *ctfser, int64_t value,
	259	unsigned int size_bits, int byte_order)
	260	{
	261	int ret = 0;
013f35c6	262
d6981059 PP	263	/* Reverse byte order? */
d6981059 PP	264	bool rbo = byte_order != BYTE_ORDER;
013f35c6	265
d6981059 PP	266	BT_ASSERT(size_bits % 8 == 0);
d6981059 PP	267	BT_ASSERT(_bt_ctfser_has_space_left(ctfser, size_bits));
013f35c6	268
d6981059 PP	269	switch (size_bits) {
	270	case 8:
	271	{
	272	int8_t v = (int8_t) value;
013f35c6	273
d6981059 PP	274	memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
	275	break;
	276	}
	277	case 16:
	278	{
	279	int16_t v = (int16_t) value;
	280
	281	if (rbo) {
	282	v = GUINT16_SWAP_LE_BE(v);
013f35c6	283	}
013f35c6	284
d6981059 PP	285	memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
	286	break;
	287	}
	288	case 32:
	289	{
	290	int32_t v = (int32_t) value;
013f35c6	291
d6981059 PP	292	if (rbo) {
d6981059 PP	293	v = GUINT32_SWAP_LE_BE(v);
013f35c6	294	}
d6981059 PP	295
	296	memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
	297	break;
	298	}
	299	case 64:
	300	{
	301	int64_t v = (int64_t) value;
	302
	303	if (rbo) {
	304	v = GUINT64_SWAP_LE_BE(v);
013f35c6	305	}
d6981059 PP	306
	307	memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
	308	break;
	309	}
	310	default:
	311	abort();
013f35c6 PP	312	}
	313
	314	_bt_ctfser_incr_offset(ctfser, size_bits);
	315	return ret;
	316	}
	317
	318	/*
d6981059 PP	319	* Writes an unsigned integer known to have a size that is a multiple of
	320	* 8 and an alignment that is >= 8 at the current offset within the
	321	* current packet.
013f35c6 PP	322	*/
013f35c6 PP	323	static inline
d6981059 PP	324	int bt_ctfser_write_byte_aligned_unsigned_int(struct bt_ctfser *ctfser,
	325	uint64_t value, unsigned int alignment_bits,
	326	unsigned int size_bits, int byte_order)
013f35c6 PP	327	{
	328	int ret;
	329
	330	BT_ASSERT(alignment_bits % 8 == 0);
	331	ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
	332	if (unlikely(ret)) {
	333	goto end;
	334	}
	335
	336	if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
	337	ret = _bt_ctfser_increase_cur_packet_size(ctfser);
	338	if (unlikely(ret)) {
	339	goto end;
	340	}
	341	}
	342
d6981059 PP	343	ret = _bt_ctfser_write_byte_aligned_unsigned_int_no_align(ctfser, value,
d6981059 PP	344	size_bits, byte_order);
013f35c6 PP	345	if (unlikely(ret)) {
	346	goto end;
	347	}
	348
	349	end:
	350	return ret;
	351	}
	352
	353	/*
d6981059 PP	354	* Writes a signed integer known to have a size that is a multiple of 8
	355	* and an alignment that is >= 8 at the current offset within the
	356	* current packet.
013f35c6 PP	357	*/
013f35c6 PP	358	static inline
d6981059 PP	359	int bt_ctfser_write_byte_aligned_signed_int(struct bt_ctfser *ctfser,
	360	int64_t value, unsigned int alignment_bits,
	361	unsigned int size_bits, int byte_order)
	362	{
	363	int ret;
	364
	365	BT_ASSERT(alignment_bits % 8 == 0);
	366	ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
	367	if (unlikely(ret)) {
	368	goto end;
	369	}
	370
	371	if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
	372	ret = _bt_ctfser_increase_cur_packet_size(ctfser);
	373	if (unlikely(ret)) {
	374	goto end;
	375	}
	376	}
	377
	378	ret = _bt_ctfser_write_byte_aligned_signed_int_no_align(ctfser, value,
	379	size_bits, byte_order);
	380	if (unlikely(ret)) {
	381	goto end;
	382	}
	383
	384	end:
	385	return ret;
	386	}
	387
	388	/*
	389	* Writes an unsigned integer at the current offset within the current
	390	* packet.
	391	*/
	392	static inline
	393	int bt_ctfser_write_unsigned_int(struct bt_ctfser *ctfser, uint64_t value,
	394	unsigned int alignment_bits, unsigned int size_bits,
013f35c6 PP	395	int byte_order)
	396	{
	397	int ret = 0;
	398
	399	ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
	400	if (unlikely(ret)) {
	401	goto end;
	402	}
	403
	404	if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
	405	ret = _bt_ctfser_increase_cur_packet_size(ctfser);
	406	if (unlikely(ret)) {
	407	goto end;
	408	}
	409	}
	410
	411	if (alignment_bits % 8 == 0 && size_bits % 8 == 0) {
d6981059 PP	412	ret = _bt_ctfser_write_byte_aligned_unsigned_int_no_align(
d6981059 PP	413	ctfser, value, size_bits, byte_order);
013f35c6 PP	414	goto end;
	415	}
	416
d6981059 PP	417	if (byte_order == LITTLE_ENDIAN) {
	418	bt_bitfield_write_le(mmap_align_addr(ctfser->base_mma) +
	419	ctfser->mmap_base_offset, uint8_t,
	420	ctfser->offset_in_cur_packet_bits, size_bits, value);
013f35c6	421	} else {
d6981059 PP	422	bt_bitfield_write_be(mmap_align_addr(ctfser->base_mma) +
	423	ctfser->mmap_base_offset, uint8_t,
	424	ctfser->offset_in_cur_packet_bits, size_bits, value);
	425	}
	426
	427	_bt_ctfser_incr_offset(ctfser, size_bits);
	428
	429	end:
	430	return ret;
	431	}
	432
	433	/*
	434	* Writes a signed integer at the current offset within the current
	435	* packet.
	436	*/
	437	static inline
	438	int bt_ctfser_write_signed_int(struct bt_ctfser *ctfser, int64_t value,
	439	unsigned int alignment_bits, unsigned int size_bits,
	440	int byte_order)
	441	{
	442	int ret = 0;
	443
	444	ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
	445	if (unlikely(ret)) {
	446	goto end;
	447	}
	448
	449	if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
	450	ret = _bt_ctfser_increase_cur_packet_size(ctfser);
	451	if (unlikely(ret)) {
	452	goto end;
013f35c6 PP	453	}
	454	}
	455
d6981059 PP	456	if (alignment_bits % 8 == 0 && size_bits % 8 == 0) {
	457	ret = _bt_ctfser_write_byte_aligned_signed_int_no_align(
	458	ctfser, value, size_bits, byte_order);
	459	goto end;
	460	}
	461
	462	if (byte_order == LITTLE_ENDIAN) {
	463	bt_bitfield_write_le(mmap_align_addr(ctfser->base_mma) +
	464	ctfser->mmap_base_offset, uint8_t,
	465	ctfser->offset_in_cur_packet_bits, size_bits, value);
	466	} else {
	467	bt_bitfield_write_be(mmap_align_addr(ctfser->base_mma) +
	468	ctfser->mmap_base_offset, uint8_t,
	469	ctfser->offset_in_cur_packet_bits, size_bits, value);
	470	}
	471
013f35c6 PP	472	_bt_ctfser_incr_offset(ctfser, size_bits);
	473
	474	end:
	475	return ret;
	476	}
	477
	478	/*
	479	* Writes a 32-bit floating point number at the current offset within
	480	* the current packet.
	481	*/
	482	static inline
	483	int bt_ctfser_write_float32(struct bt_ctfser *ctfser, double value,
	484	unsigned int alignment_bits, int byte_order)
	485	{
013f35c6 PP	486	union u32f {
	487	uint32_t u;
	488	float f;
	489	} u32f;
	490
	491	u32f.f = (float) value;
d6981059 PP	492	return bt_ctfser_write_unsigned_int(ctfser, (uint64_t) u32f.u,
d6981059 PP	493	alignment_bits, 32, byte_order);
013f35c6 PP	494	}
	495
	496	/*
	497	* Writes a 64-bit floating point number at the current offset within
	498	* the current packet.
	499	*/
	500	static inline
	501	int bt_ctfser_write_float64(struct bt_ctfser *ctfser, double value,
	502	unsigned int alignment_bits, int byte_order)
	503	{
013f35c6 PP	504	union u64f {
	505	uint64_t u;
	506	float f;
	507	} u64f;
	508
	509	u64f.f = value;
d6981059 PP	510	return bt_ctfser_write_unsigned_int(ctfser, u64f.u, alignment_bits,
d6981059 PP	511	64, byte_order);
013f35c6 PP	512	}
	513
	514	/*
	515	* Writes a C string, including the terminating null character, at the
	516	* current offset within the current packet.
	517	*/
	518	static inline
	519	int bt_ctfser_write_string(struct bt_ctfser ctfser, const char value)
	520	{
	521	int ret = 0;
	522	const char *at = value;
	523
	524	ret = bt_ctfser_align_offset_in_current_packet(ctfser, 8);
	525	if (unlikely(ret)) {
	526	goto end;
	527	}
	528
	529	while (true) {
	530	if (unlikely(!_bt_ctfser_has_space_left(ctfser, 8))) {
	531	ret = _bt_ctfser_increase_cur_packet_size(ctfser);
	532	if (unlikely(ret)) {
	533	goto end;
	534	}
	535	}
	536
	537	memcpy(_bt_ctfser_get_addr(ctfser), at, sizeof(*at));
	538	_bt_ctfser_incr_offset(ctfser, 8);
	539
	540	if (unlikely(*at == '\0')) {
	541	break;
	542	}
	543
	544	at++;
	545	}
	546
	547	end:
	548	return ret;
	549	}
	550
	551	/*
	552	* Returns the current offset within the current packet (bits).
	553	*/
	554	static inline
	555	uint64_t bt_ctfser_get_offset_in_current_packet_bits(struct bt_ctfser *ctfser)
	556	{
	557	return ctfser->offset_in_cur_packet_bits;
	558	}
	559
	560	/*
	561	* Sets the current offset within the current packet (bits).
	562	*/
	563	static inline
	564	void bt_ctfser_set_offset_in_current_packet_bits(struct bt_ctfser *ctfser,
	565	uint64_t offset_bits)
	566	{
	567	BT_ASSERT(offset_bits <= _bt_ctfser_cur_packet_size_bits(ctfser));
	568	ctfser->offset_in_cur_packet_bits = offset_bits;
	569	}
	570
	571	#endif /* BABELTRACE_CTFSER_INTERNAL_H */