src/plugins/common/muxing/muxing.c

   1 /*
   2  * Copyright 2019 Francis Deslauriers <francis.deslauriers@efficios.com>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22
  23 #include <babeltrace2/babeltrace.h>
  24
  25 #include <inttypes.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include "common/assert.h"
  30 #include "common/macros.h"
  31 #include "common/uuid.h"
  32
  33 #include "muxing.h"
  34
  35 struct message_to_compare {
  36         const bt_message *msg;
  37         const bt_trace *trace;
  38         const bt_stream *stream;
  39 };
  40
  41 struct messages_to_compare {
  42         struct message_to_compare left;
  43         struct message_to_compare right;
  44 };
  45
  46 static
  47 int message_type_weight(const bt_message_type msg_type)
  48 {
  49         int weight;
  50
  51         switch (msg_type) {
  52         case BT_MESSAGE_TYPE_STREAM_BEGINNING:
  53                 weight = 7;
  54                 break;
  55         case BT_MESSAGE_TYPE_PACKET_BEGINNING:
  56                 weight = 6;
  57                 break;
  58         case BT_MESSAGE_TYPE_EVENT:
  59                 weight = 5;
  60                 break;
  61         case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
  62                 weight = 4;
  63                 break;
  64         case BT_MESSAGE_TYPE_PACKET_END:
  65                 weight = 3;
  66                 break;
  67         case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY:
  68                 weight = 2;
  69                 break;
  70         case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
  71                 weight = 1;
  72                 break;
  73         case BT_MESSAGE_TYPE_STREAM_END:
  74                 weight = 0;
  75                 break;
  76         default:
  77                 abort();
  78         }
  79
  80         return weight;
  81 }
  82
  83 /*
  84  * Compare 2 messages to order them in a determinitic way based on their
  85  * types.
  86  * Returns -1 is left mesage must go first
  87  * Returns 1 is right mesage must go first
  88  */
  89 static
  90 int compare_messages_by_type(struct messages_to_compare *msgs)
  91 {
  92         bt_message_type left_msg_type = bt_message_get_type(msgs->left.msg);
  93         bt_message_type right_msg_type = bt_message_get_type(msgs->right.msg);
  94
  95         return message_type_weight(right_msg_type) -
  96                 message_type_weight(left_msg_type);
  97 }
  98
  99 static
 100 int compare_events(const bt_event *left_event, const bt_event *right_event)
 101 {
 102         int ret = 0;
 103         const bt_event_class *left_event_class, *right_event_class;
 104         uint64_t left_event_class_id, right_event_class_id;
 105         const char *left_event_class_name, *right_event_class_name,
 106                         *left_event_class_emf_uri, *right_event_class_emf_uri;
 107         bt_event_class_log_level left_event_class_log_level, right_event_class_log_level;
 108         bt_property_availability left_log_level_avail, right_log_level_avail;
 109
 110         left_event_class = bt_event_borrow_class_const(left_event);
 111         right_event_class = bt_event_borrow_class_const(right_event);
 112
 113         left_event_class_id = bt_event_class_get_id(left_event_class);
 114         right_event_class_id = bt_event_class_get_id(right_event_class);
 115
 116         if (left_event_class_id > right_event_class_id) {
 117                 ret = 1;
 118                 goto end;
 119         } else if (left_event_class_id < right_event_class_id) {
 120                 ret = -1;
 121                 goto end;
 122         }
 123
 124         left_event_class_name = bt_event_class_get_name(left_event_class);
 125         right_event_class_name = bt_event_class_get_name(right_event_class);
 126         if (left_event_class_name && right_event_class_name) {
 127                 ret = strcmp(left_event_class_name, right_event_class_name);
 128                 if (ret != 0) {
 129                         goto end;
 130                 }
 131         } else if (!left_event_class_name && right_event_class_name) {
 132                 ret = -1;
 133                 goto end;
 134         } else if (left_event_class_name && !right_event_class_name) {
 135                 ret = 1;
 136                 goto end;
 137         }
 138
 139         left_log_level_avail = bt_event_class_get_log_level(left_event_class,
 140                 &left_event_class_log_level);
 141         right_log_level_avail = bt_event_class_get_log_level(right_event_class,
 142                 &right_event_class_log_level);
 143
 144         if (left_log_level_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE &&
 145                         right_log_level_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
 146                 ret = left_event_class_log_level - right_event_class_log_level;
 147                 if (ret) {
 148                         goto end;
 149                 }
 150         } else if (left_log_level_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE &&
 151                         right_log_level_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) {
 152                 ret = -1;
 153                 goto end;
 154         } else if (left_log_level_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE &&
 155                         right_log_level_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
 156                 ret = 1;
 157                 goto end;
 158         }
 159
 160         left_event_class_emf_uri = bt_event_class_get_emf_uri(left_event_class);
 161         right_event_class_emf_uri = bt_event_class_get_emf_uri(right_event_class);
 162         if (left_event_class_emf_uri && right_event_class_emf_uri) {
 163                 ret = strcmp(left_event_class_emf_uri, right_event_class_emf_uri);
 164                 if (ret != 0) {
 165                         goto end;
 166                 }
 167         } else if (!left_event_class_emf_uri && right_event_class_emf_uri) {
 168                 ret = -1;
 169                 goto end;
 170         } else if (left_event_class_emf_uri && !right_event_class_emf_uri) {
 171                 ret = 1;
 172                 goto end;
 173         }
 174
 175 end:
 176         return ret;
 177 }
 178
 179 static
 180 int compare_streams(const bt_stream *left_stream, const bt_stream *right_stream)
 181 {
 182         int ret = 0;
 183         const char *left_stream_name, *right_stream_name,
 184               *left_stream_class_name, *right_stream_class_name;
 185         const bt_stream_class *left_stream_class, *right_stream_class;
 186
 187         /*
 188          * No need to compare stream id as it was checked earlier and if we are
 189          * here it means they are identical or both absent.
 190          */
 191         BT_ASSERT(bt_stream_get_id(left_stream) ==
 192                 bt_stream_get_id(right_stream));
 193
 194         /* Compare stream name. */
 195         left_stream_name = bt_stream_get_name(left_stream);
 196         right_stream_name = bt_stream_get_name(right_stream);
 197
 198         if (left_stream_name && right_stream_name) {
 199                 ret = strcmp(left_stream_name, right_stream_name);
 200                 if (ret != 0) {
 201                         goto end;
 202                 }
 203         } else if (!left_stream_name && right_stream_name) {
 204                 ret = -1;
 205                 goto end;
 206         } else if (left_stream_name && !right_stream_name) {
 207                 ret = 1;
 208                 goto end;
 209         }
 210
 211         left_stream_class = bt_stream_borrow_class_const(left_stream);
 212         right_stream_class = bt_stream_borrow_class_const(right_stream);
 213
 214         /*
 215          * No need to compare stream class id as it was checked earlier and if
 216          * we are here it means they are identical.
 217          */
 218         BT_ASSERT(bt_stream_class_get_id(left_stream_class) ==
 219                 bt_stream_class_get_id(right_stream_class));
 220
 221         /* Compare stream class name. */
 222         left_stream_class_name = bt_stream_class_get_name(left_stream_class);
 223         right_stream_class_name = bt_stream_class_get_name(right_stream_class);
 224
 225         if (left_stream_class_name && right_stream_class_name) {
 226                 ret = strcmp(left_stream_class_name, right_stream_class_name);
 227                 if (ret != 0) {
 228                         goto end;
 229                 }
 230         } else if (!left_stream_class_name && right_stream_class_name) {
 231                 ret = -1;
 232                 goto end;
 233         } else if (left_stream_class_name && !right_stream_class_name) {
 234                 ret = 1;
 235                 goto end;
 236         }
 237
 238         /* Compare stream class automatic event class id assignment. */
 239         if (bt_stream_class_assigns_automatic_event_class_id(left_stream_class) &&
 240                         !bt_stream_class_assigns_automatic_event_class_id(right_stream_class)) {
 241                 ret = 1;
 242                 goto end;
 243         } else if (!bt_stream_class_assigns_automatic_event_class_id(left_stream_class) &&
 244                         bt_stream_class_assigns_automatic_event_class_id(right_stream_class)) {
 245                 ret = -1;
 246                 goto end;
 247         }
 248
 249         /* Compare stream class automatic stream id assignment. */
 250         if (bt_stream_class_assigns_automatic_stream_id(left_stream_class) &&
 251                         !bt_stream_class_assigns_automatic_stream_id(right_stream_class)) {
 252                 ret = 1;
 253                 goto end;
 254         } else if (!bt_stream_class_assigns_automatic_stream_id(left_stream_class) &&
 255                         bt_stream_class_assigns_automatic_stream_id(right_stream_class)) {
 256                 ret = -1;
 257                 goto end;
 258         }
 259
 260         /* Compare stream class support of discarded events. */
 261         if (bt_stream_class_supports_discarded_events(left_stream_class) &&
 262                         !bt_stream_class_supports_discarded_events(right_stream_class)) {
 263                 ret = 1;
 264                 goto end;
 265         } else if (!bt_stream_class_supports_discarded_events(left_stream_class) &&
 266                         bt_stream_class_supports_discarded_events(right_stream_class)) {
 267                 ret = -1;
 268                 goto end;
 269         }
 270
 271         /* Compare stream class discarded events default clock snapshot. */
 272         if (bt_stream_class_discarded_events_have_default_clock_snapshots(left_stream_class) &&
 273                         !bt_stream_class_discarded_events_have_default_clock_snapshots(right_stream_class)) {
 274                 ret = 1;
 275                 goto end;
 276         } else if (!bt_stream_class_discarded_events_have_default_clock_snapshots(left_stream_class) &&
 277                         bt_stream_class_discarded_events_have_default_clock_snapshots(right_stream_class)) {
 278                 ret = -1;
 279                 goto end;
 280         }
 281
 282         /* Compare stream class support of packets. */
 283         if (bt_stream_class_supports_packets(left_stream_class) &&
 284                         !bt_stream_class_supports_packets(right_stream_class)) {
 285                 ret = 1;
 286                 goto end;
 287         } else if (!bt_stream_class_supports_packets(left_stream_class) &&
 288                         bt_stream_class_supports_packets(right_stream_class)) {
 289                 ret = -1;
 290                 goto end;
 291         }
 292
 293         if (!bt_stream_class_supports_packets(left_stream_class)) {
 294                 /* Skip all packet related checks. */
 295                 goto end;
 296         }
 297
 298         /*
 299          * Compare stream class presence of discarded packets beginning default
 300          * clock snapshot.
 301          */
 302         if (bt_stream_class_packets_have_beginning_default_clock_snapshot(left_stream_class) &&
 303                         !bt_stream_class_packets_have_beginning_default_clock_snapshot(right_stream_class)) {
 304                 ret = 1;
 305                 goto end;
 306         } else if (!bt_stream_class_packets_have_beginning_default_clock_snapshot(left_stream_class) &&
 307                         bt_stream_class_packets_have_beginning_default_clock_snapshot(right_stream_class)) {
 308                 ret = -1;
 309                 goto end;
 310         }
 311
 312         /*
 313          * Compare stream class presence of discarded packets end default clock
 314          * snapshot.
 315          */
 316         if (bt_stream_class_packets_have_end_default_clock_snapshot(left_stream_class) &&
 317                         !bt_stream_class_packets_have_end_default_clock_snapshot(right_stream_class)) {
 318                 ret = 1;
 319                 goto end;
 320         } else if (!bt_stream_class_packets_have_end_default_clock_snapshot(left_stream_class) &&
 321                         bt_stream_class_packets_have_end_default_clock_snapshot(right_stream_class)) {
 322                 ret = -1;
 323                 goto end;
 324         }
 325
 326         /* Compare stream class support of discarded packets. */
 327         if (bt_stream_class_supports_discarded_packets(left_stream_class) &&
 328                         !bt_stream_class_supports_discarded_packets(right_stream_class)) {
 329                 ret = 1;
 330                 goto end;
 331         } else if (!bt_stream_class_supports_discarded_packets(left_stream_class) &&
 332                         bt_stream_class_supports_discarded_packets(right_stream_class)) {
 333                 ret = -1;
 334                 goto end;
 335         }
 336
 337         /* Compare stream class discarded packets default clock snapshot. */
 338         if (bt_stream_class_discarded_packets_have_default_clock_snapshots(left_stream_class) &&
 339                         !bt_stream_class_discarded_packets_have_default_clock_snapshots(right_stream_class)) {
 340                 ret = 1;
 341                 goto end;
 342         } else if (!bt_stream_class_discarded_packets_have_default_clock_snapshots(left_stream_class) &&
 343                         bt_stream_class_discarded_packets_have_default_clock_snapshots(right_stream_class)) {
 344                 ret = -1;
 345                 goto end;
 346         }
 347
 348 end:
 349         return ret;
 350 }
 351
 352 static
 353 int compare_clock_snapshots_and_clock_classes(const bt_clock_snapshot *left_cs,
 354                 const bt_clock_snapshot *right_cs)
 355 {
 356         int ret;
 357         uint64_t left_freq, right_freq, left_prec, right_prec;
 358         uint64_t left_cs_value, right_cs_value;
 359         const bt_clock_class *left_clock_class, *right_clock_class;
 360         const char *left_clock_class_name, *right_clock_class_name;
 361         left_cs_value = bt_clock_snapshot_get_value(left_cs);
 362         right_cs_value = bt_clock_snapshot_get_value(right_cs);
 363         bt_uuid left_clock_class_uuid, right_clock_class_uuid;
 364
 365         ret = left_cs_value - right_cs_value;
 366         if (ret != 0) {
 367                 goto end;
 368         }
 369
 370         left_clock_class = bt_clock_snapshot_borrow_clock_class_const(left_cs);
 371         right_clock_class = bt_clock_snapshot_borrow_clock_class_const(right_cs);
 372
 373         left_clock_class_uuid = bt_clock_class_get_uuid(left_clock_class);
 374         right_clock_class_uuid = bt_clock_class_get_uuid(right_clock_class);
 375
 376         if (left_clock_class_uuid && !right_clock_class_uuid) {
 377                 ret = -1;
 378                 goto end;
 379         } else if (!left_clock_class_uuid && right_clock_class_uuid) {
 380                 ret = 1;
 381                 goto end;
 382         } else if (left_clock_class_uuid && right_clock_class_uuid) {
 383                 ret = bt_uuid_compare(left_clock_class_uuid,
 384                         right_clock_class_uuid);
 385                 if (ret != 0) {
 386                         goto end;
 387                 }
 388         }
 389
 390
 391         left_clock_class_name = bt_clock_class_get_name(left_clock_class);
 392         right_clock_class_name = bt_clock_class_get_name(right_clock_class);
 393
 394         if (left_clock_class_name && !right_clock_class_name) {
 395                 ret = -1;
 396                 goto end;
 397         } else if (!left_clock_class_name && right_clock_class_name) {
 398                 ret = 1;
 399                 goto end;
 400         } else if (left_clock_class_name && right_clock_class_name) {
 401                 ret = strcmp(left_clock_class_name, right_clock_class_name);
 402                 if (ret != 0) {
 403                         goto end;
 404                 }
 405         }
 406
 407         left_freq = bt_clock_class_get_frequency(left_clock_class);
 408         right_freq = bt_clock_class_get_frequency(right_clock_class);
 409
 410         ret = right_freq - left_freq;
 411         if (ret != 0) {
 412                 goto end;
 413         }
 414
 415         left_prec = bt_clock_class_get_precision(left_clock_class);
 416         right_prec = bt_clock_class_get_precision(right_clock_class);
 417
 418         ret = right_prec - left_prec;
 419         if (ret != 0) {
 420                 goto end;
 421         }
 422
 423 end:
 424         return ret;
 425 }
 426
 427 static
 428 const bt_stream *borrow_stream(const bt_message *msg)
 429 {
 430         bt_message_type msg_type = bt_message_get_type(msg);
 431         const bt_stream *stream = NULL;
 432         const bt_packet *packet = NULL;
 433         const bt_event *event = NULL;
 434
 435         switch (msg_type) {
 436         case BT_MESSAGE_TYPE_STREAM_BEGINNING:
 437                 stream = bt_message_stream_beginning_borrow_stream_const(msg);
 438                 break;
 439         case BT_MESSAGE_TYPE_STREAM_END:
 440                 stream = bt_message_stream_end_borrow_stream_const(msg);
 441                 break;
 442         case BT_MESSAGE_TYPE_PACKET_BEGINNING:
 443                 packet = bt_message_packet_beginning_borrow_packet_const(msg);
 444                 stream = bt_packet_borrow_stream_const(packet);
 445                 break;
 446         case BT_MESSAGE_TYPE_PACKET_END:
 447                 packet = bt_message_packet_end_borrow_packet_const(msg);
 448                 stream = bt_packet_borrow_stream_const(packet);
 449                 break;
 450         case BT_MESSAGE_TYPE_EVENT:
 451                 event = bt_message_event_borrow_event_const(msg);
 452                 stream = bt_event_borrow_stream_const(event);
 453                 break;
 454         case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
 455                 stream = bt_message_discarded_events_borrow_stream_const(msg);
 456                 break;
 457         case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
 458                 stream = bt_message_discarded_packets_borrow_stream_const(msg);
 459                 break;
 460         case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY:
 461                 goto end;
 462         default:
 463                 abort();
 464         }
 465
 466 end:
 467         return stream;
 468 }
 469
 470 static
 471 const bt_trace *borrow_trace(const bt_message *msg)
 472 {
 473         const bt_trace *trace = NULL;
 474         const bt_stream *stream = NULL;
 475
 476         stream = borrow_stream(msg);
 477         if (stream) {
 478                 trace = bt_stream_borrow_trace_const(stream);
 479         }
 480
 481         return trace;
 482 }
 483
 484 static
 485 int compare_messages_by_trace_name(struct messages_to_compare *msgs)
 486 {
 487         int ret = 0;
 488         const char *left_trace_name = NULL, *right_trace_name = NULL;
 489
 490         if (msgs->left.trace && !msgs->right.trace) {
 491                 ret = -1;
 492                 goto end;
 493         }
 494
 495         if (!msgs->left.trace && msgs->right.trace) {
 496                 ret = 1;
 497                 goto end;
 498         }
 499
 500         if (!msgs->left.trace && !msgs->right.trace) {
 501                 ret = 0;
 502                 goto end;
 503         }
 504
 505         left_trace_name = bt_trace_get_name(msgs->left.trace);
 506         right_trace_name = bt_trace_get_name(msgs->right.trace);
 507
 508         if (left_trace_name && !right_trace_name) {
 509                 ret = -1;
 510                 goto end;
 511         }
 512
 513         if (!left_trace_name && right_trace_name) {
 514                 ret = 1;
 515                 goto end;
 516         }
 517
 518         if (!left_trace_name && !right_trace_name) {
 519                 ret = 0;
 520                 goto end;
 521         }
 522
 523         ret = strcmp(left_trace_name, right_trace_name);
 524 end:
 525         return ret;
 526 }
 527
 528 static
 529 int compare_messages_by_trace_uuid(struct messages_to_compare *msgs)
 530 {
 531         int ret = 0;
 532         bt_uuid left_trace_uuid = NULL, right_trace_uuid = NULL;
 533
 534         if (msgs->left.trace && !msgs->right.trace) {
 535                 ret = -1;
 536                 goto end;
 537         }
 538
 539         if (!msgs->left.trace && msgs->right.trace) {
 540                 ret = 1;
 541                 goto end;
 542         }
 543
 544         if (!msgs->left.trace && !msgs->right.trace) {
 545                 ret = 0;
 546                 goto end;
 547         }
 548
 549         left_trace_uuid = bt_trace_get_uuid(msgs->left.trace);
 550         right_trace_uuid = bt_trace_get_uuid(msgs->right.trace);
 551
 552         if (left_trace_uuid && !right_trace_uuid) {
 553                 ret = -1;
 554                 goto end;
 555         }
 556
 557         if (!left_trace_uuid && right_trace_uuid) {
 558                 ret = 1;
 559                 goto end;
 560         }
 561
 562         if (!left_trace_uuid && !right_trace_uuid) {
 563                 ret = 0;
 564                 goto end;
 565         }
 566
 567         ret = bt_uuid_compare(left_trace_uuid, right_trace_uuid);
 568 end:
 569         return ret;
 570 }
 571
 572 static
 573 int compare_messages_by_stream_class_id(struct messages_to_compare *msgs)
 574 {
 575         int ret = 0;
 576         uint64_t left_stream_class_id = 0, right_stream_class_id = 0;
 577
 578         if (msgs->left.stream && !msgs->right.stream) {
 579                 ret = -1;
 580                 goto end;
 581         }
 582
 583         if (!msgs->left.stream && msgs->right.stream) {
 584                 ret = 1;
 585                 goto end;
 586         }
 587
 588         if (!msgs->left.stream && !msgs->right.stream) {
 589                 ret = 0;
 590                 goto end;
 591         }
 592
 593         left_stream_class_id = bt_stream_class_get_id(
 594                 bt_stream_borrow_class_const(msgs->left.stream));
 595
 596         right_stream_class_id = bt_stream_class_get_id(
 597                 bt_stream_borrow_class_const(msgs->right.stream));
 598
 599         if (left_stream_class_id == right_stream_class_id) {
 600                 ret = 0;
 601                 goto end;
 602         }
 603
 604         ret = (left_stream_class_id < right_stream_class_id) ? -1 : 1;
 605
 606 end:
 607         return ret;
 608 }
 609
 610 static
 611 int compare_messages_by_stream_id(struct messages_to_compare *msgs)
 612 {
 613         int ret = 0;
 614         uint64_t left_stream_id = 0, right_stream_id = 0;
 615
 616         if (msgs->left.stream && !msgs->right.stream) {
 617                 ret = -1;
 618                 goto end;
 619         }
 620
 621         if (!msgs->left.stream && msgs->right.stream) {
 622                 ret = 1;
 623                 goto end;
 624         }
 625
 626         if (!msgs->left.stream && !msgs->right.stream) {
 627                 ret = 0;
 628                 goto end;
 629         }
 630
 631         left_stream_id = bt_stream_get_id(msgs->left.stream);
 632         right_stream_id = bt_stream_get_id(msgs->right.stream);
 633
 634         if (left_stream_id == right_stream_id) {
 635                 ret = 0;
 636                 goto end;
 637         }
 638
 639         ret = (left_stream_id < right_stream_id) ? -1 : 1;
 640
 641 end:
 642         return ret;
 643 }
 644
 645 static
 646 int compare_messages_same_type(struct messages_to_compare *msgs)
 647 {
 648         int ret = 0;
 649
 650         /*
 651          * Both messages are of the same type, we must compare characterics of
 652          * the messages such as the attributes of the event in a event message.
 653          */
 654         BT_ASSERT(bt_message_get_type(msgs->left.msg) ==
 655                 bt_message_get_type(msgs->right.msg));
 656
 657         switch (bt_message_get_type(msgs->left.msg)) {
 658         case BT_MESSAGE_TYPE_STREAM_BEGINNING:
 659                 /* Fall-through */
 660         case BT_MESSAGE_TYPE_STREAM_END:
 661                 /* Fall-through */
 662         case BT_MESSAGE_TYPE_PACKET_BEGINNING:
 663                 /* Fall-through */
 664         case BT_MESSAGE_TYPE_PACKET_END:
 665                 ret = compare_streams(msgs->left.stream, msgs->right.stream);
 666                 if (ret) {
 667                         goto end;
 668                 }
 669
 670                 break;
 671         case BT_MESSAGE_TYPE_EVENT:
 672         {
 673                 const bt_event *left_event, *right_event;
 674                 left_event = bt_message_event_borrow_event_const(msgs->left.msg);
 675                 right_event = bt_message_event_borrow_event_const(msgs->right.msg);
 676
 677                 ret = compare_events(left_event, right_event);
 678                 if (ret) {
 679                         goto end;
 680                 }
 681
 682                 ret = compare_streams(msgs->left.stream, msgs->right.stream);
 683                 if (ret) {
 684                         goto end;
 685                 }
 686                 break;
 687         }
 688         case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
 689         {
 690                 const bt_stream_class *left_stream_class;
 691                 bt_property_availability left_event_count_avail,
 692                                          right_event_count_avail;
 693                 uint64_t left_event_count, right_event_count;
 694
 695                 /*
 696                  * Compare streams first to check if there is a
 697                  * mismatch about discarded event related configuration
 698                  * in the stream class.
 699                  */
 700                 ret = compare_streams(msgs->left.stream, msgs->right.stream);
 701                 if (ret) {
 702                         goto end;
 703                 }
 704
 705                 left_stream_class = bt_stream_borrow_class_const(msgs->left.stream);
 706                 if (bt_stream_class_discarded_events_have_default_clock_snapshots(
 707                                 left_stream_class)) {
 708                         const bt_clock_snapshot *left_beg_cs =
 709                                 bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(msgs->left.msg);
 710                         const bt_clock_snapshot *right_beg_cs =
 711                                 bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(msgs->right.msg);
 712                         const bt_clock_snapshot *left_end_cs =
 713                                 bt_message_discarded_events_borrow_end_default_clock_snapshot_const(msgs->left.msg);
 714                         const bt_clock_snapshot *right_end_cs =
 715                                 bt_message_discarded_events_borrow_end_default_clock_snapshot_const(msgs->right.msg);
 716
 717                         ret = compare_clock_snapshots_and_clock_classes(
 718                                 left_beg_cs, right_beg_cs);
 719                         if (ret) {
 720                                 goto end;
 721                         }
 722
 723                         ret = compare_clock_snapshots_and_clock_classes(
 724                                 left_end_cs, right_end_cs);
 725                         if (ret) {
 726                                 goto end;
 727                         }
 728                 }
 729
 730                 left_event_count_avail =
 731                         bt_message_discarded_events_get_count(
 732                                 msgs->left.msg, &left_event_count);
 733                 right_event_count_avail =
 734                         bt_message_discarded_events_get_count(
 735                                 msgs->right.msg, &right_event_count);
 736                 if (left_event_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE &&
 737                         right_event_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
 738                         ret = left_event_count - right_event_count;
 739                         if (ret != 0) {
 740                                 goto end;
 741                         }
 742                 } else if (left_event_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE &&
 743                         right_event_count_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) {
 744                         ret = -1;
 745                         goto end;
 746                 } else if (left_event_count_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE &&
 747                         right_event_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
 748                         ret = 1;
 749                         goto end;
 750                 }
 751
 752                 break;
 753         }
 754         case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
 755         {
 756                 const bt_stream_class *left_stream_class;
 757                 bt_property_availability left_packet_count_avail,
 758                                          right_packet_count_avail;
 759                 uint64_t left_packet_count, right_packet_count;
 760
 761                 /*
 762                  * Compare streams first to check if there is a
 763                  * mismatch about discarded packets related
 764                  * configuration in the stream class.
 765                  */
 766                 ret = compare_streams(msgs->left.stream, msgs->right.stream);
 767                 if (ret) {
 768                         goto end;
 769                 }
 770
 771                 left_stream_class = bt_stream_borrow_class_const(msgs->left.stream);
 772
 773                 if (bt_stream_class_discarded_packets_have_default_clock_snapshots(
 774                                 left_stream_class)) {
 775                         const bt_clock_snapshot *left_beg_cs =
 776                                 bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(msgs->left.msg);
 777                         const bt_clock_snapshot *right_beg_cs =
 778                                 bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(msgs->right.msg);
 779                         const bt_clock_snapshot *left_end_cs =
 780                                 bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(msgs->left.msg);
 781                         const bt_clock_snapshot *right_end_cs =
 782                                 bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(msgs->right.msg);
 783
 784                         ret = compare_clock_snapshots_and_clock_classes(
 785                                 left_beg_cs, right_beg_cs);
 786                         if (ret) {
 787                                 goto end;
 788                         }
 789
 790                         ret = compare_clock_snapshots_and_clock_classes(
 791                                 left_end_cs, right_end_cs);
 792                         if (ret) {
 793                                 goto end;
 794                         }
 795                 }
 796
 797                 left_packet_count_avail = bt_message_discarded_packets_get_count(
 798                         msgs->left.msg, &left_packet_count);
 799                 right_packet_count_avail = bt_message_discarded_packets_get_count(
 800                         msgs->right.msg, &right_packet_count);
 801                 if (left_packet_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE &&
 802                         right_packet_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
 803                         ret = left_packet_count - right_packet_count;
 804                         if (ret != 0) {
 805                                 goto end;
 806                         }
 807                 } else if (left_packet_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE &&
 808                         right_packet_count_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE) {
 809                         ret = -1;
 810                         goto end;
 811                 } else if (left_packet_count_avail == BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE &&
 812                         right_packet_count_avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
 813                         ret = 1;
 814                         goto end;
 815                 }
 816
 817                 break;
 818         }
 819         case BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY:
 820         {
 821                 const bt_clock_snapshot *left_cs =
 822                         bt_message_message_iterator_inactivity_borrow_default_clock_snapshot_const(msgs->left.msg);
 823                 const bt_clock_snapshot *right_cs =
 824                         bt_message_message_iterator_inactivity_borrow_default_clock_snapshot_const(msgs->right.msg);
 825
 826                 ret = compare_clock_snapshots_and_clock_classes(
 827                         left_cs, right_cs);
 828                 if (ret != 0) {
 829                         goto end;
 830                 }
 831
 832                 break;
 833         }
 834         default:
 835                 abort();
 836         }
 837
 838 end:
 839         return ret;
 840 }
 841
 842 BT_HIDDEN
 843 int common_muxing_compare_messages(const bt_message *left_msg,
 844                 const bt_message *right_msg)
 845 {
 846         int ret = 0;
 847         struct messages_to_compare msgs;
 848
 849         BT_ASSERT(left_msg != right_msg);
 850
 851         msgs.left.msg = left_msg;
 852         msgs.left.trace = borrow_trace(left_msg);
 853         msgs.left.stream = borrow_stream(left_msg);
 854
 855         msgs.right.msg = right_msg;
 856         msgs.right.trace = borrow_trace(right_msg);
 857         msgs.right.stream = borrow_stream(right_msg);
 858
 859         /* Same timestamp: compare trace UUIDs. */
 860         ret = compare_messages_by_trace_uuid(&msgs);
 861         if (ret) {
 862                 goto end;
 863         }
 864
 865         /* Same timestamp and trace UUID: compare trace names. */
 866         ret = compare_messages_by_trace_name(&msgs);
 867         if (ret) {
 868                 goto end;
 869         }
 870
 871         /*
 872          * Same timestamp, trace name, and trace UUID: compare stream class
 873          * IDs.
 874          */
 875         ret = compare_messages_by_stream_class_id(&msgs);
 876         if (ret) {
 877                 goto end;
 878         }
 879
 880         /*
 881          * Same timestamp, trace name, trace UUID, and stream class ID: compare
 882          * stream IDs.
 883          */
 884         ret = compare_messages_by_stream_id(&msgs);
 885         if (ret) {
 886                 goto end;
 887         }
 888
 889         if (bt_message_get_type(msgs.left.msg) !=
 890                         bt_message_get_type(msgs.right.msg)) {
 891                 /*
 892                  * The messages are of different type, we order (arbitrarily)
 893                  * in the following way:
 894                  * SB < PB < EV < DE < MI < PE < DP < SE
 895                  */
 896                 ret = compare_messages_by_type(&msgs);
 897                 if (ret) {
 898                         goto end;
 899                 }
 900         } else {
 901                 /* The messages are of the same type. */
 902                 ret = compare_messages_same_type(&msgs);
 903                 if (ret) {
 904                         goto end;
 905                 }
 906         }
 907
 908 end:
 909         return ret;
 910 }