lib/trace-ir/event.c

   1 /*
   2  * Copyright 2017-2018 Philippe Proulx <pproulx@efficios.com>
   3  * Copyright 2013, 2014 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to deal
   7  * in the Software without restriction, including without limitation the rights
   8  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9  * copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  */
  23
  24 #define BT_LOG_TAG "EVENT"
  25 #include <babeltrace/lib-logging-internal.h>
  26
  27 #include <babeltrace/assert-pre-internal.h>
  28 #include <babeltrace/trace-ir/field-internal.h>
  29 #include <babeltrace/trace-ir/field-class-internal.h>
  30 #include <babeltrace/trace-ir/clock-class.h>
  31 #include <babeltrace/trace-ir/clock-value-const.h>
  32 #include <babeltrace/trace-ir/clock-value-internal.h>
  33 #include <babeltrace/trace-ir/clock-class-internal.h>
  34 #include <babeltrace/trace-ir/event-const.h>
  35 #include <babeltrace/trace-ir/event-internal.h>
  36 #include <babeltrace/trace-ir/event-class.h>
  37 #include <babeltrace/trace-ir/event-class-internal.h>
  38 #include <babeltrace/trace-ir/stream-class.h>
  39 #include <babeltrace/trace-ir/stream-class-const.h>
  40 #include <babeltrace/trace-ir/stream-class-internal.h>
  41 #include <babeltrace/trace-ir/stream-internal.h>
  42 #include <babeltrace/trace-ir/packet.h>
  43 #include <babeltrace/trace-ir/packet-internal.h>
  44 #include <babeltrace/trace-ir/trace.h>
  45 #include <babeltrace/trace-ir/trace-internal.h>
  46 #include <babeltrace/trace-ir/packet-internal.h>
  47 #include <babeltrace/object.h>
  48 #include <babeltrace/trace-ir/attributes-internal.h>
  49 #include <babeltrace/compiler-internal.h>
  50 #include <babeltrace/assert-internal.h>
  51 #include <inttypes.h>
  52
  53 BT_HIDDEN
  54 void _bt_event_set_is_frozen(const struct bt_event *event, bool is_frozen)
  55 {
  56         BT_ASSERT(event);
  57         BT_LIB_LOGD("Setting event's frozen state: %!+e, is-frozen=%d",
  58                 event, is_frozen);
  59
  60         if (event->header_field) {
  61                 BT_LOGD_STR("Setting event's header field's frozen state.");
  62                 bt_field_set_is_frozen(
  63                         event->header_field->field, is_frozen);
  64         }
  65
  66         if (event->common_context_field) {
  67                 BT_LOGD_STR("Setting event's common context field's frozen state.");
  68                 bt_field_set_is_frozen(
  69                         event->common_context_field, is_frozen);
  70         }
  71
  72         if (event->specific_context_field) {
  73                 BT_LOGD_STR("Setting event's specific context field's frozen state.");
  74                 bt_field_set_is_frozen(event->specific_context_field,
  75                         is_frozen);
  76         }
  77
  78         if (event->payload_field) {
  79                 BT_LOGD_STR("Setting event's payload field's frozen state.");
  80                 bt_field_set_is_frozen(event->payload_field,
  81                         is_frozen);
  82         }
  83
  84         ((struct bt_event *) event)->frozen = is_frozen;
  85         BT_LOGD_STR("Setting event's packet's frozen state.");
  86         bt_packet_set_is_frozen(event->packet, is_frozen);
  87 }
  88
  89 static
  90 void recycle_event_header_field(struct bt_field_wrapper *field_wrapper,
  91                 struct bt_stream_class *stream_class)
  92 {
  93         BT_ASSERT(field_wrapper);
  94         BT_LIB_LOGD("Recycling event header field: "
  95                 "addr=%p, %![sc-]+S, %![field-]+f", field_wrapper,
  96                 stream_class, field_wrapper->field);
  97         bt_object_pool_recycle_object(
  98                 &stream_class->event_header_field_pool,
  99                 field_wrapper);
 100 }
 101
 102 static inline
 103 struct bt_field_wrapper *create_event_header_field(
 104                 struct bt_stream_class *stream_class)
 105 {
 106         struct bt_field_wrapper *field_wrapper = NULL;
 107
 108         field_wrapper = bt_field_wrapper_create(
 109                 &stream_class->event_header_field_pool,
 110                 stream_class->event_header_fc);
 111         if (!field_wrapper) {
 112                 goto error;
 113         }
 114
 115         goto end;
 116
 117 error:
 118         if (field_wrapper) {
 119                 recycle_event_header_field(field_wrapper, stream_class);
 120                 field_wrapper = NULL;
 121         }
 122
 123 end:
 124         return field_wrapper;
 125 }
 126
 127 BT_HIDDEN
 128 struct bt_event *bt_event_new(struct bt_event_class *event_class)
 129 {
 130         struct bt_event *event = NULL;
 131         struct bt_stream_class *stream_class;
 132         struct bt_field_class *fc;
 133
 134         BT_ASSERT(event_class);
 135         event = g_new0(struct bt_event, 1);
 136         if (!event) {
 137                 BT_LOGE_STR("Failed to allocate one event.");
 138                 goto error;
 139         }
 140
 141         bt_object_init_unique(&event->base);
 142         stream_class = bt_event_class_borrow_stream_class(event_class);
 143         BT_ASSERT(stream_class);
 144
 145         if (stream_class->event_header_fc) {
 146                 event->header_field = create_event_header_field(stream_class);
 147                 if (!event->header_field) {
 148                         BT_LOGE_STR("Cannot create event header field.");
 149                         goto error;
 150                 }
 151         }
 152
 153         fc = stream_class->event_common_context_fc;
 154         if (fc) {
 155                 event->common_context_field = bt_field_create(fc);
 156                 if (!event->common_context_field) {
 157                         /* bt_field_create() logs errors */
 158                         goto error;
 159                 }
 160         }
 161
 162         fc = event_class->specific_context_fc;
 163         if (fc) {
 164                 event->specific_context_field = bt_field_create(fc);
 165                 if (!event->specific_context_field) {
 166                         /* bt_field_create() logs errors */
 167                         goto error;
 168                 }
 169         }
 170
 171         fc = event_class->payload_fc;
 172         if (fc) {
 173                 event->payload_field = bt_field_create(fc);
 174                 if (!event->payload_field) {
 175                         /* bt_field_create() logs errors */
 176                         goto error;
 177                 }
 178         }
 179
 180         if (stream_class->default_clock_class) {
 181                 event->default_cv = bt_clock_value_create(
 182                         stream_class->default_clock_class);
 183                 if (!event->default_cv) {
 184                         /* bt_clock_value_create() logs errors */
 185                         goto error;
 186                 }
 187         }
 188
 189         goto end;
 190
 191 error:
 192         if (event) {
 193                 bt_event_destroy(event);
 194                 event = NULL;
 195         }
 196
 197 end:
 198         return event;
 199 }
 200
 201 struct bt_event_class *bt_event_borrow_class(struct bt_event *event)
 202 {
 203         BT_ASSERT_PRE_NON_NULL(event, "Event");
 204         return event->class;
 205 }
 206
 207 const struct bt_event_class *bt_event_borrow_class_const(
 208                 const struct bt_event *event)
 209 {
 210         return bt_event_borrow_class((void *) event);
 211 }
 212
 213 struct bt_stream *bt_event_borrow_stream(struct bt_event *event)
 214 {
 215         BT_ASSERT_PRE_NON_NULL(event, "Event");
 216         return event->packet ? event->packet->stream : NULL;
 217 }
 218
 219 const struct bt_stream *bt_event_borrow_stream_const(
 220                 const struct bt_event *event)
 221 {
 222         return bt_event_borrow_stream((void *) event);
 223 }
 224
 225 struct bt_field *bt_event_borrow_header_field(struct bt_event *event)
 226 {
 227         BT_ASSERT_PRE_NON_NULL(event, "Event");
 228         return event->header_field ? event->header_field->field : NULL;
 229 }
 230
 231 const struct bt_field *bt_event_borrow_header_field_const(
 232                 const struct bt_event *event)
 233 {
 234         BT_ASSERT_PRE_NON_NULL(event, "Event");
 235         return event->header_field ? event->header_field->field : NULL;
 236 }
 237
 238 struct bt_field *bt_event_borrow_common_context_field(struct bt_event *event)
 239 {
 240         BT_ASSERT_PRE_NON_NULL(event, "Event");
 241         return event->common_context_field;
 242 }
 243
 244 const struct bt_field *bt_event_borrow_common_context_field_const(
 245                 const struct bt_event *event)
 246 {
 247         BT_ASSERT_PRE_NON_NULL(event, "Event");
 248         return event->common_context_field;
 249 }
 250
 251 struct bt_field *bt_event_borrow_specific_context_field(struct bt_event *event)
 252 {
 253         BT_ASSERT_PRE_NON_NULL(event, "Event");
 254         return event->specific_context_field;
 255 }
 256
 257 const struct bt_field *bt_event_borrow_specific_context_field_const(
 258                 const struct bt_event *event)
 259 {
 260         BT_ASSERT_PRE_NON_NULL(event, "Event");
 261         return event->specific_context_field;
 262 }
 263
 264 struct bt_field *bt_event_borrow_payload_field(struct bt_event *event)
 265 {
 266         BT_ASSERT_PRE_NON_NULL(event, "Event");
 267         return event->payload_field;
 268 }
 269
 270 const struct bt_field *bt_event_borrow_payload_field_const(
 271                 const struct bt_event *event)
 272 {
 273         BT_ASSERT_PRE_NON_NULL(event, "Event");
 274         return event->payload_field;
 275 }
 276
 277 static
 278 void release_event_header_field(struct bt_field_wrapper *field_wrapper,
 279                 struct bt_event *event)
 280 {
 281         if (!event->class) {
 282                 bt_field_wrapper_destroy(field_wrapper);
 283         } else {
 284                 struct bt_stream_class *stream_class =
 285                         bt_event_class_borrow_stream_class(event->class);
 286
 287                 BT_ASSERT(stream_class);
 288                 recycle_event_header_field(field_wrapper, stream_class);
 289         }
 290 }
 291
 292 BT_HIDDEN
 293 void bt_event_destroy(struct bt_event *event)
 294 {
 295         BT_ASSERT(event);
 296         BT_LIB_LOGD("Destroying event: %!+e", event);
 297
 298         if (event->header_field) {
 299                 BT_LOGD_STR("Releasing event's header field.");
 300                 release_event_header_field(event->header_field, event);
 301                 event->header_field = NULL;
 302         }
 303
 304         if (event->common_context_field) {
 305                 BT_LOGD_STR("Destroying event's stream event context field.");
 306                 bt_field_destroy(event->common_context_field);
 307                 event->common_context_field = NULL;
 308         }
 309
 310         if (event->specific_context_field) {
 311                 BT_LOGD_STR("Destroying event's context field.");
 312                 bt_field_destroy(event->specific_context_field);
 313                 event->specific_context_field = NULL;
 314         }
 315
 316         if (event->payload_field) {
 317                 BT_LOGD_STR("Destroying event's payload field.");
 318                 bt_field_destroy(event->payload_field);
 319                 event->payload_field = NULL;
 320         }
 321
 322         BT_LOGD_STR("Putting event's class.");
 323         bt_object_put_ref(event->class);
 324
 325         if (event->default_cv) {
 326                 bt_clock_value_recycle(event->default_cv);
 327                 event->default_cv = NULL;
 328         }
 329
 330         BT_LOGD_STR("Putting event's packet.");
 331         BT_OBJECT_PUT_REF_AND_RESET(event->packet);
 332         g_free(event);
 333 }
 334
 335 void bt_event_set_default_clock_value(struct bt_event *event,
 336                 uint64_t value_cycles)
 337 {
 338         struct bt_stream_class *sc;
 339
 340         BT_ASSERT_PRE_NON_NULL(event, "Event");
 341         BT_ASSERT_PRE_EVENT_HOT(event);
 342         sc = bt_event_class_borrow_stream_class_inline(event->class);
 343         BT_ASSERT(sc);
 344         BT_ASSERT_PRE(sc->default_clock_class,
 345                 "Event's stream class has no default clock class: "
 346                 "%![ev-]+e, %![sc-]+S", event, sc);
 347         BT_ASSERT(event->default_cv);
 348         bt_clock_value_set_value_inline(event->default_cv, value_cycles);
 349         BT_LIB_LOGV("Set event's default clock value: %![event-]+e, "
 350                 "value=%" PRIu64, event, value_cycles);
 351 }
 352
 353 enum bt_clock_value_status bt_event_borrow_default_clock_value_const(
 354                 const struct bt_event *event,
 355                 const struct bt_clock_value **clock_value)
 356 {
 357         BT_ASSERT_PRE_NON_NULL(event, "Event");
 358         BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value (output)");
 359         *clock_value = event->default_cv;
 360         return BT_CLOCK_VALUE_STATUS_KNOWN;
 361 }
 362
 363 struct bt_packet *bt_event_borrow_packet(struct bt_event *event)
 364 {
 365         BT_ASSERT_PRE_NON_NULL(event, "Event");
 366         return event->packet;
 367 }
 368
 369 const struct bt_packet *bt_event_borrow_packet_const(
 370                 const struct bt_event *event)
 371 {
 372         return bt_event_borrow_packet((void *) event);
 373 }
 374
 375 int bt_event_move_header_field(struct bt_event *event,
 376                 struct bt_event_header_field *header_field)
 377 {
 378         struct bt_stream_class *stream_class;
 379         struct bt_field_wrapper *field_wrapper = (void *) header_field;
 380
 381         BT_ASSERT_PRE_NON_NULL(event, "Event");
 382         BT_ASSERT_PRE_NON_NULL(field_wrapper, "Header field");
 383         BT_ASSERT_PRE_EVENT_HOT(event);
 384         stream_class = bt_event_class_borrow_stream_class_inline(event->class);
 385         BT_ASSERT_PRE(stream_class->event_header_fc,
 386                 "Stream class has no event header field class: %!+S",
 387                 stream_class);
 388
 389         /* Recycle current header field: always exists */
 390         BT_ASSERT(event->header_field);
 391         recycle_event_header_field(event->header_field, stream_class);
 392
 393         /* Move new field */
 394         event->header_field = field_wrapper;
 395         return 0;
 396 }