projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Avoid unnecessary inclusions in public headers
[babeltrace.git] / plugins / text / pretty / pretty.c
CommitLineData
7a278c8e 1/*
3228cc1d 2 * pretty.c
7a278c8e 3 *
5dac767a 4 * Babeltrace CTF Text Output Plugin
7a278c8e 5 *
2e339de1 6 * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
f504043c 7 * Copyright 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
7a278c8e
JG		 8 *
9 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining a copy
12 * of this software and associated documentation files (the "Software"), to deal
13 * in the Software without restriction, including without limitation the rights
14 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 * copies of the Software, and to permit persons to whom the Software is
16 * furnished to do so, subject to the following conditions:
17 *
18 * The above copyright notice and this permission notice shall be included in
19 * all copies or substantial portions of the Software.
20 *
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27 * SOFTWARE.
28 */
29
9d408fca 30#include <babeltrace/babeltrace.h>
6e1bc0df 31#include <babeltrace/values.h>
3d9990ac 32#include <babeltrace/compiler-internal.h>
ad96d936 33#include <babeltrace/common-internal.h>
7d61fa8e 34#include <plugins-common.h>
bfd20a42 35#include <stdio.h>
39cfa40f 36#include <stdbool.h>
bac67f0f 37#include <glib.h>
75e1829b 38#include <assert.h>
6405967d 39
3228cc1d
PP		 40#include "pretty.h"
41
61d6f9b1
MJ		 42GQuark stream_packet_context_quarks[STREAM_PACKET_CONTEXT_QUARKS_LEN];
43
6e1bc0df
MD		 44static
45const char *plugin_options[] = {
ad96d936 46 "color",
a0ad501b 47 "path",
6e1bc0df
MD		 48 "no-delta",
49 "clock-cycles",
50 "clock-seconds",
51 "clock-date",
52 "clock-gmt",
a263021c 53 "verbose",
6e1bc0df
MD		 54 "name-default", /* show/hide */
55 "name-payload",
56 "name-context",
57 "name-scope",
58 "name-header",
59 "field-default", /* show/hide */
60 "field-trace",
61 "field-trace:hostname",
62 "field-trace:domain",
63 "field-trace:procname",
64 "field-trace:vpid",
65 "field-loglevel",
66 "field-emf",
60535549 67 "field-callsite",
6e1bc0df
MD		 68};
69
bfd20a42 70static
3228cc1d 71void destroy_pretty_data(struct pretty_component *pretty)
bac67f0f 72{
3228cc1d 73 bt_put(pretty->input_iterator);
5280f742
PP		 74
75 if (pretty->string) {
76 (void) g_string_free(pretty->string, TRUE);
77 }
78
79 if (pretty->tmp_string) {
80 (void) g_string_free(pretty->tmp_string, TRUE);
81 }
82
3228cc1d 83 if (pretty->out != stdout) {
77986bad
JD		 84 int ret;
85
3228cc1d 86 ret = fclose(pretty->out);
77986bad
JD		 87 if (ret) {
88 perror("close output file");
89 }
90 }
3228cc1d 91 g_free(pretty->options.output_path);
3228cc1d 92 g_free(pretty);
bac67f0f
JG		 93}
94
b25bd455 95static
3228cc1d 96struct pretty_component *create_pretty(void)
bac67f0f 97{
3228cc1d 98 struct pretty_component *pretty;
541b0a11 99
3228cc1d
PP		 100 pretty = g_new0(struct pretty_component, 1);
101 if (!pretty) {
541b0a11
JG		 102 goto end;
103 }
3228cc1d
PP		 104 pretty->string = g_string_new("");
105 if (!pretty->string) {
6a18b281
MD		 106 goto error;
107 }
5280f742
PP		 108 pretty->tmp_string = g_string_new("");
109 if (!pretty->tmp_string) {
110 goto error;
111 }
541b0a11 112end:
3228cc1d 113 return pretty;
6a18b281
MD		 114
115error:
3228cc1d 116 g_free(pretty);
6a18b281 117 return NULL;
bac67f0f
JG		 118}
119
3228cc1d
PP		 120BT_HIDDEN
121void pretty_finalize(struct bt_private_component *component)
b25bd455 122{
890882ef 123 void *data = bt_private_component_get_user_data(component);
b25bd455 124
3228cc1d 125 destroy_pretty_data(data);
b25bd455
JG		 126}
127
bac67f0f 128static
3228cc1d 129enum bt_component_status handle_notification(struct pretty_component *pretty,
6e1bc0df 130 struct bt_notification *notification)
4c1456f0 131{
541b0a11 132 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
541b0a11 133
b5e978f4 134 assert(pretty);
541b0a11 135
7cdc2bab
MD		 136 switch (bt_notification_get_type(notification)) {
137 case BT_NOTIFICATION_TYPE_EVENT:
d9f65f09 138 ret = pretty_print_event(pretty, notification);
7cdc2bab
MD		 139 break;
140 case BT_NOTIFICATION_TYPE_INACTIVITY:
141 fprintf(stderr, "Inactivity notification\n");
142 break;
143 case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
144 case BT_NOTIFICATION_TYPE_PACKET_END:
145 case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
146 case BT_NOTIFICATION_TYPE_STREAM_END:
147 break;
08899d39
PP		 148 case BT_NOTIFICATION_TYPE_DISCARDED_PACKETS:
149 case BT_NOTIFICATION_TYPE_DISCARDED_EVENTS:
150 ret = pretty_print_discarded_elements(pretty, notification);
151 break;
7cdc2bab
MD		 152 default:
153 fprintf(stderr, "Unhandled notification type\n");
78586d8a 154 }
b5e978f4 155
541b0a11 156 return ret;
4c1456f0 157}
bac67f0f 158
3228cc1d 159BT_HIDDEN
0d8b4d8e 160void pretty_port_connected(
890882ef 161 struct bt_private_component *component,
8f4799f7
PP		 162 struct bt_private_port *self_port,
163 struct bt_port *other_port)
75e1829b 164{
73d5c1ad 165 enum bt_connection_status conn_status;
890882ef 166 struct bt_private_connection *connection;
3228cc1d 167 struct pretty_component *pretty;
fa054faf
PP		 168 static const enum bt_notification_type notif_types[] = {
169 BT_NOTIFICATION_TYPE_EVENT,
08899d39
PP		 170 BT_NOTIFICATION_TYPE_DISCARDED_PACKETS,
171 BT_NOTIFICATION_TYPE_DISCARDED_EVENTS,
fa054faf
PP		 172 BT_NOTIFICATION_TYPE_SENTINEL,
173 };
75e1829b 174
3228cc1d
PP		 175 pretty = bt_private_component_get_user_data(component);
176 assert(pretty);
177 assert(!pretty->input_iterator);
890882ef 178 connection = bt_private_port_get_private_connection(self_port);
72b913fb 179 assert(connection);
73d5c1ad
PP		 180 conn_status = bt_private_connection_create_notification_iterator(
181 connection, notif_types, &pretty->input_iterator);
182 if (conn_status != BT_CONNECTION_STATUS_OK) {
0d8b4d8e 183 pretty->error = true;
75e1829b 184 }
72b913fb
PP		 185
186 bt_put(connection);
75e1829b
JG		 187}
188
3228cc1d
PP		 189BT_HIDDEN
190enum bt_component_status pretty_consume(struct bt_private_component *component)
fec2a9f2
JG		 191{
192 enum bt_component_status ret;
193 struct bt_notification *notification = NULL;
194 struct bt_notification_iterator *it;
3228cc1d 195 struct pretty_component *pretty =
890882ef 196 bt_private_component_get_user_data(component);
41a2b7ae 197 enum bt_notification_iterator_status it_ret;
fec2a9f2 198
0d8b4d8e
PP		 199 if (unlikely(pretty->error)) {
200 ret = BT_COMPONENT_STATUS_ERROR;
201 goto end;
202 }
fec2a9f2 203
0d8b4d8e 204 it = pretty->input_iterator;
41a2b7ae 205 it_ret = bt_notification_iterator_next(it);
0d8b4d8e 206
41a2b7ae 207 switch (it_ret) {
41a2b7ae
PP		 208 case BT_NOTIFICATION_ITERATOR_STATUS_END:
209 ret = BT_COMPONENT_STATUS_END;
3228cc1d 210 BT_PUT(pretty->input_iterator);
41a2b7ae 211 goto end;
dfa6653c
PP		 212 case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN:
213 ret = BT_COMPONENT_STATUS_AGAIN;
214 goto end;
215 case BT_NOTIFICATION_ITERATOR_STATUS_OK:
41a2b7ae 216 break;
dfa6653c
PP		 217 default:
218 ret = BT_COMPONENT_STATUS_ERROR;
219 goto end;
fec2a9f2
JG		 220 }
221
41a2b7ae
PP		 222 notification = bt_notification_iterator_get_notification(it);
223 assert(notification);
3228cc1d 224 ret = handle_notification(pretty, notification);
dfa6653c 225
fec2a9f2 226end:
fec2a9f2
JG		 227 bt_put(notification);
228 return ret;
229}
230
6e1bc0df
MD		 231static
232enum bt_component_status add_params_to_map(struct bt_value *plugin_opt_map)
233{
234 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
235 unsigned int i;
236
237 for (i = 0; i < BT_ARRAY_SIZE(plugin_options); i++) {
238 const char *key = plugin_options[i];
239 enum bt_value_status status;
240
241 status = bt_value_map_insert(plugin_opt_map, key, bt_value_null);
242 switch (status) {
243 case BT_VALUE_STATUS_OK:
244 break;
245 default:
246 ret = BT_COMPONENT_STATUS_ERROR;
247 goto end;
248 }
249 }
250end:
251 return ret;
252}
253
254static
c55a9f58 255bt_bool check_param_exists(const char *key, struct bt_value *object, void *data)
6e1bc0df 256{
3228cc1d
PP		 257 struct pretty_component *pretty = data;
258 struct bt_value *plugin_opt_map = pretty->plugin_opt_map;
6e1bc0df
MD		 259
260 if (!bt_value_map_get(plugin_opt_map, key)) {
3228cc1d
PP		 261 fprintf(pretty->err,
262 "[warning] Parameter \"%s\" unknown to \"text.pretty\" sink component\n", key);
6e1bc0df 263 }
c55a9f58 264 return BT_TRUE;
6e1bc0df
MD		 265}
266
267static
268enum bt_component_status apply_one_string(const char *key,
269 struct bt_value *params,
270 char **option)
271{
272 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
273 struct bt_value *value = NULL;
274 enum bt_value_status status;
275 const char *str;
276
277 value = bt_value_map_get(params, key);
278 if (!value) {
279 goto end;
280 }
281 if (bt_value_is_null(value)) {
282 goto end;
283 }
284 status = bt_value_string_get(value, &str);
285 switch (status) {
286 case BT_VALUE_STATUS_OK:
287 break;
288 default:
289 ret = BT_COMPONENT_STATUS_ERROR;
290 goto end;
291 }
292 *option = g_strdup(str);
293end:
294 bt_put(value);
295 return ret;
296}
297
298static
299enum bt_component_status apply_one_bool(const char *key,
300 struct bt_value *params,
301 bool *option,
302 bool *found)
303{
304 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
305 struct bt_value *value = NULL;
306 enum bt_value_status status;
c55a9f58 307 bt_bool bool_val;
6e1bc0df
MD		 308
309 value = bt_value_map_get(params, key);
310 if (!value) {
311 goto end;
312 }
c55a9f58 313 status = bt_value_bool_get(value, &bool_val);
6e1bc0df
MD		 314 switch (status) {
315 case BT_VALUE_STATUS_OK:
316 break;
317 default:
318 ret = BT_COMPONENT_STATUS_ERROR;
319 goto end;
320 }
c55a9f58 321 *option = (bool) bool_val;
6e1bc0df
MD		 322 if (found) {
323 *found = true;
324 }
325end:
326 bt_put(value);
327 return ret;
328}
329
ad96d936 330static
3228cc1d 331void warn_wrong_color_param(struct pretty_component *pretty)
ad96d936 332{
3228cc1d 333 fprintf(pretty->err,
ad96d936
PP		 334 "[warning] Accepted values for the \"color\" parameter are:\n \"always\", \"auto\", \"never\"\n");
335}
336
77986bad 337static
3228cc1d 338enum bt_component_status open_output_file(struct pretty_component *pretty)
77986bad
JD		 339{
340 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
341
3228cc1d 342 if (!pretty->options.output_path) {
77986bad
JD		 343 goto end;
344 }
345
3228cc1d
PP		 346 pretty->out = fopen(pretty->options.output_path, "w");
347 if (!pretty->out) {
77986bad
JD		 348 goto error;
349 }
350
351 goto end;
352
353error:
354 ret = BT_COMPONENT_STATUS_ERROR;
355end:
356 return ret;
357}
358
6e1bc0df 359static
3228cc1d 360enum bt_component_status apply_params(struct pretty_component *pretty,
6e1bc0df
MD		 361 struct bt_value *params)
362{
363 enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
364 enum bt_value_status status;
365 bool value, found;
366 char *str = NULL;
367
3228cc1d
PP		 368 pretty->plugin_opt_map = bt_value_map_create();
369 if (!pretty->plugin_opt_map) {
6e1bc0df
MD		 370 ret = BT_COMPONENT_STATUS_ERROR;
371 goto end;
372 }
3228cc1d 373 ret = add_params_to_map(pretty->plugin_opt_map);
6e1bc0df
MD		 374 if (ret != BT_COMPONENT_STATUS_OK) {
375 goto end;
376 }
377 /* Report unknown parameters. */
3228cc1d 378 status = bt_value_map_foreach(params, check_param_exists, pretty);
6e1bc0df
MD		 379 switch (status) {
380 case BT_VALUE_STATUS_OK:
381 break;
382 default:
383 ret = BT_COMPONENT_STATUS_ERROR;
384 goto end;
385 }
386 /* Known parameters. */
3228cc1d 387 pretty->options.color = PRETTY_COLOR_OPT_AUTO;
ad96d936
PP		 388 if (bt_value_map_has_key(params, "color")) {
389 struct bt_value *color_value;
390 const char *color;
391
392 color_value = bt_value_map_get(params, "color");
393 if (!color_value) {
394 goto end;
395 }
396
72b913fb
PP		 397 status = bt_value_string_get(color_value, &color);
398 if (status) {
3228cc1d 399 warn_wrong_color_param(pretty);
ad96d936
PP		 400 } else {
401 if (strcmp(color, "never") == 0) {
3228cc1d 402 pretty->options.color = PRETTY_COLOR_OPT_NEVER;
ad96d936 403 } else if (strcmp(color, "auto") == 0) {
3228cc1d 404 pretty->options.color = PRETTY_COLOR_OPT_AUTO;
ad96d936 405 } else if (strcmp(color, "always") == 0) {
3228cc1d 406 pretty->options.color = PRETTY_COLOR_OPT_ALWAYS;
ad96d936 407 } else {
3228cc1d 408 warn_wrong_color_param(pretty);
ad96d936
PP		 409 }
410 }
411
412 bt_put(color_value);
413 }
414
a0ad501b 415 ret = apply_one_string("path", params, &pretty->options.output_path);
6e1bc0df
MD		 416 if (ret != BT_COMPONENT_STATUS_OK) {
417 goto end;
418 }
3228cc1d 419 ret = open_output_file(pretty);
77986bad
JD		 420 if (ret != BT_COMPONENT_STATUS_OK) {
421 goto end;
422 }
6e1bc0df 423
6e1bc0df
MD		 424 value = false; /* Default. */
425 ret = apply_one_bool("no-delta", params, &value, NULL);
426 if (ret != BT_COMPONENT_STATUS_OK) {
427 goto end;
428 }
3228cc1d 429 pretty->options.print_delta_field = !value; /* Reverse logic. */
6e1bc0df
MD		 430
431 value = false; /* Default. */
432 ret = apply_one_bool("clock-cycles", params, &value, NULL);
433 if (ret != BT_COMPONENT_STATUS_OK) {
434 goto end;
435 }
3228cc1d 436 pretty->options.print_timestamp_cycles = value;
6e1bc0df
MD		 437
438 value = false; /* Default. */
439 ret = apply_one_bool("clock-seconds", params, &value, NULL);
440 if (ret != BT_COMPONENT_STATUS_OK) {
441 goto end;
442 }
3228cc1d 443 pretty->options.clock_seconds = value;
6e1bc0df
MD		 444
445 value = false; /* Default. */
446 ret = apply_one_bool("clock-date", params, &value, NULL);
447 if (ret != BT_COMPONENT_STATUS_OK) {
448 goto end;
449 }
3228cc1d 450 pretty->options.clock_date = value;
6e1bc0df
MD		 451
452 value = false; /* Default. */
453 ret = apply_one_bool("clock-gmt", params, &value, NULL);
454 if (ret != BT_COMPONENT_STATUS_OK) {
455 goto end;
456 }
3228cc1d 457 pretty->options.clock_gmt = value;
6e1bc0df 458
a263021c
JD		 459 value = false; /* Default. */
460 ret = apply_one_bool("verbose", params, &value, NULL);
461 if (ret != BT_COMPONENT_STATUS_OK) {
462 goto end;
463 }
3228cc1d 464 pretty->options.verbose = value;
a263021c 465
6e1bc0df
MD		 466 /* Names. */
467 ret = apply_one_string("name-default", params, &str);
468 if (ret != BT_COMPONENT_STATUS_OK) {
469 goto end;
470 }
471 if (!str) {
3228cc1d 472 pretty->options.name_default = PRETTY_DEFAULT_UNSET;
6e1bc0df 473 } else if (!strcmp(str, "show")) {
3228cc1d 474 pretty->options.name_default = PRETTY_DEFAULT_SHOW;
6e1bc0df 475 } else if (!strcmp(str, "hide")) {
3228cc1d 476 pretty->options.name_default = PRETTY_DEFAULT_HIDE;
6e1bc0df
MD		 477 } else {
478 ret = BT_COMPONENT_STATUS_ERROR;
479 goto end;
480 }
481 g_free(str);
482 str = NULL;
483
3228cc1d
PP		 484 switch (pretty->options.name_default) {
485 case PRETTY_DEFAULT_UNSET:
486 pretty->options.print_payload_field_names = true;
487 pretty->options.print_context_field_names = true;
488 pretty->options.print_header_field_names = false;
489 pretty->options.print_scope_field_names = false;
6e1bc0df 490 break;
3228cc1d
PP		 491 case PRETTY_DEFAULT_SHOW:
492 pretty->options.print_payload_field_names = true;
493 pretty->options.print_context_field_names = true;
494 pretty->options.print_header_field_names = true;
495 pretty->options.print_scope_field_names = true;
6e1bc0df 496 break;
3228cc1d
PP		 497 case PRETTY_DEFAULT_HIDE:
498 pretty->options.print_payload_field_names = false;
499 pretty->options.print_context_field_names = false;
500 pretty->options.print_header_field_names = false;
501 pretty->options.print_scope_field_names = false;
6e1bc0df
MD		 502 break;
503 default:
504 ret = BT_COMPONENT_STATUS_ERROR;
505 goto end;
506 }
507
508 value = false;
509 found = false;
510 ret = apply_one_bool("name-payload", params, &value, &found);
511 if (ret != BT_COMPONENT_STATUS_OK) {
512 goto end;
513 }
514 if (found) {
3228cc1d 515 pretty->options.print_payload_field_names = value;
6e1bc0df
MD		 516 }
517
518 value = false;
519 found = false;
520 ret = apply_one_bool("name-context", params, &value, &found);
521 if (ret != BT_COMPONENT_STATUS_OK) {
522 goto end;
523 }
524 if (found) {
3228cc1d 525 pretty->options.print_context_field_names = value;
6e1bc0df
MD		 526 }
527
528 value = false;
529 found = false;
530 ret = apply_one_bool("name-header", params, &value, &found);
531 if (ret != BT_COMPONENT_STATUS_OK) {
532 goto end;
533 }
534 if (found) {
3228cc1d 535 pretty->options.print_header_field_names = value;
6e1bc0df
MD		 536 }
537
538 value = false;
539 found = false;
540 ret = apply_one_bool("name-scope", params, &value, &found);
541 if (ret != BT_COMPONENT_STATUS_OK) {
542 goto end;
543 }
544 if (found) {
3228cc1d 545 pretty->options.print_scope_field_names = value;
6e1bc0df
MD		 546 }
547
548 /* Fields. */
549 ret = apply_one_string("field-default", params, &str);
550 if (ret != BT_COMPONENT_STATUS_OK) {
551 goto end;
552 }
553 if (!str) {
3228cc1d 554 pretty->options.field_default = PRETTY_DEFAULT_UNSET;
6e1bc0df 555 } else if (!strcmp(str, "show")) {
3228cc1d 556 pretty->options.field_default = PRETTY_DEFAULT_SHOW;
6e1bc0df 557 } else if (!strcmp(str, "hide")) {
3228cc1d 558 pretty->options.field_default = PRETTY_DEFAULT_HIDE;
6e1bc0df
MD		 559 } else {
560 ret = BT_COMPONENT_STATUS_ERROR;
561 goto end;
562 }
563 g_free(str);
564 str = NULL;
565
3228cc1d
PP		 566 switch (pretty->options.field_default) {
567 case PRETTY_DEFAULT_UNSET:
568 pretty->options.print_trace_field = false;
569 pretty->options.print_trace_hostname_field = true;
570 pretty->options.print_trace_domain_field = false;
571 pretty->options.print_trace_procname_field = true;
572 pretty->options.print_trace_vpid_field = true;
573 pretty->options.print_loglevel_field = false;
574 pretty->options.print_emf_field = false;
575 pretty->options.print_callsite_field = false;
6e1bc0df 576 break;
3228cc1d
PP		 577 case PRETTY_DEFAULT_SHOW:
578 pretty->options.print_trace_field = true;
579 pretty->options.print_trace_hostname_field = true;
580 pretty->options.print_trace_domain_field = true;
581 pretty->options.print_trace_procname_field = true;
582 pretty->options.print_trace_vpid_field = true;
583 pretty->options.print_loglevel_field = true;
584 pretty->options.print_emf_field = true;
585 pretty->options.print_callsite_field = true;
6e1bc0df 586 break;
3228cc1d
PP		 587 case PRETTY_DEFAULT_HIDE:
588 pretty->options.print_trace_field = false;
589 pretty->options.print_trace_hostname_field = false;
590 pretty->options.print_trace_domain_field = false;
591 pretty->options.print_trace_procname_field = false;
592 pretty->options.print_trace_vpid_field = false;
593 pretty->options.print_loglevel_field = false;
594 pretty->options.print_emf_field = false;
595 pretty->options.print_callsite_field = false;
6e1bc0df
MD		 596 break;
597 default:
598 ret = BT_COMPONENT_STATUS_ERROR;
599 goto end;
600 }
601
602 value = false;
603 found = false;
604 ret = apply_one_bool("field-trace", params, &value, &found);
605 if (ret != BT_COMPONENT_STATUS_OK) {
606 goto end;
607 }
608 if (found) {
3228cc1d 609 pretty->options.print_trace_field = value;
6e1bc0df
MD		 610 }
611
612 value = false;
613 found = false;
614 ret = apply_one_bool("field-trace:hostname", params, &value, &found);
615 if (ret != BT_COMPONENT_STATUS_OK) {
616 goto end;
617 }
618 if (found) {
3228cc1d 619 pretty->options.print_trace_hostname_field = value;
6e1bc0df
MD		 620 }
621
622 value = false;
623 found = false;
624 ret = apply_one_bool("field-trace:domain", params, &value, &found);
625 if (ret != BT_COMPONENT_STATUS_OK) {
626 goto end;
627 }
628 if (found) {
3228cc1d 629 pretty->options.print_trace_domain_field = value;
6e1bc0df
MD		 630 }
631
632 value = false;
633 found = false;
634 ret = apply_one_bool("field-trace:procname", params, &value, &found);
635 if (ret != BT_COMPONENT_STATUS_OK) {
636 goto end;
637 }
638 if (found) {
3228cc1d 639 pretty->options.print_trace_procname_field = value;
6e1bc0df
MD		 640 }
641
642 value = false;
643 found = false;
644 ret = apply_one_bool("field-trace:vpid", params, &value, &found);
645 if (ret != BT_COMPONENT_STATUS_OK) {
646 goto end;
647 }
648 if (found) {
3228cc1d 649 pretty->options.print_trace_vpid_field = value;
6e1bc0df
MD		 650 }
651
652 value = false;
653 found = false;
654 ret = apply_one_bool("field-loglevel", params, &value, &found);
655 if (ret != BT_COMPONENT_STATUS_OK) {
656 goto end;
657 }
658 if (found) {
3228cc1d 659 pretty->options.print_loglevel_field = value;
6e1bc0df
MD		 660 }
661
662 value = false;
663 found = false;
664 ret = apply_one_bool("field-emf", params, &value, &found);
665 if (ret != BT_COMPONENT_STATUS_OK) {
666 goto end;
667 }
668 if (found) {
3228cc1d 669 pretty->options.print_emf_field = value;
6e1bc0df
MD		 670 }
671
672 value = false;
673 found = false;
60535549 674 ret = apply_one_bool("field-callsite", params, &value, &found);
6e1bc0df
MD		 675 if (ret != BT_COMPONENT_STATUS_OK) {
676 goto end;
677 }
678 if (found) {
3228cc1d 679 pretty->options.print_callsite_field = value;
6e1bc0df
MD		 680 }
681
6e1bc0df 682end:
3228cc1d
PP		 683 bt_put(pretty->plugin_opt_map);
684 pretty->plugin_opt_map = NULL;
6e1bc0df
MD		 685 g_free(str);
686 return ret;
687}
688
ad96d936 689static
3228cc1d 690void set_use_colors(struct pretty_component *pretty)
ad96d936 691{
3228cc1d
PP		 692 switch (pretty->options.color) {
693 case PRETTY_COLOR_OPT_ALWAYS:
694 pretty->use_colors = true;
ad96d936 695 break;
3228cc1d
PP		 696 case PRETTY_COLOR_OPT_AUTO:
697 pretty->use_colors = pretty->out == stdout &&
ad96d936
PP		 698 bt_common_colors_supported();
699 break;
3228cc1d
PP		 700 case PRETTY_COLOR_OPT_NEVER:
701 pretty->use_colors = false;
ad96d936
PP		 702 break;
703 }
704}
705
2b4c4a7c
JD		 706static
707void init_stream_packet_context_quarks(void)
708{
709 stream_packet_context_quarks[Q_TIMESTAMP_BEGIN] =
710 g_quark_from_string("timestamp_begin");
711 stream_packet_context_quarks[Q_TIMESTAMP_BEGIN] =
712 g_quark_from_string("timestamp_begin");
713 stream_packet_context_quarks[Q_TIMESTAMP_END] =
714 g_quark_from_string("timestamp_end");
715 stream_packet_context_quarks[Q_EVENTS_DISCARDED] =
716 g_quark_from_string("events_discarded");
717 stream_packet_context_quarks[Q_CONTENT_SIZE] =
718 g_quark_from_string("content_size");
719 stream_packet_context_quarks[Q_PACKET_SIZE] =
720 g_quark_from_string("packet_size");
721 stream_packet_context_quarks[Q_PACKET_SEQ_NUM] =
722 g_quark_from_string("packet_seq_num");
723}
724
3228cc1d
PP		 725BT_HIDDEN
726enum bt_component_status pretty_init(
890882ef
PP		 727 struct bt_private_component *component,
728 struct bt_value *params,
7d61fa8e 729 UNUSED_VAR void *init_method_data)
bac67f0f
JG		 730{
731 enum bt_component_status ret;
3228cc1d 732 struct pretty_component *pretty = create_pretty();
bac67f0f 733
3228cc1d 734 if (!pretty) {
bac67f0f
JG		 735 ret = BT_COMPONENT_STATUS_NOMEM;
736 goto end;
737 }
738
147337a3
PP		 739 ret = bt_private_component_sink_add_input_private_port(component,
740 "in", NULL, NULL);
741 if (ret != BT_COMPONENT_STATUS_OK) {
b9d103be
PP		 742 goto end;
743 }
744
3228cc1d
PP		 745 pretty->out = stdout;
746 pretty->err = stderr;
6e1bc0df 747
3228cc1d
PP		 748 pretty->delta_cycles = -1ULL;
749 pretty->last_cycles_timestamp = -1ULL;
3af83b5a 750
3228cc1d
PP		 751 pretty->delta_real_timestamp = -1ULL;
752 pretty->last_real_timestamp = -1ULL;
3af83b5a 753
3228cc1d 754 ret = apply_params(pretty, params);
6e1bc0df
MD		 755 if (ret != BT_COMPONENT_STATUS_OK) {
756 goto error;
757 }
758
3228cc1d 759 set_use_colors(pretty);
3228cc1d 760 ret = bt_private_component_set_user_data(component, pretty);
bac67f0f
JG		 761 if (ret != BT_COMPONENT_STATUS_OK) {
762 goto error;
763 }
2b4c4a7c
JD		 764
765 init_stream_packet_context_quarks();
766
bac67f0f
JG		 767end:
768 return ret;
769error:
3228cc1d 770 destroy_pretty_data(pretty);
bac67f0f
JG		 771 return ret;
772}
BabelTrace - Trace Format Babel Tower
This page took 0.074576 seconds and 4 git commands to generate.