plugins/utils/trimmer/iterator.c

   1 /*
   2  * iterator.c
   3  *
   4  * Babeltrace Trace Trimmer Iterator
   5  *
   6  * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  *
   8  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  */
  28
  29 #include "trimmer.h"
  30 #include "iterator.h"
  31 #include <babeltrace/component/notification/iterator.h>
  32 #include <babeltrace/component/notification/notification.h>
  33 #include <babeltrace/component/notification/event.h>
  34 #include <babeltrace/component/notification/stream.h>
  35 #include <babeltrace/component/notification/packet.h>
  36 #include <babeltrace/component/component-filter.h>
  37 #include <babeltrace/ctf-ir/event.h>
  38 #include <babeltrace/ctf-ir/stream.h>
  39 #include <babeltrace/ctf-ir/stream-class.h>
  40 #include <babeltrace/ctf-ir/clock-class.h>
  41 #include <babeltrace/ctf-ir/packet.h>
  42 #include <babeltrace/ctf-ir/trace.h>
  43 #include <babeltrace/ctf-ir/fields.h>
  44 #include <assert.h>
  45 #include <plugins-common.h>
  46
  47 BT_HIDDEN
  48 void trimmer_iterator_destroy(struct bt_notification_iterator *it)
  49 {
  50         struct trimmer_iterator *it_data;
  51
  52         it_data = bt_notification_iterator_get_private_data(it);
  53         assert(it_data);
  54
  55         if (it_data->input_iterator_group) {
  56                 g_ptr_array_free(it_data->input_iterator_group, TRUE);
  57         }
  58         bt_put(it_data->current_notification);
  59         g_free(it_data);
  60 }
  61
  62 BT_HIDDEN
  63 enum bt_notification_iterator_status trimmer_iterator_init(
  64                 struct bt_component *component,
  65                 struct bt_notification_iterator *iterator,
  66                 UNUSED_VAR void *init_method_data)
  67 {
  68         enum bt_notification_iterator_status ret =
  69                 BT_NOTIFICATION_ITERATOR_STATUS_OK;
  70         enum bt_notification_iterator_status it_ret;
  71         struct trimmer_iterator *it_data = g_new0(struct trimmer_iterator, 1);
  72
  73         if (!it_data) {
  74                 ret = BT_NOTIFICATION_ITERATOR_STATUS_NOMEM;
  75                 goto end;
  76         }
  77
  78         /* FIXME init trimmer_iterator */
  79         it_ret = bt_notification_iterator_set_private_data(iterator, it_data);
  80         if (it_ret) {
  81                 goto end;
  82         }
  83 end:
  84         return ret;
  85 }
  86
  87 BT_HIDDEN
  88 struct bt_notification *trimmer_iterator_get(
  89                 struct bt_notification_iterator *iterator)
  90 {
  91         struct trimmer_iterator *trim_it;
  92
  93         trim_it = bt_notification_iterator_get_private_data(iterator);
  94         assert(trim_it);
  95
  96         if (!trim_it->current_notification) {
  97                 enum bt_notification_iterator_status it_ret;
  98
  99                 it_ret = trimmer_iterator_next(iterator);
 100                 if (it_ret) {
 101                         goto end;
 102                 }
 103         }
 104 end:
 105         return bt_get(trim_it->current_notification);
 106 }
 107
 108 static
 109 int update_lazy_bound(struct trimmer_bound *bound, const char *name,
 110                 int64_t ts, bool *lazy_update)
 111 {
 112         struct tm tm;
 113         int64_t value;
 114         time_t timeval;
 115
 116         *lazy_update = false;
 117
 118         if (!bound->lazy) {
 119                 return 0;
 120         }
 121         tm.tm_isdst = -1;
 122         timeval = ts / NSEC_PER_SEC;
 123
 124         if (bound->lazy_values.gmt) {
 125                 /* Get day, month, year. */
 126                 if (!gmtime_r(&timeval, &tm)) {
 127                         printf_error("Failure in gmtime_r()");
 128                         goto error;
 129                 }
 130                 tm.tm_sec = bound->lazy_values.ss;
 131                 tm.tm_min = bound->lazy_values.mm;
 132                 tm.tm_hour = bound->lazy_values.hh;
 133                 timeval = timegm(&tm);
 134                 if (timeval < 0) {
 135                         printf_error("Failure in timegm(), incorrectly formatted %s timestamp",
 136                                         name);
 137                         goto error;
 138                 }
 139         } else {
 140                 /* Get day, month, year. */
 141                 if (!localtime_r(&timeval, &tm)) {
 142                         printf_error("Failure in localtime_r()");
 143                         goto error;
 144                 }
 145                 tm.tm_sec = bound->lazy_values.ss;
 146                 tm.tm_min = bound->lazy_values.mm;
 147                 tm.tm_hour = bound->lazy_values.hh;
 148                 timeval = mktime(&tm);
 149                 if (timeval < 0) {
 150                         printf_error("Failure in mktime(), incorrectly formatted %s timestamp",
 151                                 name);
 152                         goto error;
 153                 }
 154         }
 155         value = (int64_t) timeval;
 156         value *= NSEC_PER_SEC;
 157         value += bound->lazy_values.ns;
 158         bound->value = value;
 159         bound->set = true;
 160         bound->lazy = false;
 161         *lazy_update = true;
 162         return 0;
 163
 164 error:
 165         return -1;
 166 }
 167
 168 static
 169 enum bt_notification_iterator_status
 170 evaluate_event_notification(struct bt_notification *notification,
 171                 struct trimmer_bound *begin, struct trimmer_bound *end,
 172                 bool *_event_in_range)
 173 {
 174         int64_t ts;
 175         int clock_ret;
 176         struct bt_ctf_event *event = NULL;
 177         bool in_range = true;
 178         struct bt_ctf_clock_class *clock_class = NULL;
 179         struct bt_ctf_trace *trace = NULL;
 180         struct bt_ctf_stream *stream = NULL;
 181         struct bt_ctf_stream_class *stream_class = NULL;
 182         struct bt_ctf_clock_value *clock_value = NULL;
 183         enum bt_notification_iterator_status ret =
 184                         BT_NOTIFICATION_ITERATOR_STATUS_OK;
 185         bool lazy_update = false;
 186
 187         event = bt_notification_event_get_event(notification);
 188         assert(event);
 189
 190         stream = bt_ctf_event_get_stream(event);
 191         assert(stream);
 192
 193         stream_class = bt_ctf_stream_get_class(stream);
 194         assert(stream_class);
 195
 196         trace = bt_ctf_stream_class_get_trace(stream_class);
 197         assert(trace);
 198
 199         /* FIXME multi-clock? */
 200         clock_class = bt_ctf_trace_get_clock_class(trace, 0);
 201         if (!clock_class) {
 202                 goto end;
 203         }
 204
 205         clock_value = bt_ctf_event_get_clock_value(event, clock_class);
 206         if (!clock_value) {
 207                 printf_error("Failed to retrieve clock value");
 208                 ret = BT_NOTIFICATION_ITERATOR_STATUS_ERROR;
 209                 goto end;
 210         }
 211
 212         clock_ret = bt_ctf_clock_value_get_value_ns_from_epoch(
 213                         clock_value, &ts);
 214         if (clock_ret) {
 215                 printf_error("Failed to retrieve clock value timestamp");
 216                 ret = BT_NOTIFICATION_ITERATOR_STATUS_ERROR;
 217                 goto end;
 218         }
 219         if (update_lazy_bound(begin, "begin", ts, &lazy_update)) {
 220                 ret = BT_NOTIFICATION_ITERATOR_STATUS_ERROR;
 221                 goto end;
 222         }
 223         if (update_lazy_bound(end, "end", ts, &lazy_update)) {
 224                 ret = BT_NOTIFICATION_ITERATOR_STATUS_ERROR;
 225                 goto end;
 226         }
 227         if (lazy_update && begin->set && end->set) {
 228                 if (begin->value > end->value) {
 229                         printf_error("Unexpected: time range begin value is above end value");
 230                         ret = BT_NOTIFICATION_ITERATOR_STATUS_ERROR;
 231                         goto end;
 232                 }
 233         }
 234         if (begin->set && ts < begin->value) {
 235                 in_range = false;
 236         }
 237         if (end->set && ts > end->value) {
 238                 in_range = false;
 239         }
 240 end:
 241         bt_put(event);
 242         bt_put(clock_class);
 243         bt_put(trace);
 244         bt_put(stream);
 245         bt_put(stream_class);
 246         bt_put(clock_value);
 247         *_event_in_range = in_range;
 248         return ret;
 249 }
 250
 251 static
 252 int ns_from_integer_field(struct bt_ctf_field *integer, int64_t *ns)
 253 {
 254         int ret = 0;
 255         int is_signed;
 256         uint64_t raw_clock_value;
 257         struct bt_ctf_field_type *integer_type = NULL;
 258         struct bt_ctf_clock_class *clock_class = NULL;
 259         struct bt_ctf_clock_value *clock_value = NULL;
 260
 261         integer_type = bt_ctf_field_get_type(integer);
 262         assert(integer_type);
 263         clock_class = bt_ctf_field_type_integer_get_mapped_clock_class(
 264                 integer_type);
 265         if (!clock_class) {
 266                 ret = -1;
 267                 goto end;
 268         }
 269
 270         is_signed = bt_ctf_field_type_integer_get_signed(integer_type);
 271         if (!is_signed) {
 272                 ret = bt_ctf_field_unsigned_integer_get_value(integer,
 273                                 &raw_clock_value);
 274                 if (ret) {
 275                         goto end;
 276                 }
 277         } else {
 278                 /* Signed clock values are unsupported. */
 279                 goto end;
 280         }
 281
 282         clock_value = bt_ctf_clock_value_create(clock_class, raw_clock_value);
 283         if (!clock_value) {
 284                 goto end;
 285         }
 286
 287         ret = bt_ctf_clock_value_get_value_ns_from_epoch(clock_value, ns);
 288 end:
 289         bt_put(integer_type);
 290         bt_put(clock_class);
 291         bt_put(clock_value);
 292         return ret;
 293 }
 294
 295 static
 296 enum bt_notification_iterator_status evaluate_packet_notification(
 297                 struct bt_notification *notification,
 298                 struct trimmer_bound *begin, struct trimmer_bound *end,
 299                 bool *_packet_in_range)
 300 {
 301         enum bt_notification_iterator_status ret =
 302                         BT_NOTIFICATION_ITERATOR_STATUS_OK;
 303         int64_t begin_ns, pkt_begin_ns, end_ns, pkt_end_ns;
 304         bool in_range = true;
 305         struct bt_ctf_packet *packet = NULL;
 306         struct bt_ctf_field *packet_context = NULL,
 307                         *timestamp_begin = NULL,
 308                         *timestamp_end = NULL;
 309
 310         switch (bt_notification_get_type(notification)) {
 311         case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
 312                 packet = bt_notification_packet_begin_get_packet(notification);
 313                 break;
 314         case BT_NOTIFICATION_TYPE_PACKET_END:
 315                 packet = bt_notification_packet_end_get_packet(notification);
 316                 break;
 317         default:
 318                 break;
 319         }
 320         assert(packet);
 321
 322         packet_context = bt_ctf_packet_get_context(packet);
 323         if (!packet_context) {
 324                 goto end;
 325         }
 326
 327         if (!bt_ctf_field_is_structure(packet_context)) {
 328                 goto end;
 329         }
 330
 331         timestamp_begin = bt_ctf_field_structure_get_field(
 332                         packet_context, "timestamp_begin");
 333         if (!timestamp_begin || !bt_ctf_field_is_integer(timestamp_begin)) {
 334                 goto end;
 335         }
 336         timestamp_end = bt_ctf_field_structure_get_field(
 337                         packet_context, "timestamp_end");
 338         if (!timestamp_end || !bt_ctf_field_is_integer(timestamp_end)) {
 339                 goto end;
 340         }
 341
 342         if (ns_from_integer_field(timestamp_begin, &pkt_begin_ns)) {
 343                 goto end;
 344         }
 345         if (ns_from_integer_field(timestamp_end, &pkt_end_ns)) {
 346                 goto end;
 347         }
 348
 349         begin_ns = begin->set ? begin->value : INT64_MIN;
 350         end_ns = end->set ? end->value : INT64_MAX;
 351
 352         /*
 353          * Accept if there is any overlap between the selected region and the
 354          * packet.
 355          */
 356         in_range = (pkt_end_ns >= begin_ns) && (pkt_begin_ns <= end_ns);
 357 end:
 358         *_packet_in_range = in_range;
 359         bt_put(packet);
 360         bt_put(packet_context);
 361         bt_put(timestamp_begin);
 362         bt_put(timestamp_end);
 363         return ret;
 364 }
 365
 366 /* Return true if the notification should be forwarded. */
 367 static
 368 enum bt_notification_iterator_status evaluate_notification(
 369                 struct bt_notification *notification,
 370                 struct trimmer_bound *begin, struct trimmer_bound *end,
 371                 bool *in_range)
 372 {
 373         enum bt_notification_type type;
 374         enum bt_notification_iterator_status ret =
 375                         BT_NOTIFICATION_ITERATOR_STATUS_OK;
 376
 377         *in_range = true;
 378         type = bt_notification_get_type(notification);
 379         switch (type) {
 380         case BT_NOTIFICATION_TYPE_EVENT:
 381                 ret = evaluate_event_notification(notification, begin,
 382                                 end, in_range);
 383                 break;
 384         case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
 385         case BT_NOTIFICATION_TYPE_PACKET_END:
 386                 ret = evaluate_packet_notification(notification, begin,
 387                                 end, in_range);
 388                 break;
 389         default:
 390                 /* Accept all other notifications. */
 391                 break;
 392         }
 393         return ret;
 394 }
 395
 396 BT_HIDDEN
 397 enum bt_notification_iterator_status trimmer_iterator_next(
 398                 struct bt_notification_iterator *iterator)
 399 {
 400         struct trimmer_iterator *trim_it = NULL;
 401         struct bt_component *component = NULL;
 402         struct trimmer *trimmer = NULL;
 403         struct bt_notification_iterator *source_it = NULL;
 404         enum bt_notification_iterator_status ret =
 405                         BT_NOTIFICATION_ITERATOR_STATUS_OK;
 406         enum bt_component_status component_ret;
 407         bool notification_in_range = false;
 408
 409         trim_it = bt_notification_iterator_get_private_data(iterator);
 410         assert(trim_it);
 411
 412         component = bt_notification_iterator_get_component(iterator);
 413         assert(component);
 414         trimmer = bt_component_get_private_data(component);
 415         assert(trimmer);
 416
 417         /* FIXME, should handle input iterator groups. */
 418         component_ret = bt_component_filter_get_input_iterator(component, 0,
 419                         &source_it);
 420         assert((component_ret == BT_COMPONENT_STATUS_OK) && source_it);
 421
 422         while (!notification_in_range) {
 423                 struct bt_notification *notification;
 424
 425                 ret = bt_notification_iterator_next(source_it);
 426                 if (ret != BT_NOTIFICATION_ITERATOR_STATUS_OK) {
 427                         goto end;
 428                 }
 429
 430                 notification = bt_notification_iterator_get_notification(
 431                                 source_it);
 432                 if (!notification) {
 433                         ret = BT_NOTIFICATION_ITERATOR_STATUS_ERROR;
 434                         goto end;
 435                 }
 436
 437                 ret = evaluate_notification(notification,
 438                                 &trimmer->begin, &trimmer->end,
 439                                 &notification_in_range);
 440                 if (notification_in_range) {
 441                         BT_MOVE(trim_it->current_notification, notification);
 442                 } else {
 443                         bt_put(notification);
 444                 }
 445
 446                 if (ret != BT_NOTIFICATION_ITERATOR_STATUS_OK) {
 447                         break;
 448                 }
 449         }
 450 end:
 451         bt_put(source_it);
 452         bt_put(component);
 453         return ret;
 454 }
 455
 456 BT_HIDDEN
 457 enum bt_notification_iterator_status trimmer_iterator_seek_time(
 458                 struct bt_notification_iterator *iterator, int64_t time)
 459 {
 460         enum bt_notification_iterator_status ret;
 461
 462         ret = BT_NOTIFICATION_ITERATOR_STATUS_OK;
 463 end:
 464         return ret;
 465 }