lib/ctf-writer/serialize.c

   1 /*
   2  * serialize.c
   3  *
   4  * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
   5  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   6  * Copyright 2017 Philippe Proulx <pproulx@efficios.com>
   7  *
   8  * The original author of the serialization functions for Babeltrace 1
   9  * is Mathieu Desnoyers. Philippe Proulx modified the functions in 2017
  10  * to use Babeltrace 2 objects.
  11  *
  12  * Permission is hereby granted, free of charge, to any person obtaining a copy
  13  * of this software and associated documentation files (the "Software"), to deal
  14  * in the Software without restriction, including without limitation the rights
  15  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  16  * copies of the Software, and to permit persons to whom the Software is
  17  * furnished to do so, subject to the following conditions:
  18  *
  19  * The above copyright notice and this permission notice shall be included in
  20  * all copies or substantial portions of the Software.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  23  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  25  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  26  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  27  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  28  * SOFTWARE.
  29  */
  30
  31 #include <stdio.h>
  32 #include <stdint.h>
  33 #include <stdbool.h>
  34 #include <babeltrace/ctf-ir/field-types.h>
  35 #include <babeltrace/ctf-ir/field-types-internal.h>
  36 #include <babeltrace/ctf-ir/fields.h>
  37 #include <babeltrace/ctf-ir/fields-internal.h>
  38 #include <babeltrace/ctf-writer/serialize-internal.h>
  39 #include <babeltrace/align.h>
  40 #include <babeltrace/mmap-align.h>
  41 #include <babeltrace/endian.h>
  42 #include <babeltrace/bitfield.h>
  43 #include <babeltrace/compat/fcntl.h>
  44 #include <glib.h>
  45
  46 /* "Native" to CTF IR byte order */
  47 #if (BYTE_ORDER == LITTLE_ENDIAN)
  48 # define MY_BT_CTF_BYTE_ORDER BT_CTF_BYTE_ORDER_LITTLE_ENDIAN
  49 #else
  50 # define MY_BT_CTF_BYTE_ORDER BT_CTF_BYTE_ORDER_BIG_ENDIAN
  51 #endif
  52
  53 #if (FLT_RADIX != 2)
  54 # error "Unsupported floating point radix"
  55 #endif
  56
  57 union intval {
  58         int64_t signd;
  59         uint64_t unsignd;
  60 };
  61
  62 /*
  63  * The aligned read/write functions are expected to be faster than the
  64  * bitfield variants. They will be enabled eventually as an
  65  * optimisation.
  66  */
  67 static
  68 int aligned_integer_write(struct bt_ctf_stream_pos *pos,
  69                 union intval value, unsigned int alignment, unsigned int size,
  70                 bool is_signed, enum bt_ctf_byte_order byte_order)
  71 {
  72         bool rbo = (byte_order != MY_BT_CTF_BYTE_ORDER); /* reverse byte order */
  73
  74         if (!bt_ctf_stream_pos_align(pos, alignment))
  75                 return -EFAULT;
  76
  77         if (!bt_ctf_stream_pos_access_ok(pos, size))
  78                 return -EFAULT;
  79
  80         assert(!(pos->offset % CHAR_BIT));
  81         if (!is_signed) {
  82                 switch (size) {
  83                 case 8:
  84                 {
  85                         uint8_t v = value.unsignd;
  86
  87                         memcpy(bt_ctf_stream_pos_get_addr(pos), &v, sizeof(v));
  88                         break;
  89                 }
  90                 case 16:
  91                 {
  92                         uint16_t v = value.unsignd;
  93
  94                         if (rbo)
  95                                 v = GUINT16_SWAP_LE_BE(v);
  96                         memcpy(bt_ctf_stream_pos_get_addr(pos), &v, sizeof(v));
  97                         break;
  98                 }
  99                 case 32:
 100                 {
 101                         uint32_t v = value.unsignd;
 102
 103                         if (rbo)
 104                                 v = GUINT32_SWAP_LE_BE(v);
 105                         memcpy(bt_ctf_stream_pos_get_addr(pos), &v, sizeof(v));
 106                         break;
 107                 }
 108                 case 64:
 109                 {
 110                         uint64_t v = value.unsignd;
 111
 112                         if (rbo)
 113                                 v = GUINT64_SWAP_LE_BE(v);
 114                         memcpy(bt_ctf_stream_pos_get_addr(pos), &v, sizeof(v));
 115                         break;
 116                 }
 117                 default:
 118                         assert(false);
 119                 }
 120         } else {
 121                 switch (size) {
 122                 case 8:
 123                 {
 124                         uint8_t v = value.signd;
 125
 126                         memcpy(bt_ctf_stream_pos_get_addr(pos), &v, sizeof(v));
 127                         break;
 128                 }
 129                 case 16:
 130                 {
 131                         int16_t v = value.signd;
 132
 133                         if (rbo)
 134                                 v = GUINT16_SWAP_LE_BE(v);
 135                         memcpy(bt_ctf_stream_pos_get_addr(pos), &v, sizeof(v));
 136                         break;
 137                 }
 138                 case 32:
 139                 {
 140                         int32_t v = value.signd;
 141
 142                         if (rbo)
 143                                 v = GUINT32_SWAP_LE_BE(v);
 144                         memcpy(bt_ctf_stream_pos_get_addr(pos), &v, sizeof(v));
 145                         break;
 146                 }
 147                 case 64:
 148                 {
 149                         int64_t v = value.signd;
 150
 151                         if (rbo)
 152                                 v = GUINT64_SWAP_LE_BE(v);
 153                         memcpy(bt_ctf_stream_pos_get_addr(pos), &v, sizeof(v));
 154                         break;
 155                 }
 156                 default:
 157                         assert(false);
 158                 }
 159         }
 160
 161         if (!bt_ctf_stream_pos_move(pos, size))
 162                 return -EFAULT;
 163         return 0;
 164 }
 165
 166 static
 167 int integer_write(struct bt_ctf_stream_pos *pos, union intval value,
 168         unsigned int alignment, unsigned int size, bool is_signed,
 169         enum bt_ctf_byte_order byte_order)
 170 {
 171         if (!(alignment % CHAR_BIT)
 172             && !(size % CHAR_BIT)) {
 173                 return aligned_integer_write(pos, value, alignment,
 174                         size, is_signed, byte_order);
 175         }
 176
 177         if (!bt_ctf_stream_pos_align(pos, alignment))
 178                 return -EFAULT;
 179
 180         if (!bt_ctf_stream_pos_access_ok(pos, size))
 181                 return -EFAULT;
 182
 183         if (!is_signed) {
 184                 if (byte_order == BT_CTF_BYTE_ORDER_LITTLE_ENDIAN)
 185                         bt_bitfield_write_le(mmap_align_addr(pos->base_mma) +
 186                                 pos->mmap_base_offset, unsigned char,
 187                                 pos->offset, size, value.unsignd);
 188                 else
 189                         bt_bitfield_write_be(mmap_align_addr(pos->base_mma) +
 190                                 pos->mmap_base_offset, unsigned char,
 191                                 pos->offset, size, value.unsignd);
 192         } else {
 193                 if (byte_order == BT_CTF_BYTE_ORDER_LITTLE_ENDIAN)
 194                         bt_bitfield_write_le(mmap_align_addr(pos->base_mma) +
 195                                 pos->mmap_base_offset, unsigned char,
 196                                 pos->offset, size, value.signd);
 197                 else
 198                         bt_bitfield_write_be(mmap_align_addr(pos->base_mma) +
 199                                 pos->mmap_base_offset, unsigned char,
 200                                 pos->offset, size, value.signd);
 201         }
 202
 203         if (!bt_ctf_stream_pos_move(pos, size))
 204                 return -EFAULT;
 205         return 0;
 206 }
 207
 208 BT_HIDDEN
 209 int bt_ctf_field_integer_write(struct bt_ctf_field_integer *int_field,
 210                 struct bt_ctf_stream_pos *pos,
 211                 enum bt_ctf_byte_order native_byte_order)
 212 {
 213         struct bt_ctf_field_type *type = int_field->parent.type;
 214         struct bt_ctf_field_type_integer *int_type = (void *) type;
 215         enum bt_ctf_byte_order byte_order;
 216         union intval value;
 217
 218         byte_order = int_type->user_byte_order;
 219         if (byte_order == BT_CTF_BYTE_ORDER_NATIVE) {
 220                 byte_order = native_byte_order;
 221         }
 222
 223         value.signd = int_field->payload.signd;
 224         value.unsignd = int_field->payload.unsignd;
 225         return integer_write(pos, value, type->alignment,
 226                 int_type->size, int_type->is_signed,
 227                 byte_order);
 228 }
 229
 230 BT_HIDDEN
 231 int bt_ctf_field_floating_point_write(
 232                 struct bt_ctf_field_floating_point *flt_field,
 233                 struct bt_ctf_stream_pos *pos,
 234                 enum bt_ctf_byte_order native_byte_order)
 235 {
 236         struct bt_ctf_field_type *type = flt_field->parent.type;
 237         struct bt_ctf_field_type_floating_point *flt_type = (void *) type;
 238         enum bt_ctf_byte_order byte_order;
 239         union intval value;
 240         unsigned int size;
 241
 242         byte_order = flt_type->user_byte_order;
 243         if (byte_order == BT_CTF_BYTE_ORDER_NATIVE) {
 244                 byte_order = native_byte_order;
 245         }
 246
 247         if (flt_type->mant_dig == FLT_MANT_DIG) {
 248                 union u32f {
 249                         uint32_t u;
 250                         float f;
 251                 } u32f;
 252
 253                 u32f.f = (float) flt_field->payload;
 254                 value.unsignd = u32f.u;
 255                 size = 32;
 256         } else if (flt_type->mant_dig == DBL_MANT_DIG) {
 257                 union u64d {
 258                         uint64_t u;
 259                         double d;
 260                 } u64d;
 261
 262                 u64d.d = flt_field->payload;
 263                 value.unsignd = u64d.u;
 264                 size = 64;
 265         } else {
 266                 return -EINVAL;
 267         }
 268
 269         return integer_write(pos, value, type->alignment, size, false,
 270                 byte_order);
 271 }
 272
 273 BT_HIDDEN
 274 void bt_ctf_stream_pos_packet_seek(struct bt_ctf_stream_pos *pos, size_t index,
 275         int whence)
 276 {
 277         int ret;
 278
 279         assert(whence == SEEK_CUR && index == 0);
 280
 281         if (pos->base_mma) {
 282                 /* unmap old base */
 283                 ret = munmap_align(pos->base_mma);
 284                 if (ret) {
 285                         assert(false);
 286                 }
 287                 pos->base_mma = NULL;
 288         }
 289
 290         /* The writer will add padding */
 291         pos->mmap_offset += pos->packet_size / CHAR_BIT;
 292         pos->content_size = -1U;        /* Unknown at this point */
 293         pos->packet_size = getpagesize() * 8 * CHAR_BIT;
 294         do {
 295                 ret = bt_posix_fallocate(pos->fd, pos->mmap_offset,
 296                         pos->packet_size / CHAR_BIT);
 297         } while (ret == EINTR);
 298         assert(ret == 0);
 299         pos->offset = 0;
 300
 301         /* map new base. Need mapping length from header. */
 302         pos->base_mma = mmap_align(pos->packet_size / CHAR_BIT, pos->prot,
 303                 pos->flags, pos->fd, pos->mmap_offset);
 304         if (pos->base_mma == MAP_FAILED) {
 305                 assert(false);
 306         }
 307 }