projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
copytrace: check clock_class_count before getting the clock by index
[babeltrace.git] / plugins / libctfcopytrace / ctfcopytrace.c
CommitLineData
91b73004
JD		 1/*
2 * copytrace.c
3 *
4 * Babeltrace library to create a copy of a CTF trace
5 *
6 * Copyright 2017 Julien Desfossez <jdesfossez@efficios.com>
7 *
8 * Author: Julien Desfossez <jdesfossez@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 <babeltrace/ctf-ir/event.h>
30#include <babeltrace/ctf-ir/packet.h>
31#include <babeltrace/ctf-ir/event-class.h>
32#include <babeltrace/ctf-ir/stream.h>
33#include <babeltrace/ctf-ir/stream-class.h>
34#include <babeltrace/ctf-ir/clock-class.h>
35#include <babeltrace/ctf-ir/fields.h>
36#include <babeltrace/ctf-writer/stream.h>
37#include <assert.h>
38
39#include "ctfcopytrace.h"
b2f1f465 40#include "clock-fields.h"
91b73004 41
9ac68eb1 42BT_HIDDEN
91b73004
JD		 43struct bt_ctf_clock_class *ctf_copy_clock_class(FILE *err,
44 struct bt_ctf_clock_class *clock_class)
45{
46 int64_t offset, offset_s;
47 int int_ret;
48 uint64_t u64_ret;
49 const char *name, *description;
50 struct bt_ctf_clock_class *writer_clock_class = NULL;
51
52 assert(err && clock_class);
53
54 name = bt_ctf_clock_class_get_name(clock_class);
55 if (!name) {
56 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
57 __LINE__);
58 goto end;
59 }
60
61 writer_clock_class = bt_ctf_clock_class_create(name);
62 if (!writer_clock_class) {
63 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
64 __LINE__);
65 goto end;
66 }
67
68 description = bt_ctf_clock_class_get_description(clock_class);
16cd0c80
JD		 69 if (description) {
70 int_ret = bt_ctf_clock_class_set_description(writer_clock_class,
71 description);
72 if (int_ret != 0) {
73 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
74 __LINE__);
75 goto end_destroy;
76 }
91b73004
JD		 77 }
78
79 u64_ret = bt_ctf_clock_class_get_frequency(clock_class);
80 if (u64_ret == -1ULL) {
81 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
82 __LINE__);
83 goto end_destroy;
84 }
85 int_ret = bt_ctf_clock_class_set_frequency(writer_clock_class, u64_ret);
86 if (int_ret != 0) {
87 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
88 __LINE__);
89 goto end_destroy;
90 }
91
92 u64_ret = bt_ctf_clock_class_get_precision(clock_class);
93 if (u64_ret == -1ULL) {
94 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
95 __LINE__);
96 goto end_destroy;
97 }
98 int_ret = bt_ctf_clock_class_set_precision(writer_clock_class,
99 u64_ret);
100 if (int_ret != 0) {
101 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
102 __LINE__);
103 goto end_destroy;
104 }
105
106 int_ret = bt_ctf_clock_class_get_offset_s(clock_class, &offset_s);
107 if (int_ret != 0) {
108 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
109 __LINE__);
110 goto end_destroy;
111 }
112
113 int_ret = bt_ctf_clock_class_set_offset_s(writer_clock_class, offset_s);
114 if (int_ret != 0) {
115 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
116 __LINE__);
117 goto end_destroy;
118 }
119
120 int_ret = bt_ctf_clock_class_get_offset_cycles(clock_class, &offset);
121 if (int_ret != 0) {
122 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
123 __LINE__);
124 goto end_destroy;
125 }
126
127 int_ret = bt_ctf_clock_class_set_offset_cycles(writer_clock_class, offset);
128 if (int_ret != 0) {
129 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
130 __LINE__);
131 goto end_destroy;
132 }
133
acd6aeb1 134 int_ret = bt_ctf_clock_class_is_absolute(clock_class);
91b73004
JD		 135 if (int_ret == -1) {
136 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
137 __LINE__);
138 goto end_destroy;
139 }
140
141 int_ret = bt_ctf_clock_class_set_is_absolute(writer_clock_class, int_ret);
142 if (int_ret != 0) {
143 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
144 __LINE__);
145 goto end_destroy;
146 }
147
148 goto end;
149
150end_destroy:
151 BT_PUT(writer_clock_class);
152end:
153 return writer_clock_class;
154}
155
9ac68eb1 156BT_HIDDEN
91b73004
JD		 157enum bt_component_status ctf_copy_clock_classes(FILE *err,
158 struct bt_ctf_trace *writer_trace,
159 struct bt_ctf_stream_class *writer_stream_class,
160 struct bt_ctf_trace *trace)
161{
162 enum bt_component_status ret;
91b73004
JD		 163 int int_ret, clock_class_count, i;
164
165 clock_class_count = bt_ctf_trace_get_clock_class_count(trace);
166
167 for (i = 0; i < clock_class_count; i++) {
168 struct bt_ctf_clock_class *writer_clock_class;
169 struct bt_ctf_clock_class *clock_class =
9ac68eb1 170 bt_ctf_trace_get_clock_class_by_index(trace, i);
91b73004
JD		 171
172 if (!clock_class) {
173 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
174 __LINE__);
175 ret = BT_COMPONENT_STATUS_ERROR;
176 goto end;
177 }
178
179 writer_clock_class = ctf_copy_clock_class(err, clock_class);
180 bt_put(clock_class);
181 if (!writer_clock_class) {
182 fprintf(err, "Failed to copy clock class");
183 ret = BT_COMPONENT_STATUS_ERROR;
184 goto end;
185 }
186
187 int_ret = bt_ctf_trace_add_clock_class(writer_trace, writer_clock_class);
188 if (int_ret != 0) {
189 BT_PUT(writer_clock_class);
190 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
191 __LINE__);
192 ret = BT_COMPONENT_STATUS_ERROR;
193 goto end;
194 }
195
196 /*
b2f1f465 197 * Ownership transferred to the trace.
91b73004
JD		 198 */
199 bt_put(writer_clock_class);
200 }
201
202 ret = BT_COMPONENT_STATUS_OK;
203
204end:
205 return ret;
206}
207
9ac68eb1 208BT_HIDDEN
91b73004
JD		 209struct bt_ctf_event_class *ctf_copy_event_class(FILE *err,
210 struct bt_ctf_event_class *event_class)
211{
212 struct bt_ctf_event_class *writer_event_class = NULL;
f87fb9b4 213 struct bt_ctf_field_type *context, *payload_type;
91b73004 214 const char *name;
cf76ce92
PP		 215 int ret;
216 int64_t id;
217 enum bt_ctf_event_class_log_level log_level;
218 const char *emf_uri;
91b73004
JD		 219
220 name = bt_ctf_event_class_get_name(event_class);
221 if (!name) {
222 fprintf(err, "[error] %s in %s:%d\n", __func__,
223 __FILE__, __LINE__);
224 goto end;
225 }
226
227 writer_event_class = bt_ctf_event_class_create(name);
228 if (!writer_event_class) {
229 fprintf(err, "[error] %s in %s:%d\n", __func__,
230 __FILE__, __LINE__);
231 goto end;
232 }
233
cf76ce92
PP		 234 id = bt_ctf_event_class_get_id(event_class);
235 if (id < 0) {
236 fprintf(err, "[error] %s in %s:%d\n", __func__,
237 __FILE__, __LINE__);
238 goto error;
239 }
91b73004 240
cf76ce92
PP		 241 ret = bt_ctf_event_class_set_id(writer_event_class, id);
242 if (ret) {
243 fprintf(err, "[error] %s in %s:%d\n", __func__,
244 __FILE__, __LINE__);
245 goto error;
246 }
91b73004 247
cf76ce92
PP		 248 log_level = bt_ctf_event_class_get_log_level(event_class);
249 if (log_level < 0) {
250 fprintf(err, "[error] %s in %s:%d\n", __func__,
251 __FILE__, __LINE__);
252 goto error;
253 }
254
255 ret = bt_ctf_event_class_set_log_level(writer_event_class, log_level);
256 if (ret) {
257 fprintf(err, "[error] %s in %s:%d\n", __func__,
258 __FILE__, __LINE__);
259 goto error;
260 }
261
262 emf_uri = bt_ctf_event_class_get_emf_uri(event_class);
263 if (emf_uri) {
264 ret = bt_ctf_event_class_set_emf_uri(writer_event_class,
265 emf_uri);
266 if (ret) {
91b73004
JD		 267 fprintf(err, "[error] %s in %s:%d\n", __func__,
268 __FILE__, __LINE__);
9ae49d3d 269 goto error;
91b73004
JD		 270 }
271 }
272
f87fb9b4
JD		 273 payload_type = bt_ctf_event_class_get_payload_type(event_class);
274 if (payload_type) {
275 ret = bt_ctf_event_class_set_payload_type(writer_event_class,
276 payload_type);
91b73004 277 if (ret < 0) {
f87fb9b4
JD		 278 fprintf(err, "[error] %s in %s:%d\n", __func__,
279 __FILE__, __LINE__);
9ae49d3d 280 goto error;
91b73004 281 }
f87fb9b4 282 BT_PUT(payload_type);
91b73004
JD		 283 }
284
279c77d0
JD		 285 context = bt_ctf_event_class_get_context_type(event_class);
286 if (context) {
287 ret = bt_ctf_event_class_set_context_type(
288 writer_event_class, context);
289 BT_PUT(context);
290 if (ret < 0) {
291 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
292 __LINE__);
293 goto error;
294 }
295 }
296
9ae49d3d
JD		 297 goto end;
298
299error:
300 BT_PUT(writer_event_class);
91b73004
JD		 301end:
302 return writer_event_class;
303}
304
9ac68eb1 305BT_HIDDEN
91b73004
JD		 306enum bt_component_status ctf_copy_event_classes(FILE *err,
307 struct bt_ctf_stream_class *stream_class,
308 struct bt_ctf_stream_class *writer_stream_class)
309{
310 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
9ae49d3d 311 struct bt_ctf_event_class *event_class = NULL, *writer_event_class = NULL;
91b73004
JD		 312 int count, i;
313
314 count = bt_ctf_stream_class_get_event_class_count(stream_class);
315 if (count < 0) {
316 fprintf(err, "[error] %s in %s:%d\n", __func__,
317 __FILE__, __LINE__);
318 goto end;
319 }
320
321 for (i = 0; i < count; i++) {
91b73004
JD		 322 int int_ret;
323
9ac68eb1 324 event_class = bt_ctf_stream_class_get_event_class_by_index(
91b73004
JD		 325 stream_class, i);
326 if (!event_class) {
327 fprintf(err, "[error] %s in %s:%d\n", __func__,
328 __FILE__, __LINE__);
329 ret = BT_COMPONENT_STATUS_ERROR;
9ae49d3d 330 goto error;
91b73004 331 }
cb0a5cf8
JD		 332 if (i < bt_ctf_stream_class_get_event_class_count(writer_stream_class)) {
333 writer_event_class = bt_ctf_stream_class_get_event_class_by_index(
334 writer_stream_class, i);
335 if (writer_event_class) {
336 /*
337 * If the writer_event_class already exists,
338 * just skip it. It can be used to resync the
339 * event_classes after a trace has become
340 * static.
341 */
342 BT_PUT(writer_event_class);
343 BT_PUT(event_class);
344 continue;
345 }
346 }
347
91b73004
JD		 348 writer_event_class = ctf_copy_event_class(err, event_class);
349 if (!writer_event_class) {
350 fprintf(err, "[error] %s in %s:%d\n", __func__,
351 __FILE__, __LINE__);
352 ret = BT_COMPONENT_STATUS_ERROR;
9ae49d3d 353 goto error;
91b73004
JD		 354 }
355
91b73004
JD		 356 int_ret = bt_ctf_stream_class_add_event_class(writer_stream_class,
357 writer_event_class);
358 if (int_ret < 0) {
359 fprintf(err, "[error] Failed to add event class\n");
360 fprintf(err, "[error] %s in %s:%d\n", __func__,
361 __FILE__, __LINE__);
362 ret = BT_COMPONENT_STATUS_ERROR;
9ae49d3d 363 goto error;
91b73004 364 }
9ae49d3d
JD		 365 BT_PUT(writer_event_class);
366 BT_PUT(event_class);
91b73004
JD		 367 }
368
9ae49d3d
JD		 369 goto end;
370
371error:
372 bt_put(event_class);
373 bt_put(writer_event_class);
91b73004
JD		 374end:
375 return ret;
376}
377
9ac68eb1 378BT_HIDDEN
91b73004 379struct bt_ctf_stream_class *ctf_copy_stream_class(FILE *err,
b2f1f465
JD		 380 struct bt_ctf_stream_class *stream_class,
381 struct bt_ctf_trace *writer_trace,
382 bool override_ts64)
91b73004 383{
9ae49d3d
JD		 384 struct bt_ctf_field_type *type = NULL;
385 struct bt_ctf_stream_class *writer_stream_class = NULL;
91b73004
JD		 386 int ret_int;
387 const char *name = bt_ctf_stream_class_get_name(stream_class);
388
389 if (strlen(name) == 0) {
390 name = NULL;
391 }
392
e49da5dd 393 writer_stream_class = bt_ctf_stream_class_create_empty(name);
91b73004
JD		 394 if (!writer_stream_class) {
395 fprintf(err, "[error] %s in %s:%d\n",
396 __func__, __FILE__, __LINE__);
397 goto end;
398 }
399
400 type = bt_ctf_stream_class_get_packet_context_type(stream_class);
cfb74f3d
JD		 401 if (type) {
402 ret_int = bt_ctf_stream_class_set_packet_context_type(
403 writer_stream_class, type);
404 if (ret_int < 0) {
405 fprintf(err, "[error] %s in %s:%d\n", __func__,
406 __FILE__, __LINE__);
407 goto error;
408 }
409 BT_PUT(type);
91b73004
JD		 410 }
411
412 type = bt_ctf_stream_class_get_event_header_type(stream_class);
06b019a7 413 if (type) {
d23979be
JD		 414 ret_int = bt_ctf_trace_get_clock_class_count(writer_trace);
415 if (ret_int < 0) {
416 fprintf(err, "[error] %s in %s:%d\n", __func__,
417 __FILE__, __LINE__);
418 goto error;
419 }
420 if (override_ts64 && ret_int > 0) {
06b019a7
JD		 421 struct bt_ctf_field_type *new_event_header_type;
422
423 new_event_header_type = override_header_type(err, type,
424 writer_trace);
425 if (!new_event_header_type) {
426 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
427 __LINE__);
428 goto error;
429 }
430 ret_int = bt_ctf_stream_class_set_event_header_type(
431 writer_stream_class, new_event_header_type);
432 BT_PUT(new_event_header_type);
433 if (ret_int < 0) {
434 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
435 __LINE__);
436 goto error;
437 }
438 } else {
439 ret_int = bt_ctf_stream_class_set_event_header_type(
440 writer_stream_class, type);
441 if (ret_int < 0) {
442 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
443 __LINE__);
444 goto error;
445 }
0f29db56 446 }
06b019a7 447 BT_PUT(type);
91b73004
JD		 448 }
449
450 type = bt_ctf_stream_class_get_event_context_type(stream_class);
451 if (type) {
452 ret_int = bt_ctf_stream_class_set_event_context_type(
453 writer_stream_class, type);
91b73004
JD		 454 if (ret_int < 0) {
455 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
456 __LINE__);
457 goto error;
458 }
459 }
9ae49d3d 460 BT_PUT(type);
91b73004
JD		 461
462 goto end;
463
464error:
465 BT_PUT(writer_stream_class);
466end:
9ae49d3d 467 bt_put(type);
91b73004
JD		 468 return writer_stream_class;
469}
470
387483fc
JD		 471BT_HIDDEN
472int ctf_stream_copy_packet_header(FILE *err, struct bt_ctf_packet *packet,
473 struct bt_ctf_stream *writer_stream)
474{
475 struct bt_ctf_field *packet_header = NULL, *writer_packet_header = NULL;
476 int ret = 0;
477
478 packet_header = bt_ctf_packet_get_header(packet);
479 if (!packet_header) {
480 goto end;
481 }
482
483 writer_packet_header = bt_ctf_field_copy(packet_header);
484 if (!writer_packet_header) {
485 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
486 __LINE__);
487 goto error;
488 }
489
490 ret = bt_ctf_stream_set_packet_header(writer_stream,
491 writer_packet_header);
492 if (ret) {
493 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
494 __LINE__);
495 goto error;
496 }
497
498 goto end;
499
500error:
501 ret = -1;
502end:
503 bt_put(writer_packet_header);
504 bt_put(packet_header);
505 return ret;
506}
507
508BT_HIDDEN
509int ctf_packet_copy_header(FILE *err, struct bt_ctf_packet *packet,
510 struct bt_ctf_packet *writer_packet)
511{
512 struct bt_ctf_field *packet_header = NULL, *writer_packet_header = NULL;
513 int ret = 0;
514
515 packet_header = bt_ctf_packet_get_header(packet);
516 if (!packet_header) {
517 goto end;
518 }
519
520 writer_packet_header = bt_ctf_field_copy(packet_header);
521 if (!writer_packet_header) {
522 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
523 __LINE__);
524 goto error;
525 }
526
527 ret = bt_ctf_packet_set_header(writer_packet, writer_packet_header);
528 if (ret) {
529 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
530 __LINE__);
531 goto error;
532 }
533
534 goto end;
535
536error:
537 ret = -1;
538end:
539 bt_put(packet_header);
540 bt_put(writer_packet_header);
541 return ret;
542}
543
9ac68eb1 544BT_HIDDEN
9877e1aa
JD		 545int ctf_stream_copy_packet_context(FILE *err, struct bt_ctf_packet *packet,
546 struct bt_ctf_stream *writer_stream)
91b73004 547{
9877e1aa
JD		 548 struct bt_ctf_field *packet_context = NULL, *writer_packet_context = NULL;
549 int ret = 0;
91b73004 550
9877e1aa
JD		 551 packet_context = bt_ctf_packet_get_context(packet);
552 if (!packet_context) {
91b73004
JD		 553 goto end;
554 }
555
9877e1aa
JD		 556 writer_packet_context = bt_ctf_field_copy(packet_context);
557 if (!writer_packet_context) {
91b73004
JD		 558 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
559 __LINE__);
9877e1aa 560 goto error;
91b73004
JD		 561 }
562
9877e1aa
JD		 563 ret = bt_ctf_stream_set_packet_context(writer_stream,
564 writer_packet_context);
565 if (ret) {
91b73004
JD		 566 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
567 __LINE__);
9877e1aa 568 goto error;
91b73004
JD		 569 }
570
9ae49d3d
JD		 571 goto end;
572
573error:
9877e1aa 574 ret = -1;
91b73004 575end:
9877e1aa
JD		 576 bt_put(packet_context);
577 bt_put(writer_packet_context);
91b73004
JD		 578 return ret;
579}
580
9ac68eb1 581BT_HIDDEN
9877e1aa
JD		 582int ctf_packet_copy_context(FILE *err, struct bt_ctf_packet *packet,
583 struct bt_ctf_stream *writer_stream,
584 struct bt_ctf_packet *writer_packet)
91b73004 585{
9ae49d3d 586 struct bt_ctf_field *packet_context = NULL, *writer_packet_context = NULL;
9877e1aa 587 int ret = 0;
91b73004
JD		 588
589 packet_context = bt_ctf_packet_get_context(packet);
590 if (!packet_context) {
60ef553b 591 goto end;
91b73004
JD		 592 }
593
9877e1aa
JD		 594 writer_packet_context = bt_ctf_field_copy(packet_context);
595 if (!writer_packet_context) {
91b73004
JD		 596 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
597 __LINE__);
9ae49d3d 598 goto error;
91b73004
JD		 599 }
600
9877e1aa
JD		 601 ret = bt_ctf_packet_set_context(writer_packet, writer_packet_context);
602 if (ret) {
91b73004
JD		 603 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
604 __LINE__);
9ae49d3d 605 goto error;
91b73004
JD		 606 }
607
9ae49d3d
JD		 608 goto end;
609
610error:
9877e1aa 611 ret = -1;
9ae49d3d 612end:
9877e1aa 613 bt_put(writer_packet_context);
91b73004 614 bt_put(packet_context);
9877e1aa 615 return ret;
b2f1f465
JD		 616}
617
9ac68eb1 618BT_HIDDEN
0f29db56 619int ctf_copy_event_header(FILE *err, struct bt_ctf_event *event,
b2f1f465
JD		 620 struct bt_ctf_event_class *writer_event_class,
621 struct bt_ctf_event *writer_event,
622 struct bt_ctf_field *event_header)
623{
9ae49d3d
JD		 624 struct bt_ctf_clock_class *clock_class = NULL, *writer_clock_class = NULL;
625 struct bt_ctf_clock_value *clock_value = NULL, *writer_clock_value = NULL;
b2f1f465
JD		 626
627 int ret;
0f29db56
JD		 628 struct bt_ctf_field *writer_event_header = NULL;
629 uint64_t value;
b2f1f465 630
0f29db56
JD		 631 clock_class = event_get_clock_class(err, event);
632 if (!clock_class) {
633 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
634 __LINE__);
635 goto error;
636 }
637
638 clock_value = bt_ctf_event_get_clock_value(event, clock_class);
9ae49d3d 639 BT_PUT(clock_class);
0f29db56
JD		 640 if (!clock_value) {
641 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
642 __LINE__);
643 goto error;
644 }
645
646 ret = bt_ctf_clock_value_get_value(clock_value, &value);
9ae49d3d 647 BT_PUT(clock_value);
0f29db56
JD		 648 if (ret) {
649 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
650 __LINE__);
651 goto error;
b2f1f465
JD		 652 }
653
654 writer_clock_class = event_get_clock_class(err, writer_event);
655 if (!writer_clock_class) {
656 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
657 __LINE__);
658 goto error;
659 }
660
0f29db56 661 writer_clock_value = bt_ctf_clock_value_create(writer_clock_class, value);
9ae49d3d 662 BT_PUT(writer_clock_class);
0f29db56 663 if (!writer_clock_value) {
b2f1f465
JD		 664 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
665 __LINE__);
9ae49d3d 666 goto error;
b2f1f465
JD		 667 }
668
0f29db56 669 ret = bt_ctf_event_set_clock_value(writer_event, writer_clock_value);
9ae49d3d 670 BT_PUT(writer_clock_value);
b2f1f465
JD		 671 if (ret) {
672 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
673 __LINE__);
674 goto error;
675 }
676
0f29db56
JD		 677 writer_event_header = bt_ctf_field_copy(event_header);
678 if (!writer_event_header) {
679 fprintf(err, "[error] %s in %s:%d\n", __func__,
680 __FILE__, __LINE__);
0f29db56
JD		 681 goto end;
682 }
683
b2f1f465 684 ret = bt_ctf_event_set_header(writer_event, writer_event_header);
9ae49d3d 685 BT_PUT(writer_event_header);
b2f1f465
JD		 686 if (ret < 0) {
687 fprintf(err, "[error] %s in %s:%d\n", __func__,
688 __FILE__, __LINE__);
689 goto error;
690 }
b2f1f465
JD		 691
692 ret = 0;
693
694 goto end;
695
696error:
b2f1f465 697 ret = -1;
91b73004
JD		 698end:
699 return ret;
700}
701
d23979be
JD		 702static
703struct bt_ctf_trace *event_class_get_trace(FILE *err,
704 struct bt_ctf_event_class *event_class)
705{
706 struct bt_ctf_trace *trace = NULL;
707 struct bt_ctf_stream_class *stream_class = NULL;
708
709 stream_class = bt_ctf_event_class_get_stream_class(event_class);
710 if (!stream_class) {
711 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
712 __LINE__);
713 goto error;
714 }
715
716 trace = bt_ctf_stream_class_get_trace(stream_class);
717 if (!trace) {
718 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
719 __LINE__);
720 goto error;
721 }
722
723 goto end;
724
725error:
726 BT_PUT(trace);
727end:
728 bt_put(stream_class);
729 return trace;
730}
731
9ac68eb1 732BT_HIDDEN
91b73004 733struct bt_ctf_event *ctf_copy_event(FILE *err, struct bt_ctf_event *event,
b2f1f465
JD		 734 struct bt_ctf_event_class *writer_event_class,
735 bool override_ts64)
91b73004 736{
9ae49d3d
JD		 737 struct bt_ctf_event *writer_event = NULL;
738 struct bt_ctf_field *field = NULL, *copy_field = NULL;
d23979be 739 struct bt_ctf_trace *writer_trace = NULL;
91b73004
JD		 740 int ret;
741
742 writer_event = bt_ctf_event_create(writer_event_class);
743 if (!writer_event) {
744 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
745 __LINE__);
d23979be
JD		 746 goto error;
747 }
748
749 writer_trace = event_class_get_trace(err, writer_event_class);
750 if (!writer_trace) {
751 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
752 __LINE__);
753 goto error;
91b73004
JD		 754 }
755
756 field = bt_ctf_event_get_header(event);
06b019a7
JD		 757 if (field) {
758 /*
d23979be
JD		 759 * If override_ts64, we override all integer fields mapped to a
760 * clock to a uint64_t field type, otherwise, we just copy it as
761 * is.
06b019a7 762 */
d23979be
JD		 763 ret = bt_ctf_trace_get_clock_class_count(writer_trace);
764 if (ret < 0) {
765 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
766 __LINE__);
767 goto error;
768 }
769 if (override_ts64 && ret > 0) {
06b019a7
JD		 770 copy_field = bt_ctf_event_get_header(writer_event);
771 if (!copy_field) {
772 fprintf(err, "[error] %s in %s:%d\n", __func__,
773 __FILE__, __LINE__);
774 goto error;
775 }
b2f1f465 776
06b019a7
JD		 777 ret = copy_override_field(err, event, writer_event, field,
778 copy_field);
779 if (ret) {
780 fprintf(err, "[error] %s in %s:%d\n", __func__,
781 __FILE__, __LINE__);
782 goto error;
783 }
784 BT_PUT(copy_field);
785 } else {
786 ret = ctf_copy_event_header(err, event, writer_event_class,
787 writer_event, field);
788 if (ret) {
789 fprintf(err, "[error] %s in %s:%d\n", __func__,
790 __FILE__, __LINE__);
791 goto error;
792 }
91b73004 793 }
06b019a7 794 BT_PUT(field);
91b73004
JD		 795 }
796
797 /* Optional field, so it can fail silently. */
798 field = bt_ctf_event_get_stream_event_context(event);
961ec227
JD		 799 if (field) {
800 copy_field = bt_ctf_field_copy(field);
801 if (!copy_field) {
802 fprintf(err, "[error] %s in %s:%d\n", __func__,
803 __FILE__, __LINE__);
804 goto error;
805 }
91b73004
JD		 806 ret = bt_ctf_event_set_stream_event_context(writer_event,
807 copy_field);
91b73004
JD		 808 if (ret < 0) {
809 fprintf(err, "[error] %s in %s:%d\n", __func__,
810 __FILE__, __LINE__);
811 goto error;
812 }
961ec227
JD		 813 BT_PUT(field);
814 BT_PUT(copy_field);
91b73004
JD		 815 }
816
817 /* Optional field, so it can fail silently. */
818 field = bt_ctf_event_get_event_context(event);
961ec227
JD		 819 if (field) {
820 copy_field = bt_ctf_field_copy(field);
821 if (!copy_field) {
822 fprintf(err, "[error] %s in %s:%d\n", __func__,
823 __FILE__, __LINE__);
824 goto error;
825 }
91b73004 826 ret = bt_ctf_event_set_event_context(writer_event, copy_field);
91b73004
JD		 827 if (ret < 0) {
828 fprintf(err, "[error] %s in %s:%d\n", __func__,
829 __FILE__, __LINE__);
830 goto error;
831 }
961ec227
JD		 832 BT_PUT(field);
833 BT_PUT(copy_field);
91b73004
JD		 834 }
835
9ac68eb1 836 field = bt_ctf_event_get_event_payload(event);
961ec227
JD		 837 if (field) {
838 copy_field = bt_ctf_field_copy(field);
839 if (!copy_field) {
840 fprintf(err, "[error] %s in %s:%d\n", __func__,
841 __FILE__, __LINE__);
842 goto error;
843 }
9ac68eb1 844 ret = bt_ctf_event_set_event_payload(writer_event, copy_field);
91b73004
JD		 845 if (ret < 0) {
846 fprintf(err, "[error] %s in %s:%d\n", __func__,
847 __FILE__, __LINE__);
848 goto error;
849 }
961ec227
JD		 850 BT_PUT(field);
851 BT_PUT(copy_field);
91b73004 852 }
9ae49d3d 853
91b73004
JD		 854 goto end;
855
856error:
857 BT_PUT(writer_event);
858end:
9ae49d3d
JD		 859 bt_put(field);
860 bt_put(copy_field);
d23979be 861 bt_put(writer_trace);
91b73004
JD		 862 return writer_event;
863}
864
9ac68eb1 865BT_HIDDEN
91b73004
JD		 866enum bt_component_status ctf_copy_trace(FILE *err, struct bt_ctf_trace *trace,
867 struct bt_ctf_trace *writer_trace)
868{
869 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
870 int field_count, i, int_ret;
9ae49d3d 871 struct bt_ctf_field_type *header_type = NULL;
6468dbd6 872 enum bt_ctf_byte_order order;
0ac862b4 873 const char *trace_name;
91b73004
JD		 874
875 field_count = bt_ctf_trace_get_environment_field_count(trace);
876 for (i = 0; i < field_count; i++) {
877 int ret_int;
878 const char *name;
9ae49d3d 879 struct bt_value *value = NULL;
91b73004 880
9ac68eb1
PP		 881 name = bt_ctf_trace_get_environment_field_name_by_index(
882 trace, i);
91b73004
JD		 883 if (!name) {
884 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
885 __LINE__);
886 ret = BT_COMPONENT_STATUS_ERROR;
9ae49d3d 887 goto end;
91b73004 888 }
9ac68eb1
PP		 889 value = bt_ctf_trace_get_environment_field_value_by_index(
890 trace, i);
91b73004
JD		 891 if (!value) {
892 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
893 __LINE__);
894 ret = BT_COMPONENT_STATUS_ERROR;
9ae49d3d 895 goto end;
91b73004
JD		 896 }
897
898 ret_int = bt_ctf_trace_set_environment_field(writer_trace,
899 name, value);
9ae49d3d 900 BT_PUT(value);
91b73004
JD		 901 if (ret_int < 0) {
902 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__,
903 __LINE__);
904 fprintf(err, "[error] Unable to set environment field %s\n",
905 name);
906 ret = BT_COMPONENT_STATUS_ERROR;
9ae49d3d 907 goto end;
91b73004
JD		 908 }
909 }
910
6468dbd6
JD		 911 order = bt_ctf_trace_get_native_byte_order(trace);
912 if (order == BT_CTF_BYTE_ORDER_UNKNOWN) {
913 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
914 ret = BT_COMPONENT_STATUS_ERROR;
915 goto end;
916 }
917
d41cff38
PP		 918 /*
919 * Only explicitly set the writer trace's native byte order if
920 * the original trace has a specific one. Otherwise leave what
921 * the CTF writer object chooses, which is the machine's native
922 * byte order.
923 */
2f4b93cd 924 if (order != BT_CTF_BYTE_ORDER_UNSPECIFIED) {
d41cff38
PP		 925 ret = bt_ctf_trace_set_native_byte_order(writer_trace, order);
926 if (ret) {
927 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
928 ret = BT_COMPONENT_STATUS_ERROR;
929 goto end;
930 }
6468dbd6
JD		 931 }
932
387483fc 933 header_type = bt_ctf_trace_get_packet_header_type(trace);
944eed39
JD		 934 if (header_type) {
935 int_ret = bt_ctf_trace_set_packet_header_type(writer_trace, header_type);
936 BT_PUT(header_type);
937 if (int_ret < 0) {
938 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
939 ret = BT_COMPONENT_STATUS_ERROR;
940 goto end;
941 }
91b73004
JD		 942 }
943
0ac862b4
JD		 944 trace_name = bt_ctf_trace_get_name(trace);
945 if (trace_name) {
946 int_ret = bt_ctf_trace_set_name(writer_trace, trace_name);
947 if (int_ret < 0) {
948 fprintf(err, "[error] %s in %s:%d\n", __func__, __FILE__, __LINE__);
949 ret = BT_COMPONENT_STATUS_ERROR;
950 goto end;
951 }
952 }
953
9ae49d3d 954end:
91b73004
JD		 955 return ret;
956}
BabelTrace - Trace Format Babel Tower
This page took 0.071984 seconds and 4 git commands to generate.