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/trace-ir/attributes-internal.h>
  48 #include <babeltrace/assert-internal.h>
  49 #include <babeltrace/compiler-internal.h>
  50 #include <inttypes.h>
  51
  52 BT_HIDDEN
  53 void _bt_event_set_is_frozen(const struct bt_event *event, bool is_frozen)
  54 {
  55         BT_ASSERT(event);
  56         BT_LIB_LOGD("Setting event's frozen state: %!+e, is-frozen=%d",
  57                 event, is_frozen);
  58
  59         if (event->header_field) {
  60                 BT_LOGD_STR("Setting event's header field's frozen state.");
  61                 bt_field_set_is_frozen(
  62                         event->header_field->field, is_frozen);
  63         }
  64
  65         if (event->common_context_field) {
  66                 BT_LOGD_STR("Setting event's common context field's frozen state.");
  67                 bt_field_set_is_frozen(
  68                         event->common_context_field, is_frozen);
  69         }
  70
  71         if (event->specific_context_field) {
  72                 BT_LOGD_STR("Setting event's specific context field's frozen state.");
  73                 bt_field_set_is_frozen(event->specific_context_field,
  74                         is_frozen);
  75         }
  76
  77         if (event->payload_field) {
  78                 BT_LOGD_STR("Setting event's payload field's frozen state.");
  79                 bt_field_set_is_frozen(event->payload_field,
  80                         is_frozen);
  81         }
  82
  83         ((struct bt_event *) event)->frozen = is_frozen;
  84         BT_LOGD_STR("Setting event's packet's frozen state.");
  85         bt_packet_set_is_frozen(event->packet, is_frozen);
  86 }
  87
  88 static
  89 void recycle_event_header_field(struct bt_field_wrapper *field_wrapper,
  90                 struct bt_stream_class *stream_class)
  91 {
  92         BT_ASSERT(field_wrapper);
  93         BT_LIB_LOGD("Recycling event header field: "
  94                 "addr=%p, %![sc-]+S, %![field-]+f", field_wrapper,
  95                 stream_class, field_wrapper->field);
  96         bt_object_pool_recycle_object(
  97                 &stream_class->event_header_field_pool,
  98                 field_wrapper);
  99 }
 100
 101 static inline
 102 struct bt_field_wrapper *create_event_header_field(
 103                 struct bt_stream_class *stream_class)
 104 {
 105         struct bt_field_wrapper *field_wrapper = NULL;
 106
 107         field_wrapper = bt_field_wrapper_create(
 108                 &stream_class->event_header_field_pool,
 109                 stream_class->event_header_fc);
 110         if (!field_wrapper) {
 111                 goto error;
 112         }
 113
 114         goto end;
 115
 116 error:
 117         if (field_wrapper) {
 118                 recycle_event_header_field(field_wrapper, stream_class);
 119                 field_wrapper = NULL;
 120         }
 121
 122 end:
 123         return field_wrapper;
 124 }
 125
 126 BT_HIDDEN
 127 struct bt_event *bt_event_new(struct bt_event_class *event_class)
 128 {
 129         struct bt_event *event = NULL;
 130         struct bt_stream_class *stream_class;
 131         struct bt_field_class *fc;
 132
 133         BT_ASSERT(event_class);
 134         event = g_new0(struct bt_event, 1);
 135         if (!event) {
 136                 BT_LOGE_STR("Failed to allocate one event.");
 137                 goto error;
 138         }
 139
 140         bt_object_init_unique(&event->base);
 141         stream_class = bt_event_class_borrow_stream_class(event_class);
 142         BT_ASSERT(stream_class);
 143
 144         if (stream_class->event_header_fc) {
 145                 event->header_field = create_event_header_field(stream_class);
 146                 if (!event->header_field) {
 147                         BT_LOGE_STR("Cannot create event header field.");
 148                         goto error;
 149                 }
 150         }
 151
 152         fc = stream_class->event_common_context_fc;
 153         if (fc) {
 154                 event->common_context_field = bt_field_create(fc);
 155                 if (!event->common_context_field) {
 156                         /* bt_field_create() logs errors */
 157                         goto error;
 158                 }
 159         }
 160
 161         fc = event_class->specific_context_fc;
 162         if (fc) {
 163                 event->specific_context_field = bt_field_create(fc);
 164                 if (!event->specific_context_field) {
 165                         /* bt_field_create() logs errors */
 166                         goto error;
 167                 }
 168         }
 169
 170         fc = event_class->payload_fc;
 171         if (fc) {
 172                 event->payload_field = bt_field_create(fc);
 173                 if (!event->payload_field) {
 174                         /* bt_field_create() logs errors */
 175                         goto error;
 176                 }
 177         }
 178
 179         if (stream_class->default_clock_class) {
 180                 event->default_cv = bt_clock_value_create(
 181                         stream_class->default_clock_class);
 182                 if (!event->default_cv) {
 183                         /* bt_clock_value_create() logs errors */
 184                         goto error;
 185                 }
 186         }
 187
 188         goto end;
 189
 190 error:
 191         if (event) {
 192                 bt_event_destroy(event);
 193                 event = NULL;
 194         }
 195
 196 end:
 197         return event;
 198 }
 199
 200 struct bt_event_class *bt_event_borrow_class(struct bt_event *event)
 201 {
 202         BT_ASSERT_PRE_NON_NULL(event, "Event");
 203         return event->class;
 204 }
 205
 206 const struct bt_event_class *bt_event_borrow_class_const(
 207                 const struct bt_event *event)
 208 {
 209         return bt_event_borrow_class((void *) event);
 210 }
 211
 212 struct bt_stream *bt_event_borrow_stream(struct bt_event *event)
 213 {
 214         BT_ASSERT_PRE_NON_NULL(event, "Event");
 215         return event->packet ? event->packet->stream : NULL;
 216 }
 217
 218 const struct bt_stream *bt_event_borrow_stream_const(
 219                 const struct bt_event *event)
 220 {
 221         return bt_event_borrow_stream((void *) event);
 222 }
 223
 224 struct bt_field *bt_event_borrow_header_field(struct bt_event *event)
 225 {
 226         BT_ASSERT_PRE_NON_NULL(event, "Event");
 227         return event->header_field ? event->header_field->field : NULL;
 228 }
 229
 230 const struct bt_field *bt_event_borrow_header_field_const(
 231                 const struct bt_event *event)
 232 {
 233         BT_ASSERT_PRE_NON_NULL(event, "Event");
 234         return event->header_field ? event->header_field->field : NULL;
 235 }
 236
 237 struct bt_field *bt_event_borrow_common_context_field(struct bt_event *event)
 238 {
 239         BT_ASSERT_PRE_NON_NULL(event, "Event");
 240         return event->common_context_field;
 241 }
 242
 243 const struct bt_field *bt_event_borrow_common_context_field_const(
 244                 const struct bt_event *event)
 245 {
 246         BT_ASSERT_PRE_NON_NULL(event, "Event");
 247         return event->common_context_field;
 248 }
 249
 250 struct bt_field *bt_event_borrow_specific_context_field(struct bt_event *event)
 251 {
 252         BT_ASSERT_PRE_NON_NULL(event, "Event");
 253         return event->specific_context_field;
 254 }
 255
 256 const struct bt_field *bt_event_borrow_specific_context_field_const(
 257                 const struct bt_event *event)
 258 {
 259         BT_ASSERT_PRE_NON_NULL(event, "Event");
 260         return event->specific_context_field;
 261 }
 262
 263 struct bt_field *bt_event_borrow_payload_field(struct bt_event *event)
 264 {
 265         BT_ASSERT_PRE_NON_NULL(event, "Event");
 266         return event->payload_field;
 267 }
 268
 269 const struct bt_field *bt_event_borrow_payload_field_const(
 270                 const struct bt_event *event)
 271 {
 272         BT_ASSERT_PRE_NON_NULL(event, "Event");
 273         return event->payload_field;
 274 }
 275
 276 static
 277 void release_event_header_field(struct bt_field_wrapper *field_wrapper,
 278                 struct bt_event *event)
 279 {
 280         if (!event->class) {
 281                 bt_field_wrapper_destroy(field_wrapper);
 282         } else {
 283                 struct bt_stream_class *stream_class =
 284                         bt_event_class_borrow_stream_class(event->class);
 285
 286                 BT_ASSERT(stream_class);
 287                 recycle_event_header_field(field_wrapper, stream_class);
 288         }
 289 }
 290
 291 BT_HIDDEN
 292 void bt_event_destroy(struct bt_event *event)
 293 {
 294         BT_ASSERT(event);
 295         BT_LIB_LOGD("Destroying event: %!+e", event);
 296
 297         if (event->header_field) {
 298                 BT_LOGD_STR("Releasing event's header field.");
 299                 release_event_header_field(event->header_field, event);
 300                 event->header_field = NULL;
 301         }
 302
 303         if (event->common_context_field) {
 304                 BT_LOGD_STR("Destroying event's stream event context field.");
 305                 bt_field_destroy(event->common_context_field);
 306                 event->common_context_field = NULL;
 307         }
 308
 309         if (event->specific_context_field) {
 310                 BT_LOGD_STR("Destroying event's context field.");
 311                 bt_field_destroy(event->specific_context_field);
 312                 event->specific_context_field = NULL;
 313         }
 314
 315         if (event->payload_field) {
 316                 BT_LOGD_STR("Destroying event's payload field.");
 317                 bt_field_destroy(event->payload_field);
 318                 event->payload_field = NULL;
 319         }
 320
 321         BT_LOGD_STR("Putting event's class.");
 322         bt_object_put_ref(event->class);
 323
 324         if (event->default_cv) {
 325                 bt_clock_value_recycle(event->default_cv);
 326                 event->default_cv = NULL;
 327         }
 328
 329         BT_LOGD_STR("Putting event's packet.");
 330         BT_OBJECT_PUT_REF_AND_RESET(event->packet);
 331         g_free(event);
 332 }
 333
 334 void bt_event_set_default_clock_value(struct bt_event *event,
 335                 uint64_t value_cycles)
 336 {
 337         struct bt_stream_class *sc;
 338
 339         BT_ASSERT_PRE_NON_NULL(event, "Event");
 340         BT_ASSERT_PRE_EVENT_HOT(event);
 341         sc = bt_event_class_borrow_stream_class_inline(event->class);
 342         BT_ASSERT(sc);
 343         BT_ASSERT_PRE(sc->default_clock_class,
 344                 "Event's stream class has no default clock class: "
 345                 "%![ev-]+e, %![sc-]+S", event, sc);
 346         BT_ASSERT(event->default_cv);
 347         bt_clock_value_set_value_inline(event->default_cv, value_cycles);
 348         BT_LIB_LOGV("Set event's default clock value: %![event-]+e, "
 349                 "value=%" PRIu64, event, value_cycles);
 350 }
 351
 352 enum bt_clock_value_status bt_event_borrow_default_clock_value_const(
 353                 const struct bt_event *event,
 354                 const struct bt_clock_value **clock_value)
 355 {
 356         BT_ASSERT_PRE_NON_NULL(event, "Event");
 357         BT_ASSERT_PRE_NON_NULL(clock_value, "Clock value (output)");
 358         *clock_value = event->default_cv;
 359         return BT_CLOCK_VALUE_STATUS_KNOWN;
 360 }
 361
 362 struct bt_packet *bt_event_borrow_packet(struct bt_event *event)
 363 {
 364         BT_ASSERT_PRE_NON_NULL(event, "Event");
 365         return event->packet;
 366 }
 367
 368 const struct bt_packet *bt_event_borrow_packet_const(
 369                 const struct bt_event *event)
 370 {
 371         return bt_event_borrow_packet((void *) event);
 372 }
 373
 374 int bt_event_move_header_field(struct bt_event *event,
 375                 struct bt_event_header_field *header_field)
 376 {
 377         struct bt_stream_class *stream_class;
 378         struct bt_field_wrapper *field_wrapper = (void *) header_field;
 379
 380         BT_ASSERT_PRE_NON_NULL(event, "Event");
 381         BT_ASSERT_PRE_NON_NULL(field_wrapper, "Header field");
 382         BT_ASSERT_PRE_EVENT_HOT(event);
 383         stream_class = bt_event_class_borrow_stream_class_inline(event->class);
 384         BT_ASSERT_PRE(stream_class->event_header_fc,
 385                 "Stream class has no event header field class: %!+S",
 386                 stream_class);
 387
 388         /* Recycle current header field: always exists */
 389         BT_ASSERT(event->header_field);
 390         recycle_event_header_field(event->header_field, stream_class);
 391
 392         /* Move new field */
 393         event->header_field = field_wrapper;
 394         return 0;
 395 }