Move to kernel style SPDX license identifiers
[babeltrace.git] / src / plugins / text / pretty / pretty.c
1 /*
2 * SPDX-License-Identifier: MIT
3 *
4 * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 * Copyright 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
6 */
7
8 #define BT_COMP_LOG_SELF_COMP self_comp
9 #define BT_LOG_OUTPUT_LEVEL log_level
10 #define BT_LOG_TAG "PLUGIN/SINK.TEXT.PRETTY"
11 #include "logging/comp-logging.h"
12
13 #include <babeltrace2/babeltrace.h>
14 #include "compat/compiler.h"
15 #include "common/common.h"
16 #include <stdio.h>
17 #include <stdbool.h>
18 #include <glib.h>
19 #include <string.h>
20 #include "common/assert.h"
21 #include "plugins/common/param-validation/param-validation.h"
22
23 #include "pretty.h"
24
25 static
26 const char * const in_port_name = "in";
27
28 static
29 void destroy_pretty_data(struct pretty_component *pretty)
30 {
31 if (!pretty) {
32 goto end;
33 }
34
35 bt_message_iterator_put_ref(pretty->iterator);
36
37 if (pretty->string) {
38 (void) g_string_free(pretty->string, TRUE);
39 }
40
41 if (pretty->tmp_string) {
42 (void) g_string_free(pretty->tmp_string, TRUE);
43 }
44
45 if (pretty->out != stdout) {
46 int ret;
47
48 ret = fclose(pretty->out);
49 if (ret) {
50 perror("close output file");
51 }
52 }
53 g_free(pretty->options.output_path);
54 g_free(pretty);
55
56 end:
57 return;
58 }
59
60 static
61 struct pretty_component *create_pretty(void)
62 {
63 struct pretty_component *pretty;
64
65 pretty = g_new0(struct pretty_component, 1);
66 if (!pretty) {
67 goto end;
68 }
69 pretty->string = g_string_new("");
70 if (!pretty->string) {
71 goto error;
72 }
73 pretty->tmp_string = g_string_new("");
74 if (!pretty->tmp_string) {
75 goto error;
76 }
77 end:
78 return pretty;
79
80 error:
81 g_free(pretty);
82 return NULL;
83 }
84
85 BT_HIDDEN
86 void pretty_finalize(bt_self_component_sink *comp)
87 {
88 destroy_pretty_data(
89 bt_self_component_get_data(
90 bt_self_component_sink_as_self_component(comp)));
91 }
92
93 static
94 bt_message_iterator_class_next_method_status handle_message(
95 struct pretty_component *pretty,
96 const bt_message *message)
97 {
98 bt_message_iterator_class_next_method_status ret =
99 BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
100
101 BT_ASSERT_DBG(pretty);
102
103 switch (bt_message_get_type(message)) {
104 case BT_MESSAGE_TYPE_EVENT:
105 if (pretty_print_event(pretty, message)) {
106 ret = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
107 }
108 break;
109 case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
110 case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
111 if (pretty_print_discarded_items(pretty, message)) {
112 ret = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
113 }
114 break;
115 default:
116 break;
117 }
118
119 return ret;
120 }
121
122 BT_HIDDEN
123 bt_component_class_sink_graph_is_configured_method_status
124 pretty_graph_is_configured(bt_self_component_sink *comp)
125 {
126 bt_component_class_sink_graph_is_configured_method_status status;
127 bt_message_iterator_create_from_sink_component_status
128 msg_iter_status;
129 struct pretty_component *pretty;
130
131 pretty = bt_self_component_get_data(
132 bt_self_component_sink_as_self_component(comp));
133 BT_ASSERT(pretty);
134 BT_ASSERT(!pretty->iterator);
135 msg_iter_status = bt_message_iterator_create_from_sink_component(
136 comp, bt_self_component_sink_borrow_input_port_by_name(comp,
137 in_port_name), &pretty->iterator);
138 if (msg_iter_status != BT_MESSAGE_ITERATOR_CREATE_FROM_SINK_COMPONENT_STATUS_OK) {
139 status = (int) msg_iter_status;
140 goto end;
141 }
142
143 status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;
144
145 end:
146 return status;
147 }
148
149 BT_HIDDEN
150 bt_component_class_sink_consume_method_status pretty_consume(
151 bt_self_component_sink *comp)
152 {
153 bt_component_class_sink_consume_method_status ret =
154 BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
155 bt_message_array_const msgs;
156 bt_message_iterator *it;
157 struct pretty_component *pretty = bt_self_component_get_data(
158 bt_self_component_sink_as_self_component(comp));
159 bt_message_iterator_next_status next_status;
160 uint64_t count = 0;
161 uint64_t i = 0;
162
163 it = pretty->iterator;
164 next_status = bt_message_iterator_next(it,
165 &msgs, &count);
166
167 switch (next_status) {
168 case BT_MESSAGE_ITERATOR_NEXT_STATUS_OK:
169 break;
170 case BT_MESSAGE_ITERATOR_NEXT_STATUS_MEMORY_ERROR:
171 case BT_MESSAGE_ITERATOR_NEXT_STATUS_AGAIN:
172 ret = (int) next_status;
173 goto end;
174 case BT_MESSAGE_ITERATOR_NEXT_STATUS_END:
175 ret = (int) next_status;
176 BT_MESSAGE_ITERATOR_PUT_REF_AND_RESET(
177 pretty->iterator);
178 goto end;
179 default:
180 ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
181 goto end;
182 }
183
184 BT_ASSERT_DBG(next_status == BT_MESSAGE_ITERATOR_NEXT_STATUS_OK);
185
186 for (i = 0; i < count; i++) {
187 ret = (int) handle_message(pretty, msgs[i]);
188 if (ret) {
189 goto end;
190 }
191
192 bt_message_put_ref(msgs[i]);
193 }
194
195 end:
196 for (; i < count; i++) {
197 bt_message_put_ref(msgs[i]);
198 }
199
200 return ret;
201 }
202
203 static
204 void apply_one_string(const char *key, const bt_value *params, char **option)
205 {
206 const bt_value *value = NULL;
207 const char *str;
208
209 value = bt_value_map_borrow_entry_value_const(params, key);
210 if (!value) {
211 goto end;
212 }
213
214 str = bt_value_string_get(value);
215 *option = g_strdup(str);
216
217 end:
218 return;
219 }
220
221 /*
222 * Apply parameter with key `key` to `option`. Use `def` as the value, if
223 * the parameter is not specified.
224 */
225
226 static
227 void apply_one_bool_with_default(const char *key, const bt_value *params,
228 bool *option, bool def)
229 {
230 const bt_value *value;
231
232 value = bt_value_map_borrow_entry_value_const(params, key);
233 if (value) {
234 bt_bool bool_val = bt_value_bool_get(value);
235
236 *option = (bool) bool_val;
237 } else {
238 *option = def;
239 }
240 }
241
242 static
243 void apply_one_bool_if_specified(const char *key, const bt_value *params, bool *option)
244 {
245 const bt_value *value;
246
247 value = bt_value_map_borrow_entry_value_const(params, key);
248 if (value) {
249 bt_bool bool_val = bt_value_bool_get(value);
250
251 *option = (bool) bool_val;
252 }
253 }
254
255 static
256 int open_output_file(struct pretty_component *pretty)
257 {
258 int ret = 0;
259
260 if (!pretty->options.output_path) {
261 goto end;
262 }
263
264 pretty->out = fopen(pretty->options.output_path, "w");
265 if (!pretty->out) {
266 goto error;
267 }
268
269 goto end;
270
271 error:
272 ret = -1;
273
274 end:
275 return ret;
276 }
277
278 static const char *color_choices[] = { "never", "auto", "always", NULL };
279 static const char *show_hide_choices[] = { "show", "hide", NULL };
280
281 static
282 struct bt_param_validation_map_value_entry_descr pretty_params[] = {
283 { "color", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
284 .choices = color_choices,
285 } } },
286 { "path", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_STRING } },
287 { "no-delta", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
288 { "clock-cycles", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
289 { "clock-seconds", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
290 { "clock-date", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
291 { "clock-gmt", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
292 { "verbose", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
293
294 { "name-default", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
295 .choices = show_hide_choices,
296 } } },
297 { "name-payload", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
298 { "name-context", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
299 { "name-scope", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
300 { "name-header", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
301
302 { "field-default", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
303 .choices = show_hide_choices,
304 } } },
305 { "field-trace", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
306 { "field-trace:hostname", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
307 { "field-trace:domain", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
308 { "field-trace:procname", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
309 { "field-trace:vpid", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
310 { "field-loglevel", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
311 { "field-emf", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
312 { "field-callsite", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
313 BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END
314 };
315
316 static
317 bt_component_class_initialize_method_status apply_params(
318 struct pretty_component *pretty, const bt_value *params,
319 bt_self_component *self_comp, bt_logging_level log_level)
320 {
321 int ret;
322 const bt_value *value;
323 bt_component_class_initialize_method_status status;
324 enum bt_param_validation_status validation_status;
325 gchar *validate_error = NULL;
326
327 validation_status = bt_param_validation_validate(params,
328 pretty_params, &validate_error);
329 if (validation_status == BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR) {
330 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
331 goto end;
332 } else if (validation_status == BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR) {
333 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
334 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "%s", validate_error);
335 goto end;
336 }
337
338 /* Known parameters. */
339 pretty->options.color = PRETTY_COLOR_OPT_AUTO;
340 value = bt_value_map_borrow_entry_value_const(params, "color");
341 if (value) {
342 const char *color = bt_value_string_get(value);
343
344 if (strcmp(color, "never") == 0) {
345 pretty->options.color = PRETTY_COLOR_OPT_NEVER;
346 } else if (strcmp(color, "auto") == 0) {
347 pretty->options.color = PRETTY_COLOR_OPT_AUTO;
348 } else {
349 BT_ASSERT(strcmp(color, "always") == 0);
350 pretty->options.color = PRETTY_COLOR_OPT_ALWAYS;
351 }
352 }
353
354 apply_one_string("path", params, &pretty->options.output_path);
355 ret = open_output_file(pretty);
356 if (ret) {
357 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
358 goto end;
359 }
360
361 apply_one_bool_with_default("no-delta", params,
362 &pretty->options.print_delta_field, false);
363 /* Reverse logic. */
364 pretty->options.print_delta_field = !pretty->options.print_delta_field;
365
366 apply_one_bool_with_default("clock-cycles", params,
367 &pretty->options.print_timestamp_cycles, false);
368
369 apply_one_bool_with_default("clock-seconds", params,
370 &pretty->options.clock_seconds , false);
371
372 apply_one_bool_with_default("clock-date", params,
373 &pretty->options.clock_date, false);
374
375 apply_one_bool_with_default("clock-gmt", params,
376 &pretty->options.clock_gmt, false);
377
378 apply_one_bool_with_default("verbose", params,
379 &pretty->options.verbose, false);
380
381 /* Names. */
382 value = bt_value_map_borrow_entry_value_const(params, "name-default");
383 if (value) {
384 const char *str = bt_value_string_get(value);
385
386 if (strcmp(str, "show") == 0) {
387 pretty->options.name_default = PRETTY_DEFAULT_SHOW;
388 } else {
389 BT_ASSERT(strcmp(str, "hide") == 0);
390 pretty->options.name_default = PRETTY_DEFAULT_HIDE;
391 }
392 } else {
393 pretty->options.name_default = PRETTY_DEFAULT_UNSET;
394 }
395
396 switch (pretty->options.name_default) {
397 case PRETTY_DEFAULT_UNSET:
398 pretty->options.print_payload_field_names = true;
399 pretty->options.print_context_field_names = true;
400 pretty->options.print_header_field_names = false;
401 pretty->options.print_scope_field_names = false;
402 break;
403 case PRETTY_DEFAULT_SHOW:
404 pretty->options.print_payload_field_names = true;
405 pretty->options.print_context_field_names = true;
406 pretty->options.print_header_field_names = true;
407 pretty->options.print_scope_field_names = true;
408 break;
409 case PRETTY_DEFAULT_HIDE:
410 pretty->options.print_payload_field_names = false;
411 pretty->options.print_context_field_names = false;
412 pretty->options.print_header_field_names = false;
413 pretty->options.print_scope_field_names = false;
414 break;
415 default:
416 bt_common_abort();
417 }
418
419 apply_one_bool_if_specified("name-payload", params,
420 &pretty->options.print_payload_field_names);
421
422 apply_one_bool_if_specified("name-context", params,
423 &pretty->options.print_context_field_names);
424
425 apply_one_bool_if_specified("name-header", params,
426 &pretty->options.print_header_field_names);
427
428 apply_one_bool_if_specified("name-scope", params,
429 &pretty->options.print_scope_field_names);
430
431 /* Fields. */
432 value = bt_value_map_borrow_entry_value_const(params, "field-default");
433 if (value) {
434 const char *str = bt_value_string_get(value);
435
436 if (strcmp(str, "show") == 0) {
437 pretty->options.field_default = PRETTY_DEFAULT_SHOW;
438 } else {
439 BT_ASSERT(strcmp(str, "hide") == 0);
440 pretty->options.field_default = PRETTY_DEFAULT_HIDE;
441 }
442 } else {
443 pretty->options.field_default = PRETTY_DEFAULT_UNSET;
444 }
445
446 switch (pretty->options.field_default) {
447 case PRETTY_DEFAULT_UNSET:
448 pretty->options.print_trace_field = false;
449 pretty->options.print_trace_hostname_field = true;
450 pretty->options.print_trace_domain_field = false;
451 pretty->options.print_trace_procname_field = true;
452 pretty->options.print_trace_vpid_field = true;
453 pretty->options.print_loglevel_field = false;
454 pretty->options.print_emf_field = false;
455 pretty->options.print_callsite_field = false;
456 break;
457 case PRETTY_DEFAULT_SHOW:
458 pretty->options.print_trace_field = true;
459 pretty->options.print_trace_hostname_field = true;
460 pretty->options.print_trace_domain_field = true;
461 pretty->options.print_trace_procname_field = true;
462 pretty->options.print_trace_vpid_field = true;
463 pretty->options.print_loglevel_field = true;
464 pretty->options.print_emf_field = true;
465 pretty->options.print_callsite_field = true;
466 break;
467 case PRETTY_DEFAULT_HIDE:
468 pretty->options.print_trace_field = false;
469 pretty->options.print_trace_hostname_field = false;
470 pretty->options.print_trace_domain_field = false;
471 pretty->options.print_trace_procname_field = false;
472 pretty->options.print_trace_vpid_field = false;
473 pretty->options.print_loglevel_field = false;
474 pretty->options.print_emf_field = false;
475 pretty->options.print_callsite_field = false;
476 break;
477 default:
478 bt_common_abort();
479 }
480
481 apply_one_bool_if_specified("field-trace", params,
482 &pretty->options.print_trace_field);
483
484 apply_one_bool_if_specified("field-trace:hostname", params,
485 &pretty->options.print_trace_hostname_field);
486
487 apply_one_bool_if_specified("field-trace:domain", params,
488 &pretty->options.print_trace_domain_field);
489
490 apply_one_bool_if_specified("field-trace:procname", params,
491 &pretty->options.print_trace_procname_field);
492
493 apply_one_bool_if_specified("field-trace:vpid", params,
494 &pretty->options.print_trace_vpid_field);
495
496 apply_one_bool_if_specified("field-loglevel", params,
497 &pretty->options.print_loglevel_field);
498
499 apply_one_bool_if_specified("field-emf", params,
500 &pretty->options.print_emf_field);
501
502 apply_one_bool_if_specified("field-callsite", params,
503 &pretty->options.print_callsite_field);
504
505 pretty_print_init();
506 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
507
508 end:
509 g_free(validate_error);
510
511 return status;
512 }
513
514 static
515 void set_use_colors(struct pretty_component *pretty)
516 {
517 switch (pretty->options.color) {
518 case PRETTY_COLOR_OPT_ALWAYS:
519 pretty->use_colors = true;
520 break;
521 case PRETTY_COLOR_OPT_AUTO:
522 pretty->use_colors = pretty->out == stdout &&
523 bt_common_colors_supported();
524 break;
525 case PRETTY_COLOR_OPT_NEVER:
526 pretty->use_colors = false;
527 break;
528 }
529 }
530
531 BT_HIDDEN
532 bt_component_class_initialize_method_status pretty_init(
533 bt_self_component_sink *self_comp_sink,
534 bt_self_component_sink_configuration *config,
535 const bt_value *params,
536 __attribute__((unused)) void *init_method_data)
537 {
538 bt_component_class_initialize_method_status status;
539 bt_self_component_add_port_status add_port_status;
540 struct pretty_component *pretty = create_pretty();
541 bt_self_component *self_comp =
542 bt_self_component_sink_as_self_component(self_comp_sink);
543 const bt_component *comp = bt_self_component_as_component(self_comp);
544 bt_logging_level log_level = bt_component_get_logging_level(comp);
545
546 if (!pretty) {
547 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
548 goto error;
549 }
550
551 add_port_status = bt_self_component_sink_add_input_port(self_comp_sink,
552 in_port_name, NULL, NULL);
553 if (add_port_status != BT_SELF_COMPONENT_ADD_PORT_STATUS_OK) {
554 status = (int) add_port_status;
555 goto error;
556 }
557
558 pretty->out = stdout;
559 pretty->err = stderr;
560
561 pretty->delta_cycles = -1ULL;
562 pretty->last_cycles_timestamp = -1ULL;
563
564 pretty->delta_real_timestamp = -1ULL;
565 pretty->last_real_timestamp = -1ULL;
566
567 status = apply_params(pretty, params, self_comp, log_level);
568 if (status != BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK) {
569 goto error;
570 }
571
572 set_use_colors(pretty);
573 bt_self_component_set_data(self_comp, pretty);
574
575 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
576 goto end;
577
578 error:
579 destroy_pretty_data(pretty);
580
581 end:
582 return status;
583 }
This page took 0.041354 seconds and 4 git commands to generate.