Replace assert() -> BT_ASSERT() and some preconditions with BT_ASSERT_PRE()
[babeltrace.git] / 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 #define BT_LOG_TAG "PLUGIN-UTILS-TRIMMER-FLT-ITER"
30 #include "logging.h"
31
32 #include <babeltrace/compat/time-internal.h>
33 #include <babeltrace/compat/utc-internal.h>
34 #include <babeltrace/babeltrace.h>
35 #include <babeltrace/assert-internal.h>
36 #include <plugins-common.h>
37
38 #include "trimmer.h"
39 #include "iterator.h"
40 #include "copy.h"
41
42 static
43 gboolean close_packets(gpointer key, gpointer value, gpointer user_data)
44 {
45 struct bt_packet *writer_packet = value;
46
47 bt_put(writer_packet);
48 return TRUE;
49 }
50
51 BT_HIDDEN
52 void trimmer_iterator_finalize(struct bt_private_connection_private_notification_iterator *it)
53 {
54 struct trimmer_iterator *trim_it;
55
56 trim_it = bt_private_connection_private_notification_iterator_get_user_data(it);
57 BT_ASSERT(trim_it);
58
59 bt_put(trim_it->input_iterator);
60 g_hash_table_foreach_remove(trim_it->packet_map,
61 close_packets, NULL);
62 g_hash_table_destroy(trim_it->packet_map);
63 g_free(trim_it);
64 }
65
66 BT_HIDDEN
67 enum bt_notification_iterator_status trimmer_iterator_init(
68 struct bt_private_connection_private_notification_iterator *iterator,
69 struct bt_private_port *port)
70 {
71 enum bt_notification_iterator_status ret =
72 BT_NOTIFICATION_ITERATOR_STATUS_OK;
73 enum bt_notification_iterator_status it_ret;
74 enum bt_connection_status conn_status;
75 struct bt_private_port *input_port = NULL;
76 struct bt_private_connection *connection = NULL;
77 struct bt_private_component *component =
78 bt_private_connection_private_notification_iterator_get_private_component(iterator);
79 struct trimmer_iterator *it_data = g_new0(struct trimmer_iterator, 1);
80 static const enum bt_notification_type notif_types[] = {
81 BT_NOTIFICATION_TYPE_EVENT,
82 BT_NOTIFICATION_TYPE_STREAM_END,
83 BT_NOTIFICATION_TYPE_PACKET_BEGIN,
84 BT_NOTIFICATION_TYPE_PACKET_END,
85 BT_NOTIFICATION_TYPE_SENTINEL,
86 };
87
88 if (!it_data) {
89 ret = BT_NOTIFICATION_ITERATOR_STATUS_NOMEM;
90 goto end;
91 }
92
93 /* Create a new iterator on the upstream component. */
94 input_port = bt_private_component_filter_get_input_private_port_by_name(
95 component, "in");
96 BT_ASSERT(input_port);
97 connection = bt_private_port_get_private_connection(input_port);
98 BT_ASSERT(connection);
99
100 conn_status = bt_private_connection_create_notification_iterator(connection,
101 notif_types, &it_data->input_iterator);
102 if (conn_status != BT_CONNECTION_STATUS_OK) {
103 ret = BT_NOTIFICATION_ITERATOR_STATUS_ERROR;
104 goto end;
105 }
106
107 it_data->err = stderr;
108 it_data->packet_map = g_hash_table_new_full(g_direct_hash,
109 g_direct_equal, NULL, NULL);
110
111 it_ret = bt_private_connection_private_notification_iterator_set_user_data(iterator,
112 it_data);
113 if (it_ret) {
114 goto end;
115 }
116 end:
117 bt_put(component);
118 bt_put(connection);
119 bt_put(input_port);
120 return ret;
121 }
122
123 static
124 int update_lazy_bound(struct trimmer_bound *bound, const char *name,
125 int64_t ts, bool *lazy_update)
126 {
127 struct tm tm;
128 int64_t value;
129 time_t timeval;
130
131 *lazy_update = false;
132
133 if (!bound->lazy) {
134 return 0;
135 }
136 tm.tm_isdst = -1;
137 timeval = ts / NSEC_PER_SEC;
138
139 if (bound->lazy_values.gmt) {
140 /* Get day, month, year. */
141 if (!bt_gmtime_r(&timeval, &tm)) {
142 BT_LOGE_STR("Failure in bt_gmtime_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 = bt_timegm(&tm);
149 if (timeval < 0) {
150 BT_LOGE("Failure in bt_timegm(), incorrectly formatted %s timestamp",
151 name);
152 goto error;
153 }
154 } else {
155 /* Get day, month, year. */
156 if (!bt_localtime_r(&timeval, &tm)) {
157 BT_LOGE_STR("Failure in bt_localtime_r().");
158 goto error;
159 }
160 tm.tm_sec = bound->lazy_values.ss;
161 tm.tm_min = bound->lazy_values.mm;
162 tm.tm_hour = bound->lazy_values.hh;
163 timeval = mktime(&tm);
164 if (timeval < 0) {
165 BT_LOGE("Failure in mktime(), incorrectly formatted %s timestamp",
166 name);
167 goto error;
168 }
169 }
170 value = (int64_t) timeval;
171 value *= NSEC_PER_SEC;
172 value += bound->lazy_values.ns;
173 bound->value = value;
174 bound->set = true;
175 bound->lazy = false;
176 *lazy_update = true;
177 return 0;
178
179 error:
180 return -1;
181 }
182
183 static
184 struct bt_notification *evaluate_event_notification(
185 struct bt_notification *notification,
186 struct trimmer_iterator *trim_it,
187 struct trimmer_bound *begin, struct trimmer_bound *end,
188 bool *_event_in_range, bool *finished)
189 {
190 int64_t ts;
191 int clock_ret;
192 struct bt_event *event = NULL, *writer_event;
193 bool in_range = true;
194 struct bt_clock_class *clock_class = NULL;
195 struct bt_trace *trace = NULL;
196 struct bt_stream *stream = NULL;
197 struct bt_stream_class *stream_class = NULL;
198 struct bt_clock_value *clock_value = NULL;
199 bool lazy_update = false;
200 struct bt_notification *new_notification = NULL;
201 struct bt_clock_class_priority_map *cc_prio_map;
202
203 event = bt_notification_event_get_event(notification);
204 BT_ASSERT(event);
205 cc_prio_map = bt_notification_event_get_clock_class_priority_map(
206 notification);
207 BT_ASSERT(cc_prio_map);
208 writer_event = trimmer_output_event(trim_it, event);
209 BT_ASSERT(writer_event);
210 new_notification = bt_notification_event_create(writer_event, cc_prio_map);
211 BT_ASSERT(new_notification);
212 bt_put(cc_prio_map);
213
214 stream = bt_event_get_stream(event);
215 BT_ASSERT(stream);
216
217 stream_class = bt_stream_get_class(stream);
218 BT_ASSERT(stream_class);
219
220 trace = bt_stream_class_get_trace(stream_class);
221 BT_ASSERT(trace);
222
223 /* FIXME multi-clock? */
224 clock_class = bt_trace_get_clock_class_by_index(trace, 0);
225 if (!clock_class) {
226 goto end;
227 }
228
229 clock_value = bt_event_get_clock_value(event, clock_class);
230 if (!clock_value) {
231 BT_LOGE_STR("Failed to retrieve clock value.");
232 goto error;
233 }
234
235 clock_ret = bt_clock_value_get_value_ns_from_epoch(
236 clock_value, &ts);
237 if (clock_ret) {
238 BT_LOGE_STR("Failed to retrieve clock value timestamp.");
239 goto error;
240 }
241 if (update_lazy_bound(begin, "begin", ts, &lazy_update)) {
242 goto end;
243 }
244 if (update_lazy_bound(end, "end", ts, &lazy_update)) {
245 goto end;
246 }
247 if (lazy_update && begin->set && end->set) {
248 if (begin->value > end->value) {
249 BT_LOGE_STR("Unexpected: time range begin value is above end value.");
250 goto error;
251 }
252 }
253 if (begin->set && ts < begin->value) {
254 in_range = false;
255 }
256 if (end->set && ts > end->value) {
257 in_range = false;
258 *finished = true;
259 }
260
261 goto end;
262
263 error:
264 BT_PUT(new_notification);
265 end:
266 bt_put(event);
267 bt_put(writer_event);
268 bt_put(clock_class);
269 bt_put(trace);
270 bt_put(stream);
271 bt_put(stream_class);
272 bt_put(clock_value);
273 *_event_in_range = in_range;
274 return new_notification;
275 }
276
277 static
278 int ns_from_integer_field(struct bt_field *integer, int64_t *ns)
279 {
280 int ret = 0;
281 int is_signed;
282 uint64_t raw_clock_value;
283 struct bt_field_type *integer_type = NULL;
284 struct bt_clock_class *clock_class = NULL;
285 struct bt_clock_value *clock_value = NULL;
286
287 integer_type = bt_field_get_type(integer);
288 BT_ASSERT(integer_type);
289 clock_class = bt_field_type_integer_get_mapped_clock_class(
290 integer_type);
291 if (!clock_class) {
292 ret = -1;
293 goto end;
294 }
295
296 is_signed = bt_ctf_field_type_integer_get_signed(integer_type);
297 if (!is_signed) {
298 ret = bt_field_unsigned_integer_get_value(integer,
299 &raw_clock_value);
300 if (ret) {
301 goto end;
302 }
303 } else {
304 /* Signed clock values are unsupported. */
305 ret = -1;
306 goto end;
307 }
308
309 clock_value = bt_clock_value_create(clock_class, raw_clock_value);
310 if (!clock_value) {
311 goto end;
312 }
313
314 ret = bt_clock_value_get_value_ns_from_epoch(clock_value, ns);
315 end:
316 bt_put(integer_type);
317 bt_put(clock_class);
318 bt_put(clock_value);
319 return ret;
320 }
321
322 static uint64_t ns_from_value(uint64_t frequency, uint64_t value)
323 {
324 uint64_t ns;
325
326 if (frequency == NSEC_PER_SEC) {
327 ns = value;
328 } else {
329 ns = (uint64_t) ((1e9 * (double) value) / (double) frequency);
330 }
331
332 return ns;
333 }
334
335 /*
336 * timestamp minus the offset.
337 */
338 static
339 int64_t get_raw_timestamp(struct bt_packet *writer_packet,
340 int64_t timestamp)
341 {
342 struct bt_clock_class *writer_clock_class;
343 int64_t sec_offset, cycles_offset, ns;
344 struct bt_trace *writer_trace;
345 struct bt_stream *writer_stream;
346 struct bt_stream_class *writer_stream_class;
347 int ret;
348 uint64_t freq;
349
350 writer_stream = bt_packet_get_stream(writer_packet);
351 BT_ASSERT(writer_stream);
352
353 writer_stream_class = bt_stream_get_class(writer_stream);
354 BT_ASSERT(writer_stream_class);
355
356 writer_trace = bt_stream_class_get_trace(writer_stream_class);
357 BT_ASSERT(writer_trace);
358
359 /* FIXME multi-clock? */
360 writer_clock_class = bt_trace_get_clock_class_by_index(
361 writer_trace, 0);
362 BT_ASSERT(writer_clock_class);
363
364 ret = bt_clock_class_get_offset_s(writer_clock_class, &sec_offset);
365 BT_ASSERT(!ret);
366 ns = sec_offset * NSEC_PER_SEC;
367
368 freq = bt_clock_class_get_frequency(writer_clock_class);
369 BT_ASSERT(freq != -1ULL);
370
371 ret = bt_clock_class_get_offset_cycles(writer_clock_class, &cycles_offset);
372 BT_ASSERT(!ret);
373
374 ns += ns_from_value(freq, cycles_offset);
375
376 bt_put(writer_clock_class);
377 bt_put(writer_trace);
378 bt_put(writer_stream_class);
379 bt_put(writer_stream);
380
381 return timestamp - ns;
382 }
383
384 static
385 struct bt_notification *evaluate_packet_notification(
386 struct bt_notification *notification,
387 struct trimmer_iterator *trim_it,
388 struct trimmer_bound *begin, struct trimmer_bound *end,
389 bool *_packet_in_range, bool *finished)
390 {
391 int64_t begin_ns, pkt_begin_ns, end_ns, pkt_end_ns;
392 bool in_range = true;
393 struct bt_packet *packet = NULL, *writer_packet = NULL;
394 struct bt_field *packet_context = NULL,
395 *timestamp_begin = NULL,
396 *timestamp_end = NULL;
397 struct bt_notification *new_notification = NULL;
398 enum bt_component_status ret;
399 bool lazy_update = false;
400
401 switch (bt_notification_get_type(notification)) {
402 case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
403 packet = bt_notification_packet_begin_get_packet(notification);
404 BT_ASSERT(packet);
405 writer_packet = trimmer_new_packet(trim_it, packet);
406 BT_ASSERT(writer_packet);
407 break;
408 case BT_NOTIFICATION_TYPE_PACKET_END:
409 packet = bt_notification_packet_end_get_packet(notification);
410 BT_ASSERT(packet);
411 writer_packet = trimmer_close_packet(trim_it, packet);
412 BT_ASSERT(writer_packet);
413 break;
414 default:
415 goto end;
416 }
417
418 packet_context = bt_packet_get_context(writer_packet);
419 if (!packet_context) {
420 goto end_no_notif;
421 }
422
423 if (!bt_field_is_structure(packet_context)) {
424 goto end_no_notif;
425 }
426
427 timestamp_begin = bt_field_structure_get_field_by_name(
428 packet_context, "timestamp_begin");
429 if (!timestamp_begin || !bt_field_is_integer(timestamp_begin)) {
430 goto end_no_notif;
431 }
432 timestamp_end = bt_field_structure_get_field_by_name(
433 packet_context, "timestamp_end");
434 if (!timestamp_end || !bt_field_is_integer(timestamp_end)) {
435 goto end_no_notif;
436 }
437
438 if (ns_from_integer_field(timestamp_begin, &pkt_begin_ns)) {
439 goto end_no_notif;
440 }
441 if (ns_from_integer_field(timestamp_end, &pkt_end_ns)) {
442 goto end_no_notif;
443 }
444
445 if (update_lazy_bound(begin, "begin", pkt_begin_ns, &lazy_update)) {
446 goto end_no_notif;
447 }
448 if (update_lazy_bound(end, "end", pkt_end_ns, &lazy_update)) {
449 goto end_no_notif;
450 }
451 if (lazy_update && begin->set && end->set) {
452 if (begin->value > end->value) {
453 BT_LOGE_STR("Unexpected: time range begin value is above end value.");
454 goto end_no_notif;
455 }
456 }
457
458 begin_ns = begin->set ? begin->value : INT64_MIN;
459 end_ns = end->set ? end->value : INT64_MAX;
460
461 /*
462 * Accept if there is any overlap between the selected region and the
463 * packet.
464 */
465 in_range = (pkt_end_ns >= begin_ns) && (pkt_begin_ns <= end_ns);
466 if (!in_range) {
467 goto end_no_notif;
468 }
469 if (pkt_begin_ns > end_ns) {
470 *finished = true;
471 }
472
473 if (begin_ns > pkt_begin_ns) {
474 ret = update_packet_context_field(trim_it->err, writer_packet,
475 "timestamp_begin",
476 get_raw_timestamp(writer_packet, begin_ns));
477 BT_ASSERT(!ret);
478 }
479
480 if (end_ns < pkt_end_ns) {
481 ret = update_packet_context_field(trim_it->err, writer_packet,
482 "timestamp_end",
483 get_raw_timestamp(writer_packet, end_ns));
484 BT_ASSERT(!ret);
485 }
486
487 end:
488 switch (bt_notification_get_type(notification)) {
489 case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
490 new_notification = bt_notification_packet_begin_create(writer_packet);
491 BT_ASSERT(new_notification);
492 break;
493 case BT_NOTIFICATION_TYPE_PACKET_END:
494 new_notification = bt_notification_packet_end_create(writer_packet);
495 BT_ASSERT(new_notification);
496 break;
497 default:
498 break;
499 }
500 end_no_notif:
501 *_packet_in_range = in_range;
502 bt_put(packet);
503 bt_put(writer_packet);
504 bt_put(packet_context);
505 bt_put(timestamp_begin);
506 bt_put(timestamp_end);
507 return new_notification;
508 }
509
510 static
511 struct bt_notification *evaluate_stream_notification(
512 struct bt_notification *notification,
513 struct trimmer_iterator *trim_it)
514 {
515 struct bt_stream *stream;
516
517 stream = bt_notification_stream_end_get_stream(notification);
518 BT_ASSERT(stream);
519
520 /* FIXME: useless copy */
521 return bt_notification_stream_end_create(stream);
522 }
523
524 /* Return true if the notification should be forwarded. */
525 static
526 enum bt_notification_iterator_status evaluate_notification(
527 struct bt_notification **notification,
528 struct trimmer_iterator *trim_it,
529 struct trimmer_bound *begin, struct trimmer_bound *end,
530 bool *in_range)
531 {
532 enum bt_notification_type type;
533 struct bt_notification *new_notification = NULL;
534 bool finished = false;
535
536 *in_range = true;
537 type = bt_notification_get_type(*notification);
538 switch (type) {
539 case BT_NOTIFICATION_TYPE_EVENT:
540 new_notification = evaluate_event_notification(*notification,
541 trim_it, begin, end, in_range, &finished);
542 break;
543 case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
544 case BT_NOTIFICATION_TYPE_PACKET_END:
545 new_notification = evaluate_packet_notification(*notification,
546 trim_it, begin, end, in_range, &finished);
547 break;
548 case BT_NOTIFICATION_TYPE_STREAM_END:
549 new_notification = evaluate_stream_notification(*notification,
550 trim_it);
551 break;
552 default:
553 puts("Unhandled notification type");
554 break;
555 }
556 BT_PUT(*notification);
557 *notification = new_notification;
558
559 if (finished) {
560 return BT_NOTIFICATION_ITERATOR_STATUS_END;
561 }
562
563 return BT_NOTIFICATION_ITERATOR_STATUS_OK;
564 }
565
566 BT_HIDDEN
567 struct bt_notification_iterator_next_method_return trimmer_iterator_next(
568 struct bt_private_connection_private_notification_iterator *iterator)
569 {
570 struct trimmer_iterator *trim_it = NULL;
571 struct bt_private_component *component = NULL;
572 struct trimmer *trimmer = NULL;
573 struct bt_notification_iterator *source_it = NULL;
574 struct bt_notification_iterator_next_method_return ret = {
575 .status = BT_NOTIFICATION_ITERATOR_STATUS_OK,
576 .notification = NULL,
577 };
578 bool notification_in_range = false;
579
580 trim_it = bt_private_connection_private_notification_iterator_get_user_data(iterator);
581 BT_ASSERT(trim_it);
582
583 component = bt_private_connection_private_notification_iterator_get_private_component(
584 iterator);
585 BT_ASSERT(component);
586 trimmer = bt_private_component_get_user_data(component);
587 BT_ASSERT(trimmer);
588
589 source_it = trim_it->input_iterator;
590 BT_ASSERT(source_it);
591
592 while (!notification_in_range) {
593 ret.status = bt_notification_iterator_next(source_it);
594 if (ret.status != BT_NOTIFICATION_ITERATOR_STATUS_OK) {
595 goto end;
596 }
597
598 ret.notification = bt_notification_iterator_get_notification(
599 source_it);
600 if (!ret.notification) {
601 ret.status = BT_NOTIFICATION_ITERATOR_STATUS_ERROR;
602 goto end;
603 }
604
605 ret.status = evaluate_notification(&ret.notification, trim_it,
606 &trimmer->begin, &trimmer->end,
607 &notification_in_range);
608 if (!notification_in_range) {
609 BT_PUT(ret.notification);
610 }
611
612 if (ret.status != BT_NOTIFICATION_ITERATOR_STATUS_OK) {
613 break;
614 }
615 }
616 end:
617 bt_put(component);
618 return ret;
619 }
This page took 0.041522 seconds and 4 git commands to generate.