plugins/text/pretty/pretty.c

   1 /*
   2  * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  * Copyright 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  *
   5  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  */
  25
  26 #include <babeltrace/babeltrace.h>
  27 #include <babeltrace/compiler-internal.h>
  28 #include <babeltrace/common-internal.h>
  29 #include <plugins-common.h>
  30 #include <stdio.h>
  31 #include <stdbool.h>
  32 #include <glib.h>
  33 #include <babeltrace/assert-internal.h>
  34
  35 #include "pretty.h"
  36
  37 GQuark stream_packet_context_quarks[STREAM_PACKET_CONTEXT_QUARKS_LEN];
  38
  39 static
  40 const char *plugin_options[] = {
  41         "color",
  42         "path",
  43         "no-delta",
  44         "clock-cycles",
  45         "clock-seconds",
  46         "clock-date",
  47         "clock-gmt",
  48         "verbose",
  49         "name-default",         /* show/hide */
  50         "name-payload",
  51         "name-context",
  52         "name-scope",
  53         "name-header",
  54         "field-default",        /* show/hide */
  55         "field-trace",
  56         "field-trace:hostname",
  57         "field-trace:domain",
  58         "field-trace:procname",
  59         "field-trace:vpid",
  60         "field-loglevel",
  61         "field-emf",
  62         "field-callsite",
  63 };
  64
  65 static
  66 void destroy_pretty_data(struct pretty_component *pretty)
  67 {
  68         bt_self_component_port_input_message_iterator_put_ref(pretty->iterator);
  69
  70         if (pretty->string) {
  71                 (void) g_string_free(pretty->string, TRUE);
  72         }
  73
  74         if (pretty->tmp_string) {
  75                 (void) g_string_free(pretty->tmp_string, TRUE);
  76         }
  77
  78         if (pretty->out != stdout) {
  79                 int ret;
  80
  81                 ret = fclose(pretty->out);
  82                 if (ret) {
  83                         perror("close output file");
  84                 }
  85         }
  86         g_free(pretty->options.output_path);
  87         g_free(pretty);
  88 }
  89
  90 static
  91 struct pretty_component *create_pretty(void)
  92 {
  93         struct pretty_component *pretty;
  94
  95         pretty = g_new0(struct pretty_component, 1);
  96         if (!pretty) {
  97                 goto end;
  98         }
  99         pretty->string = g_string_new("");
 100         if (!pretty->string) {
 101                 goto error;
 102         }
 103         pretty->tmp_string = g_string_new("");
 104         if (!pretty->tmp_string) {
 105                 goto error;
 106         }
 107 end:
 108         return pretty;
 109
 110 error:
 111         g_free(pretty);
 112         return NULL;
 113 }
 114
 115 BT_HIDDEN
 116 void pretty_finalize(bt_self_component_sink *comp)
 117 {
 118         destroy_pretty_data(
 119                 bt_self_component_get_data(
 120                         bt_self_component_sink_as_self_component(comp)));
 121 }
 122
 123 static
 124 bt_self_component_status handle_message(
 125                 struct pretty_component *pretty,
 126                 const bt_message *message)
 127 {
 128         bt_self_component_status ret = BT_SELF_COMPONENT_STATUS_OK;
 129
 130         BT_ASSERT(pretty);
 131
 132         switch (bt_message_get_type(message)) {
 133         case BT_MESSAGE_TYPE_EVENT:
 134                 if (pretty_print_event(pretty, message)) {
 135                         ret = BT_SELF_COMPONENT_STATUS_ERROR;
 136                 }
 137                 break;
 138         case BT_MESSAGE_TYPE_INACTIVITY:
 139                 fprintf(stderr, "Inactivity message\n");
 140                 break;
 141         case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
 142         case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
 143                 if (pretty_print_discarded_items(pretty, message)) {
 144                         ret = BT_SELF_COMPONENT_STATUS_ERROR;
 145                 }
 146                 break;
 147         default:
 148                 break;
 149         }
 150
 151         return ret;
 152 }
 153
 154 BT_HIDDEN
 155 bt_self_component_status pretty_port_connected(
 156                 bt_self_component_sink *comp,
 157                 bt_self_component_port_input *self_port,
 158                 const bt_port_output *other_port)
 159 {
 160         bt_self_component_status status = BT_SELF_COMPONENT_STATUS_OK;
 161         struct pretty_component *pretty;
 162
 163         pretty = bt_self_component_get_data(
 164                         bt_self_component_sink_as_self_component(comp));
 165         BT_ASSERT(pretty);
 166         BT_ASSERT(!pretty->iterator);
 167         pretty->iterator = bt_self_component_port_input_message_iterator_create(
 168                 self_port);
 169         if (!pretty->iterator) {
 170                 status = BT_SELF_COMPONENT_STATUS_NOMEM;
 171         }
 172
 173         return status;
 174 }
 175
 176 BT_HIDDEN
 177 bt_self_component_status pretty_consume(
 178                 bt_self_component_sink *comp)
 179 {
 180         bt_self_component_status ret;
 181         bt_message_array_const msgs;
 182         bt_self_component_port_input_message_iterator *it;
 183         struct pretty_component *pretty = bt_self_component_get_data(
 184                 bt_self_component_sink_as_self_component(comp));
 185         bt_message_iterator_status it_ret;
 186         uint64_t count = 0;
 187         uint64_t i = 0;
 188
 189         it = pretty->iterator;
 190         it_ret = bt_self_component_port_input_message_iterator_next(it,
 191                 &msgs, &count);
 192
 193         switch (it_ret) {
 194         case BT_MESSAGE_ITERATOR_STATUS_OK:
 195                 break;
 196         case BT_MESSAGE_ITERATOR_STATUS_NOMEM:
 197                 ret = BT_SELF_COMPONENT_STATUS_NOMEM;
 198                 goto end;
 199         case BT_MESSAGE_ITERATOR_STATUS_AGAIN:
 200                 ret = BT_SELF_COMPONENT_STATUS_AGAIN;
 201                 goto end;
 202         case BT_MESSAGE_ITERATOR_STATUS_END:
 203                 ret = BT_SELF_COMPONENT_STATUS_END;
 204                 BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_PUT_REF_AND_RESET(
 205                         pretty->iterator);
 206                 goto end;
 207         default:
 208                 ret = BT_SELF_COMPONENT_STATUS_ERROR;
 209                 goto end;
 210         }
 211
 212         BT_ASSERT(it_ret == BT_MESSAGE_ITERATOR_STATUS_OK);
 213
 214         for (i = 0; i < count; i++) {
 215                 ret = handle_message(pretty, msgs[i]);
 216                 if (ret) {
 217                         goto end;
 218                 }
 219
 220                 bt_message_put_ref(msgs[i]);
 221         }
 222
 223 end:
 224         for (; i < count; i++) {
 225                 bt_message_put_ref(msgs[i]);
 226         }
 227
 228         return ret;
 229 }
 230
 231 static
 232 int add_params_to_map(bt_value *plugin_opt_map)
 233 {
 234         int ret = 0;
 235         unsigned int i;
 236
 237         for (i = 0; i < BT_ARRAY_SIZE(plugin_options); i++) {
 238                 const char *key = plugin_options[i];
 239                 bt_value_status status;
 240
 241                 status = bt_value_map_insert_entry(plugin_opt_map, key,
 242                         bt_value_null);
 243                 switch (status) {
 244                 case BT_VALUE_STATUS_OK:
 245                         break;
 246                 default:
 247                         ret = -1;
 248                         goto end;
 249                 }
 250         }
 251 end:
 252         return ret;
 253 }
 254
 255 static
 256 bt_bool check_param_exists(const char *key, const bt_value *object,
 257                 void *data)
 258 {
 259         struct pretty_component *pretty = data;
 260
 261         if (!bt_value_map_has_entry(pretty->plugin_opt_map,
 262                                     key)) {
 263                 fprintf(pretty->err,
 264                         "[warning] Parameter \"%s\" unknown to \"text.pretty\" sink component\n", key);
 265         }
 266         return BT_TRUE;
 267 }
 268
 269 static
 270 void apply_one_string(const char *key, const bt_value *params, char **option)
 271 {
 272         const bt_value *value = NULL;
 273         const char *str;
 274
 275         value = bt_value_map_borrow_entry_value_const(params, key);
 276         if (!value) {
 277                 goto end;
 278         }
 279         if (bt_value_is_null(value)) {
 280                 goto end;
 281         }
 282         str = bt_value_string_get(value);
 283         *option = g_strdup(str);
 284
 285 end:
 286         return;
 287 }
 288
 289 static
 290 void apply_one_bool(const char *key, const bt_value *params, bool *option,
 291                 bool *found)
 292 {
 293         const bt_value *value = NULL;
 294         bt_bool bool_val;
 295
 296         value = bt_value_map_borrow_entry_value_const(params, key);
 297         if (!value) {
 298                 goto end;
 299         }
 300         bool_val = bt_value_bool_get(value);
 301         *option = (bool) bool_val;
 302         if (found) {
 303                 *found = true;
 304         }
 305
 306 end:
 307         return;
 308 }
 309
 310 static
 311 void warn_wrong_color_param(struct pretty_component *pretty)
 312 {
 313         fprintf(pretty->err,
 314                 "[warning] Accepted values for the \"color\" parameter are:\n    \"always\", \"auto\", \"never\"\n");
 315 }
 316
 317 static
 318 int open_output_file(struct pretty_component *pretty)
 319 {
 320         int ret = 0;
 321
 322         if (!pretty->options.output_path) {
 323                 goto end;
 324         }
 325
 326         pretty->out = fopen(pretty->options.output_path, "w");
 327         if (!pretty->out) {
 328                 goto error;
 329         }
 330
 331         goto end;
 332
 333 error:
 334         ret = -1;
 335
 336 end:
 337         return ret;
 338 }
 339
 340 static
 341 int apply_params(struct pretty_component *pretty, const bt_value *params)
 342 {
 343         int ret = 0;
 344         bt_value_status status;
 345         bool value, found;
 346         char *str = NULL;
 347
 348         pretty->plugin_opt_map = bt_value_map_create();
 349         if (!pretty->plugin_opt_map) {
 350                 ret = -1;
 351                 goto end;
 352         }
 353         ret = add_params_to_map(pretty->plugin_opt_map);
 354         if (ret) {
 355                 goto end;
 356         }
 357         /* Report unknown parameters. */
 358         status = bt_value_map_foreach_entry_const(params,
 359                 check_param_exists, pretty);
 360         switch (status) {
 361         case BT_VALUE_STATUS_OK:
 362                 break;
 363         default:
 364                 ret = -1;
 365                 goto end;
 366         }
 367         /* Known parameters. */
 368         pretty->options.color = PRETTY_COLOR_OPT_AUTO;
 369         if (bt_value_map_has_entry(params, "color")) {
 370                 const bt_value *color_value;
 371                 const char *color;
 372
 373                 color_value = bt_value_map_borrow_entry_value_const(params,
 374                         "color");
 375                 if (!color_value) {
 376                         goto end;
 377                 }
 378
 379                 color = bt_value_string_get(color_value);
 380
 381                 if (strcmp(color, "never") == 0) {
 382                         pretty->options.color = PRETTY_COLOR_OPT_NEVER;
 383                 } else if (strcmp(color, "auto") == 0) {
 384                         pretty->options.color = PRETTY_COLOR_OPT_AUTO;
 385                 } else if (strcmp(color, "always") == 0) {
 386                         pretty->options.color = PRETTY_COLOR_OPT_ALWAYS;
 387                 } else {
 388                         warn_wrong_color_param(pretty);
 389                 }
 390         }
 391
 392         apply_one_string("path", params, &pretty->options.output_path);
 393         ret = open_output_file(pretty);
 394         if (ret) {
 395                 goto end;
 396         }
 397
 398         value = false;          /* Default. */
 399         apply_one_bool("no-delta", params, &value, NULL);
 400         pretty->options.print_delta_field = !value;     /* Reverse logic. */
 401
 402         value = false;          /* Default. */
 403         apply_one_bool("clock-cycles", params, &value, NULL);
 404         pretty->options.print_timestamp_cycles = value;
 405
 406         value = false;          /* Default. */
 407         apply_one_bool("clock-seconds", params, &value, NULL);
 408         pretty->options.clock_seconds = value;
 409
 410         value = false;          /* Default. */
 411         apply_one_bool("clock-date", params, &value, NULL);
 412         pretty->options.clock_date = value;
 413
 414         value = false;          /* Default. */
 415         apply_one_bool("clock-gmt", params, &value, NULL);
 416         pretty->options.clock_gmt = value;
 417
 418         value = false;          /* Default. */
 419         apply_one_bool("verbose", params, &value, NULL);
 420         pretty->options.verbose = value;
 421
 422         /* Names. */
 423         apply_one_string("name-default", params, &str);
 424         if (!str) {
 425                 pretty->options.name_default = PRETTY_DEFAULT_UNSET;
 426         } else if (!strcmp(str, "show")) {
 427                 pretty->options.name_default = PRETTY_DEFAULT_SHOW;
 428         } else if (!strcmp(str, "hide")) {
 429                 pretty->options.name_default = PRETTY_DEFAULT_HIDE;
 430         } else {
 431                 ret = -1;
 432                 goto end;
 433         }
 434         g_free(str);
 435         str = NULL;
 436
 437         switch (pretty->options.name_default) {
 438         case PRETTY_DEFAULT_UNSET:
 439                 pretty->options.print_payload_field_names = true;
 440                 pretty->options.print_context_field_names = true;
 441                 pretty->options.print_header_field_names = false;
 442                 pretty->options.print_scope_field_names = false;
 443                 break;
 444         case PRETTY_DEFAULT_SHOW:
 445                 pretty->options.print_payload_field_names = true;
 446                 pretty->options.print_context_field_names = true;
 447                 pretty->options.print_header_field_names = true;
 448                 pretty->options.print_scope_field_names = true;
 449                 break;
 450         case PRETTY_DEFAULT_HIDE:
 451                 pretty->options.print_payload_field_names = false;
 452                 pretty->options.print_context_field_names = false;
 453                 pretty->options.print_header_field_names = false;
 454                 pretty->options.print_scope_field_names = false;
 455                 break;
 456         default:
 457                 ret = -1;
 458                 goto end;
 459         }
 460
 461         value = false;
 462         found = false;
 463         apply_one_bool("name-payload", params, &value, &found);
 464         if (found) {
 465                 pretty->options.print_payload_field_names = value;
 466         }
 467
 468         value = false;
 469         found = false;
 470         apply_one_bool("name-context", params, &value, &found);
 471         if (found) {
 472                 pretty->options.print_context_field_names = value;
 473         }
 474
 475         value = false;
 476         found = false;
 477         apply_one_bool("name-header", params, &value, &found);
 478         if (found) {
 479                 pretty->options.print_header_field_names = value;
 480         }
 481
 482         value = false;
 483         found = false;
 484         apply_one_bool("name-scope", params, &value, &found);
 485         if (found) {
 486                 pretty->options.print_scope_field_names = value;
 487         }
 488
 489         /* Fields. */
 490         apply_one_string("field-default", params, &str);
 491         if (!str) {
 492                 pretty->options.field_default = PRETTY_DEFAULT_UNSET;
 493         } else if (!strcmp(str, "show")) {
 494                 pretty->options.field_default = PRETTY_DEFAULT_SHOW;
 495         } else if (!strcmp(str, "hide")) {
 496                 pretty->options.field_default = PRETTY_DEFAULT_HIDE;
 497         } else {
 498                 ret = -1;
 499                 goto end;
 500         }
 501         g_free(str);
 502         str = NULL;
 503
 504         switch (pretty->options.field_default) {
 505         case PRETTY_DEFAULT_UNSET:
 506                 pretty->options.print_trace_field = false;
 507                 pretty->options.print_trace_hostname_field = true;
 508                 pretty->options.print_trace_domain_field = false;
 509                 pretty->options.print_trace_procname_field = true;
 510                 pretty->options.print_trace_vpid_field = true;
 511                 pretty->options.print_loglevel_field = false;
 512                 pretty->options.print_emf_field = false;
 513                 pretty->options.print_callsite_field = false;
 514                 break;
 515         case PRETTY_DEFAULT_SHOW:
 516                 pretty->options.print_trace_field = true;
 517                 pretty->options.print_trace_hostname_field = true;
 518                 pretty->options.print_trace_domain_field = true;
 519                 pretty->options.print_trace_procname_field = true;
 520                 pretty->options.print_trace_vpid_field = true;
 521                 pretty->options.print_loglevel_field = true;
 522                 pretty->options.print_emf_field = true;
 523                 pretty->options.print_callsite_field = true;
 524                 break;
 525         case PRETTY_DEFAULT_HIDE:
 526                 pretty->options.print_trace_field = false;
 527                 pretty->options.print_trace_hostname_field = false;
 528                 pretty->options.print_trace_domain_field = false;
 529                 pretty->options.print_trace_procname_field = false;
 530                 pretty->options.print_trace_vpid_field = false;
 531                 pretty->options.print_loglevel_field = false;
 532                 pretty->options.print_emf_field = false;
 533                 pretty->options.print_callsite_field = false;
 534                 break;
 535         default:
 536                 ret = -1;
 537                 goto end;
 538         }
 539
 540         value = false;
 541         found = false;
 542         apply_one_bool("field-trace", params, &value, &found);
 543         if (found) {
 544                 pretty->options.print_trace_field = value;
 545         }
 546
 547         value = false;
 548         found = false;
 549         apply_one_bool("field-trace:hostname", params, &value, &found);
 550         if (found) {
 551                 pretty->options.print_trace_hostname_field = value;
 552         }
 553
 554         value = false;
 555         found = false;
 556         apply_one_bool("field-trace:domain", params, &value, &found);
 557         if (found) {
 558                 pretty->options.print_trace_domain_field = value;
 559         }
 560
 561         value = false;
 562         found = false;
 563         apply_one_bool("field-trace:procname", params, &value, &found);
 564         if (found) {
 565                 pretty->options.print_trace_procname_field = value;
 566         }
 567
 568         value = false;
 569         found = false;
 570         apply_one_bool("field-trace:vpid", params, &value, &found);
 571         if (found) {
 572                 pretty->options.print_trace_vpid_field = value;
 573         }
 574
 575         value = false;
 576         found = false;
 577         apply_one_bool("field-loglevel", params, &value, &found);
 578         if (found) {
 579                 pretty->options.print_loglevel_field = value;
 580         }
 581
 582         value = false;
 583         found = false;
 584         apply_one_bool("field-emf", params, &value, &found);
 585         if (found) {
 586                 pretty->options.print_emf_field = value;
 587         }
 588
 589         value = false;
 590         found = false;
 591         apply_one_bool("field-callsite", params, &value, &found);
 592         if (found) {
 593                 pretty->options.print_callsite_field = value;
 594         }
 595
 596 end:
 597         bt_value_put_ref(pretty->plugin_opt_map);
 598         pretty->plugin_opt_map = NULL;
 599         g_free(str);
 600         return ret;
 601 }
 602
 603 static
 604 void set_use_colors(struct pretty_component *pretty)
 605 {
 606         switch (pretty->options.color) {
 607         case PRETTY_COLOR_OPT_ALWAYS:
 608                 pretty->use_colors = true;
 609                 break;
 610         case PRETTY_COLOR_OPT_AUTO:
 611                 pretty->use_colors = pretty->out == stdout &&
 612                         bt_common_colors_supported();
 613                 break;
 614         case PRETTY_COLOR_OPT_NEVER:
 615                 pretty->use_colors = false;
 616                 break;
 617         }
 618 }
 619
 620 static
 621 void init_stream_packet_context_quarks(void)
 622 {
 623         stream_packet_context_quarks[Q_TIMESTAMP_BEGIN] =
 624                 g_quark_from_string("timestamp_begin");
 625         stream_packet_context_quarks[Q_TIMESTAMP_BEGIN] =
 626                 g_quark_from_string("timestamp_begin");
 627         stream_packet_context_quarks[Q_TIMESTAMP_END] =
 628                 g_quark_from_string("timestamp_end");
 629         stream_packet_context_quarks[Q_EVENTS_DISCARDED] =
 630                 g_quark_from_string("events_discarded");
 631         stream_packet_context_quarks[Q_CONTENT_SIZE] =
 632                 g_quark_from_string("content_size");
 633         stream_packet_context_quarks[Q_PACKET_SIZE] =
 634                 g_quark_from_string("packet_size");
 635         stream_packet_context_quarks[Q_PACKET_SEQ_NUM] =
 636                 g_quark_from_string("packet_seq_num");
 637 }
 638
 639 BT_HIDDEN
 640 bt_self_component_status pretty_init(
 641                 bt_self_component_sink *comp,
 642                 const bt_value *params,
 643                 UNUSED_VAR void *init_method_data)
 644 {
 645         bt_self_component_status ret;
 646         struct pretty_component *pretty = create_pretty();
 647
 648         if (!pretty) {
 649                 ret = BT_SELF_COMPONENT_STATUS_NOMEM;
 650                 goto end;
 651         }
 652
 653         ret = bt_self_component_sink_add_input_port(comp, "in", NULL, NULL);
 654         if (ret != BT_SELF_COMPONENT_STATUS_OK) {
 655                 goto end;
 656         }
 657
 658         pretty->out = stdout;
 659         pretty->err = stderr;
 660
 661         pretty->delta_cycles = -1ULL;
 662         pretty->last_cycles_timestamp = -1ULL;
 663
 664         pretty->delta_real_timestamp = -1ULL;
 665         pretty->last_real_timestamp = -1ULL;
 666
 667         if (apply_params(pretty, params)) {
 668                 ret = BT_SELF_COMPONENT_STATUS_ERROR;
 669                 goto error;
 670         }
 671
 672         set_use_colors(pretty);
 673         bt_self_component_set_data(
 674                 bt_self_component_sink_as_self_component(comp), pretty);
 675         init_stream_packet_context_quarks();
 676
 677 end:
 678         return ret;
 679
 680 error:
 681         destroy_pretty_data(pretty);
 682         return ret;
 683 }