src/ctfser/ctfser.h

   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 "compat/mman.h"
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <fcntl.h>
  38 #include "common/align.h"
  39 #include "compat/endian.h"
  40 #include "common/common.h"
  41 #include "common/mmap-align.h"
  42 #include <babeltrace2/types.h>
  43 #include "common/assert.h"
  44 #include "common/macros.h"
  45 #include "compat/bitfield.h"
  46 #include <glib.h>
  47
  48 struct bt_ctfser {
  49         /* Stream file's descriptor */
  50         int fd;
  51
  52         /* Offset (bytes) of memory map (current packet) in the stream file */
  53         off_t mmap_offset;
  54
  55         /* Offset (bytes) of packet's first byte in the memory map */
  56         off_t mmap_base_offset;
  57
  58         /* Current offset (bits) within current packet */
  59         uint64_t offset_in_cur_packet_bits;
  60
  61         /* Current packet size (bytes) */
  62         uint64_t cur_packet_size_bytes;
  63
  64         /* Previous packet size (bytes) */
  65         uint64_t prev_packet_size_bytes;
  66
  67         /* Current stream size (bytes) */
  68         uint64_t stream_size_bytes;
  69
  70         /* Memory map base address */
  71         struct mmap_align *base_mma;
  72
  73         /* Stream file's path (for debugging) */
  74         GString *path;
  75 };
  76
  77 /*
  78  * Initializes a CTF serializer.
  79  *
  80  * This function opens the file `path` for writing.
  81  */
  82 BT_HIDDEN
  83 int bt_ctfser_init(struct bt_ctfser *ctfser, const char *path);
  84
  85 /*
  86  * Finalizes a CTF serializer.
  87  *
  88  * This function truncates the stream file so that there's no extra
  89  * padding after the last packet, and then closes the file.
  90  */
  91 BT_HIDDEN
  92 int bt_ctfser_fini(struct bt_ctfser *ctfser);
  93
  94 /*
  95  * Opens a new packet.
  96  *
  97  * All the next writing functions are performed within this new packet.
  98  */
  99 BT_HIDDEN
 100 int bt_ctfser_open_packet(struct bt_ctfser *ctfser);
 101
 102 /*
 103  * Closes the current packet, making its size `packet_size_bytes`.
 104  */
 105 BT_HIDDEN
 106 void bt_ctfser_close_current_packet(struct bt_ctfser *ctfser,
 107                 uint64_t packet_size_bytes);
 108
 109 BT_HIDDEN
 110 int _bt_ctfser_increase_cur_packet_size(struct bt_ctfser *ctfser);
 111
 112 static inline
 113 uint64_t _bt_ctfser_cur_packet_size_bits(struct bt_ctfser *ctfser)
 114 {
 115         return ctfser->cur_packet_size_bytes * 8;
 116 }
 117
 118 static inline
 119 uint64_t _bt_ctfser_prev_packet_size_bits(struct bt_ctfser *ctfser)
 120 {
 121         return ctfser->prev_packet_size_bytes * 8;
 122 }
 123
 124 static inline
 125 uint64_t _bt_ctfser_offset_bytes(struct bt_ctfser *ctfser)
 126 {
 127         return ctfser->offset_in_cur_packet_bits / 8;
 128 }
 129
 130 static inline
 131 uint8_t *_bt_ctfser_get_addr(struct bt_ctfser *ctfser)
 132 {
 133         /* Only makes sense to get the address after aligning on byte */
 134         BT_ASSERT(ctfser->offset_in_cur_packet_bits % 8 == 0);
 135         return ((uint8_t *) mmap_align_addr(ctfser->base_mma)) +
 136                 ctfser->mmap_base_offset + _bt_ctfser_offset_bytes(ctfser);
 137 }
 138
 139 static inline
 140 bool _bt_ctfser_has_space_left(struct bt_ctfser *ctfser, uint64_t size_bits)
 141 {
 142         bool has_space_left = true;
 143
 144         if (G_UNLIKELY((ctfser->offset_in_cur_packet_bits + size_bits >
 145                         _bt_ctfser_cur_packet_size_bits(ctfser)))) {
 146                 has_space_left = false;
 147                 goto end;
 148         }
 149
 150         if (G_UNLIKELY(size_bits > 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 (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, align_size_bits))) {
 182                 ret = _bt_ctfser_increase_cur_packet_size(ctfser);
 183                 if (G_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
 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)
 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
 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;
 218
 219                 if (rbo) {
 220                         v = GUINT16_SWAP_LE_BE(v);
 221                 }
 222
 223                 memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
 224                 break;
 225         }
 226         case 32:
 227         {
 228                 uint32_t v = (uint32_t) value;
 229
 230                 if (rbo) {
 231                         v = GUINT32_SWAP_LE_BE(v);
 232                 }
 233
 234                 memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
 235                 break;
 236         }
 237         case 64:
 238         {
 239                 uint64_t v = (uint64_t) value;
 240
 241                 if (rbo) {
 242                         v = GUINT64_SWAP_LE_BE(v);
 243                 }
 244
 245                 memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
 246                 break;
 247         }
 248         default:
 249                 abort();
 250         }
 251
 252         _bt_ctfser_incr_offset(ctfser, size_bits);
 253         return ret;
 254 }
 255
 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;
 262
 263         /* Reverse byte order? */
 264         bool rbo = byte_order != BYTE_ORDER;
 265
 266         BT_ASSERT(size_bits % 8 == 0);
 267         BT_ASSERT(_bt_ctfser_has_space_left(ctfser, size_bits));
 268
 269         switch (size_bits) {
 270         case 8:
 271         {
 272                 int8_t v = (int8_t) value;
 273
 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);
 283                 }
 284
 285                 memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
 286                 break;
 287         }
 288         case 32:
 289         {
 290                 int32_t v = (int32_t) value;
 291
 292                 if (rbo) {
 293                         v = GUINT32_SWAP_LE_BE(v);
 294                 }
 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);
 305                 }
 306
 307                 memcpy(_bt_ctfser_get_addr(ctfser), &v, sizeof(v));
 308                 break;
 309         }
 310         default:
 311                 abort();
 312         }
 313
 314         _bt_ctfser_incr_offset(ctfser, size_bits);
 315         return ret;
 316 }
 317
 318 /*
 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.
 322  */
 323 static inline
 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)
 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 (G_UNLIKELY(ret)) {
 333                 goto end;
 334         }
 335
 336         if (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
 337                 ret = _bt_ctfser_increase_cur_packet_size(ctfser);
 338                 if (G_UNLIKELY(ret)) {
 339                         goto end;
 340                 }
 341         }
 342
 343         ret = _bt_ctfser_write_byte_aligned_unsigned_int_no_align(ctfser, value,
 344                 size_bits, byte_order);
 345         if (G_UNLIKELY(ret)) {
 346                 goto end;
 347         }
 348
 349 end:
 350         return ret;
 351 }
 352
 353 /*
 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.
 357  */
 358 static inline
 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 (G_UNLIKELY(ret)) {
 368                 goto end;
 369         }
 370
 371         if (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
 372                 ret = _bt_ctfser_increase_cur_packet_size(ctfser);
 373                 if (G_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 (G_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,
 395         int byte_order)
 396 {
 397         int ret = 0;
 398
 399         ret = bt_ctfser_align_offset_in_current_packet(ctfser, alignment_bits);
 400         if (G_UNLIKELY(ret)) {
 401                 goto end;
 402         }
 403
 404         if (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
 405                 ret = _bt_ctfser_increase_cur_packet_size(ctfser);
 406                 if (G_UNLIKELY(ret)) {
 407                         goto end;
 408                 }
 409         }
 410
 411         if (alignment_bits % 8 == 0 && size_bits % 8 == 0) {
 412                 ret = _bt_ctfser_write_byte_aligned_unsigned_int_no_align(
 413                         ctfser, value, size_bits, byte_order);
 414                 goto end;
 415         }
 416
 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);
 421         } else {
 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 (G_UNLIKELY(ret)) {
 446                 goto end;
 447         }
 448
 449         if (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, size_bits))) {
 450                 ret = _bt_ctfser_increase_cur_packet_size(ctfser);
 451                 if (G_UNLIKELY(ret)) {
 452                         goto end;
 453                 }
 454         }
 455
 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
 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 {
 486         union u32f {
 487                 uint32_t u;
 488                 float f;
 489         } u32f;
 490
 491         u32f.f = (float) value;
 492         return bt_ctfser_write_unsigned_int(ctfser, (uint64_t) u32f.u,
 493                 alignment_bits, 32, byte_order);
 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 {
 504         union u64f {
 505                 uint64_t u;
 506                 float f;
 507         } u64f;
 508
 509         u64f.f = value;
 510         return bt_ctfser_write_unsigned_int(ctfser, u64f.u, alignment_bits,
 511                 64, byte_order);
 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 (G_UNLIKELY(ret)) {
 526                 goto end;
 527         }
 528
 529         while (true) {
 530                 if (G_UNLIKELY(!_bt_ctfser_has_space_left(ctfser, 8))) {
 531                         ret = _bt_ctfser_increase_cur_packet_size(ctfser);
 532                         if (G_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 (G_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 static inline
 572 const char *bt_ctfser_get_file_path(struct bt_ctfser *ctfser)
 573 {
 574         return ctfser->path->str;
 575 }
 576
 577 #endif /* BABELTRACE_CTFSER_INTERNAL_H */