Cleanup: add `#include <stdbool.h>` whenever `bool` type is used

[babeltrace.git] / src / ctfser / ctfser.h

diff --git a/src/ctfser/ctfser.h b/src/ctfser/ctfser.h
index c270faf93e3a306b14dabf158f91b957464e319b..9fc3315fa861d15843b780d85214f3d2f64877bb 100644 (file)
--- a/src/ctfser/ctfser.h
+++ b/src/ctfser/ctfser.h
@@ -28,6 +28,7 @@
  * http://www.efficios.com/ctf
  */
 
+#include <stdbool.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <limits.h>
@@ -41,6 +42,7 @@
 #include "common/mmap-align.h"
 #include <babeltrace2/types.h>
 #include "common/assert.h"
+#include "common/macros.h"
 #include "compat/bitfield.h"
 #include <glib.h>
 
@@ -71,6 +73,9 @@ struct bt_ctfser {
 
        /* Stream file's path (for debugging) */
        GString *path;
+
+       /* Serializer's log level */
+       int log_level;
 };
 
 /*
@@ -79,7 +84,8 @@ struct bt_ctfser {
  * This function opens the file `path` for writing.
  */
 BT_HIDDEN
-int bt_ctfser_init(struct bt_ctfser *ctfser, const char *path);
+int bt_ctfser_init(struct bt_ctfser *ctfser, const char *path,
+               int log_level);
 
 /*
  * Finalizes a CTF serializer.
@@ -130,7 +136,7 @@ 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);
+       BT_ASSERT_DBG(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);
 }
@@ -140,13 +146,13 @@ 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 >
+       if (G_UNLIKELY((ctfser->offset_in_cur_packet_bits + size_bits >
                        _bt_ctfser_cur_packet_size_bits(ctfser)))) {
                has_space_left = false;
                goto end;
        }
 
-       if (unlikely(size_bits > UINT64_MAX - ctfser->offset_in_cur_packet_bits)) {
+       if (G_UNLIKELY(size_bits > UINT64_MAX - ctfser->offset_in_cur_packet_bits)) {
                has_space_left = false;
                goto end;
        }
@@ -158,7 +164,7 @@ end:
 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));
+       BT_ASSERT_DBG(_bt_ctfser_has_space_left(ctfser, size_bits));
        ctfser->offset_in_cur_packet_bits += size_bits;
 }
 
@@ -173,13 +179,13 @@ int bt_ctfser_align_offset_in_current_packet(struct bt_ctfser *ctfser,
        int ret = 0;
        uint64_t align_size_bits;
 
-       BT_ASSERT(alignment_bits > 0);
+       BT_ASSERT_DBG(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))) {
+       if (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, align_size_bits))) {
                ret = _bt_ctfser_increase_cur_packet_size(ctfser);
-               if (unlikely(ret)) {
+               if (G_UNLIKELY(ret)) {
                        goto end;
                }
        }
@@ -200,8 +206,8 @@ int _bt_ctfser_write_byte_aligned_unsigned_int_no_align(
        /* 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));
+       BT_ASSERT_DBG(size_bits % 8 == 0);
+       BT_ASSERT_DBG(_bt_ctfser_has_space_left(ctfser, size_bits));
 
        switch (size_bits) {
        case 8:
@@ -262,8 +268,8 @@ int _bt_ctfser_write_byte_aligned_signed_int_no_align(
        /* 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));
+       BT_ASSERT_DBG(size_bits % 8 == 0);
+       BT_ASSERT_DBG(_bt_ctfser_has_space_left(ctfser, size_bits));
 
        switch (size_bits) {
        case 8:
@@ -326,22 +332,22 @@ int bt_ctfser_write_byte_aligned_unsigned_int(struct bt_ctfser *ctfser,
 {
        int ret;
 
-       BT_ASSERT(alignment_bits % 8 == 0);
+       BT_ASSERT_DBG(alignment_bits % 8 == 0);
        ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
-       if (unlikely(ret)) {
+       if (G_UNLIKELY(ret)) {
                goto end;
        }
 
-       if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
+       if (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
                ret = _bt_ctfser_increase_cur_packet_size(ctfser);
-               if (unlikely(ret)) {
+               if (G_UNLIKELY(ret)) {
                        goto end;
                }
        }
 
        ret = _bt_ctfser_write_byte_aligned_unsigned_int_no_align(ctfser, value,
                size_bits, byte_order);
-       if (unlikely(ret)) {
+       if (G_UNLIKELY(ret)) {
                goto end;
        }
 
@@ -361,22 +367,22 @@ int bt_ctfser_write_byte_aligned_signed_int(struct bt_ctfser *ctfser,
 {
        int ret;
 
-       BT_ASSERT(alignment_bits % 8 == 0);
+       BT_ASSERT_DBG(alignment_bits % 8 == 0);
        ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
-       if (unlikely(ret)) {
+       if (G_UNLIKELY(ret)) {
                goto end;
        }
 
-       if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
+       if (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
                ret = _bt_ctfser_increase_cur_packet_size(ctfser);
-               if (unlikely(ret)) {
+               if (G_UNLIKELY(ret)) {
                        goto end;
                }
        }
 
        ret = _bt_ctfser_write_byte_aligned_signed_int_no_align(ctfser, value,
                size_bits, byte_order);
-       if (unlikely(ret)) {
+       if (G_UNLIKELY(ret)) {
                goto end;
        }
 
@@ -396,13 +402,13 @@ int bt_ctfser_write_unsigned_int(struct bt_ctfser *ctfser, uint64_t value,
        int ret = 0;
 
        ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
-       if (unlikely(ret)) {
+       if (G_UNLIKELY(ret)) {
                goto end;
        }
 
-       if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
+       if (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
                ret = _bt_ctfser_increase_cur_packet_size(ctfser);
-               if (unlikely(ret)) {
+               if (G_UNLIKELY(ret)) {
                        goto end;
                }
        }
@@ -441,13 +447,13 @@ int bt_ctfser_write_signed_int(struct bt_ctfser *ctfser, int64_t value,
        int ret = 0;
 
        ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
-       if (unlikely(ret)) {
+       if (G_UNLIKELY(ret)) {
                goto end;
        }
 
-       if (unlikely(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
+       if (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
                ret = _bt_ctfser_increase_cur_packet_size(ctfser);
-               if (unlikely(ret)) {
+               if (G_UNLIKELY(ret)) {
                        goto end;
                }
        }
@@ -502,10 +508,10 @@ int bt_ctfser_write_float64(struct bt_ctfser *ctfser, double value,
 {
        union u64f {
                uint64_t u;
-               float f;
+               double d;
        } u64f;
 
-       u64f.f = value;
+       u64f.d = value;
        return bt_ctfser_write_unsigned_int(ctfser, u64f.u, alignment_bits,
                64, byte_order);
 }
@@ -521,14 +527,14 @@ int bt_ctfser_write_string(struct bt_ctfser *ctfser, const char *value)
        const char *at = value;
 
        ret = bt_ctfser_align_offset_in_current_packet(ctfser, 8);
-       if (unlikely(ret)) {
+       if (G_UNLIKELY(ret)) {
                goto end;
        }
 
        while (true) {
-               if (unlikely(!_bt_ctfser_has_space_left(ctfser, 8))) {
+               if (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, 8))) {
                        ret = _bt_ctfser_increase_cur_packet_size(ctfser);
-                       if (unlikely(ret)) {
+                       if (G_UNLIKELY(ret)) {
                                goto end;
                        }
                }
@@ -536,7 +542,7 @@ int bt_ctfser_write_string(struct bt_ctfser *ctfser, const char *value)
                memcpy(_bt_ctfser_get_addr(ctfser), at, sizeof(*at));
                _bt_ctfser_incr_offset(ctfser, 8);
 
-               if (unlikely(*at == '\0')) {
+               if (G_UNLIKELY(*at == '\0')) {
                        break;
                }
 
@@ -563,7 +569,7 @@ 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));
+       BT_ASSERT_DBG(offset_bits <= _bt_ctfser_cur_packet_size_bits(ctfser));
        ctfser->offset_in_cur_packet_bits = offset_bits;
 }