contrib/processor-trace/libipt/src/pt_packet_decoder.c

   1 /*
   2  * Copyright (c) 2014-2018, Intel Corporation
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  *  * Redistributions of source code must retain the above copyright notice,
   8  *    this list of conditions and the following disclaimer.
   9  *  * Redistributions in binary form must reproduce the above copyright notice,
  10  *    this list of conditions and the following disclaimer in the documentation
  11  *    and/or other materials provided with the distribution.
  12  *  * Neither the name of Intel Corporation nor the names of its contributors
  13  *    may be used to endorse or promote products derived from this software
  14  *    without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include "pt_packet_decoder.h"
  30 #include "pt_decoder_function.h"
  31 #include "pt_packet.h"
  32 #include "pt_sync.h"
  33 #include "pt_config.h"
  34 #include "pt_opcodes.h"
  35
  36 #include <string.h>
  37 #include <stdlib.h>
  38
  39
  40 int pt_pkt_decoder_init(struct pt_packet_decoder *decoder,
  41                         const struct pt_config *config)
  42 {
  43         int errcode;
  44
  45         if (!decoder || !config)
  46                 return -pte_invalid;
  47
  48         memset(decoder, 0, sizeof(*decoder));
  49
  50         errcode = pt_config_from_user(&decoder->config, config);
  51         if (errcode < 0)
  52                 return errcode;
  53
  54         return 0;
  55 }
  56
  57 struct pt_packet_decoder *pt_pkt_alloc_decoder(const struct pt_config *config)
  58 {
  59         struct pt_packet_decoder *decoder;
  60         int errcode;
  61
  62         decoder = malloc(sizeof(*decoder));
  63         if (!decoder)
  64                 return NULL;
  65
  66         errcode = pt_pkt_decoder_init(decoder, config);
  67         if (errcode < 0) {
  68                 free(decoder);
  69                 return NULL;
  70         }
  71
  72         return decoder;
  73 }
  74
  75 void pt_pkt_decoder_fini(struct pt_packet_decoder *decoder)
  76 {
  77         (void) decoder;
  78
  79         /* Nothing to do. */
  80 }
  81
  82 void pt_pkt_free_decoder(struct pt_packet_decoder *decoder)
  83 {
  84         pt_pkt_decoder_fini(decoder);
  85         free(decoder);
  86 }
  87
  88 int pt_pkt_sync_forward(struct pt_packet_decoder *decoder)
  89 {
  90         const uint8_t *pos, *sync;
  91         int errcode;
  92
  93         if (!decoder)
  94                 return -pte_invalid;
  95
  96         sync = decoder->sync;
  97         pos = decoder->pos;
  98         if (!pos)
  99                 pos = decoder->config.begin;
 100
 101         if (pos == sync)
 102                 pos += ptps_psb;
 103
 104         errcode = pt_sync_forward(&sync, pos, &decoder->config);
 105         if (errcode < 0)
 106                 return errcode;
 107
 108         decoder->sync = sync;
 109         decoder->pos = sync;
 110
 111         return 0;
 112 }
 113
 114 int pt_pkt_sync_backward(struct pt_packet_decoder *decoder)
 115 {
 116         const uint8_t *pos, *sync;
 117         int errcode;
 118
 119         if (!decoder)
 120                 return -pte_invalid;
 121
 122         pos = decoder->pos;
 123         if (!pos)
 124                 pos = decoder->config.end;
 125
 126         errcode = pt_sync_backward(&sync, pos, &decoder->config);
 127         if (errcode < 0)
 128                 return errcode;
 129
 130         decoder->sync = sync;
 131         decoder->pos = sync;
 132
 133         return 0;
 134 }
 135
 136 int pt_pkt_sync_set(struct pt_packet_decoder *decoder, uint64_t offset)
 137 {
 138         const uint8_t *begin, *end, *pos;
 139
 140         if (!decoder)
 141                 return -pte_invalid;
 142
 143         begin = decoder->config.begin;
 144         end = decoder->config.end;
 145         pos = begin + offset;
 146
 147         if (end < pos || pos < begin)
 148                 return -pte_eos;
 149
 150         decoder->sync = pos;
 151         decoder->pos = pos;
 152
 153         return 0;
 154 }
 155
 156 int pt_pkt_get_offset(const struct pt_packet_decoder *decoder, uint64_t *offset)
 157 {
 158         const uint8_t *begin, *pos;
 159
 160         if (!decoder || !offset)
 161                 return -pte_invalid;
 162
 163         begin = decoder->config.begin;
 164         pos = decoder->pos;
 165
 166         if (!pos)
 167                 return -pte_nosync;
 168
 169         *offset = pos - begin;
 170         return 0;
 171 }
 172
 173 int pt_pkt_get_sync_offset(const struct pt_packet_decoder *decoder,
 174                            uint64_t *offset)
 175 {
 176         const uint8_t *begin, *sync;
 177
 178         if (!decoder || !offset)
 179                 return -pte_invalid;
 180
 181         begin = decoder->config.begin;
 182         sync = decoder->sync;
 183
 184         if (!sync)
 185                 return -pte_nosync;
 186
 187         *offset = sync - begin;
 188         return 0;
 189 }
 190
 191 const struct pt_config *
 192 pt_pkt_get_config(const struct pt_packet_decoder *decoder)
 193 {
 194         if (!decoder)
 195                 return NULL;
 196
 197         return &decoder->config;
 198 }
 199
 200 static inline int pkt_to_user(struct pt_packet *upkt, size_t size,
 201                               const struct pt_packet *pkt)
 202 {
 203         if (!upkt || !pkt)
 204                 return -pte_internal;
 205
 206         if (upkt == pkt)
 207                 return 0;
 208
 209         /* Zero out any unknown bytes. */
 210         if (sizeof(*pkt) < size) {
 211                 memset(upkt + sizeof(*pkt), 0, size - sizeof(*pkt));
 212
 213                 size = sizeof(*pkt);
 214         }
 215
 216         memcpy(upkt, pkt, size);
 217
 218         return 0;
 219 }
 220
 221 int pt_pkt_next(struct pt_packet_decoder *decoder, struct pt_packet *packet,
 222                 size_t psize)
 223 {
 224         const struct pt_decoder_function *dfun;
 225         struct pt_packet pkt, *ppkt;
 226         int errcode, size;
 227
 228         if (!packet || !decoder)
 229                 return -pte_invalid;
 230
 231         ppkt = psize == sizeof(pkt) ? packet : &pkt;
 232
 233         errcode = pt_df_fetch(&dfun, decoder->pos, &decoder->config);
 234         if (errcode < 0)
 235                 return errcode;
 236
 237         if (!dfun)
 238                 return -pte_internal;
 239
 240         if (!dfun->packet)
 241                 return -pte_internal;
 242
 243         size = dfun->packet(decoder, ppkt);
 244         if (size < 0)
 245                 return size;
 246
 247         errcode = pkt_to_user(packet, psize, ppkt);
 248         if (errcode < 0)
 249                 return errcode;
 250
 251         decoder->pos += size;
 252
 253         return size;
 254 }
 255
 256 int pt_pkt_decode_unknown(struct pt_packet_decoder *decoder,
 257                           struct pt_packet *packet)
 258 {
 259         int size;
 260
 261         if (!decoder)
 262                 return -pte_internal;
 263
 264         size = pt_pkt_read_unknown(packet, decoder->pos, &decoder->config);
 265         if (size < 0)
 266                 return size;
 267
 268         return size;
 269 }
 270
 271 int pt_pkt_decode_pad(struct pt_packet_decoder *decoder,
 272                       struct pt_packet *packet)
 273 {
 274         (void) decoder;
 275
 276         if (!packet)
 277                 return -pte_internal;
 278
 279         packet->type = ppt_pad;
 280         packet->size = ptps_pad;
 281
 282         return ptps_pad;
 283 }
 284
 285 int pt_pkt_decode_psb(struct pt_packet_decoder *decoder,
 286                       struct pt_packet *packet)
 287 {
 288         int size;
 289
 290         if (!decoder)
 291                 return -pte_internal;
 292
 293         size = pt_pkt_read_psb(decoder->pos, &decoder->config);
 294         if (size < 0)
 295                 return size;
 296
 297         packet->type = ppt_psb;
 298         packet->size = (uint8_t) size;
 299
 300         return size;
 301 }
 302
 303 int pt_pkt_decode_tip(struct pt_packet_decoder *decoder,
 304                       struct pt_packet *packet)
 305 {
 306         int size;
 307
 308         if (!decoder || !packet)
 309                 return -pte_internal;
 310
 311         size = pt_pkt_read_ip(&packet->payload.ip, decoder->pos,
 312                               &decoder->config);
 313         if (size < 0)
 314                 return size;
 315
 316         packet->type = ppt_tip;
 317         packet->size = (uint8_t) size;
 318
 319         return size;
 320 }
 321
 322 int pt_pkt_decode_tnt_8(struct pt_packet_decoder *decoder,
 323                         struct pt_packet *packet)
 324 {
 325         int size;
 326
 327         if (!decoder || !packet)
 328                 return -pte_internal;
 329
 330         size = pt_pkt_read_tnt_8(&packet->payload.tnt, decoder->pos,
 331                                  &decoder->config);
 332         if (size < 0)
 333                 return size;
 334
 335         packet->type = ppt_tnt_8;
 336         packet->size = (uint8_t) size;
 337
 338         return size;
 339 }
 340
 341 int pt_pkt_decode_tnt_64(struct pt_packet_decoder *decoder,
 342                          struct pt_packet *packet)
 343 {
 344         int size;
 345
 346         if (!decoder || !packet)
 347                 return -pte_internal;
 348
 349         size = pt_pkt_read_tnt_64(&packet->payload.tnt, decoder->pos,
 350                                   &decoder->config);
 351         if (size < 0)
 352                 return size;
 353
 354         packet->type = ppt_tnt_64;
 355         packet->size = (uint8_t) size;
 356
 357         return size;
 358 }
 359
 360 int pt_pkt_decode_tip_pge(struct pt_packet_decoder *decoder,
 361                           struct pt_packet *packet)
 362 {
 363         int size;
 364
 365         if (!decoder || !packet)
 366                 return -pte_internal;
 367
 368         size = pt_pkt_read_ip(&packet->payload.ip, decoder->pos,
 369                               &decoder->config);
 370         if (size < 0)
 371                 return size;
 372
 373         packet->type = ppt_tip_pge;
 374         packet->size = (uint8_t) size;
 375
 376         return size;
 377 }
 378
 379 int pt_pkt_decode_tip_pgd(struct pt_packet_decoder *decoder,
 380                           struct pt_packet *packet)
 381 {
 382         int size;
 383
 384         if (!decoder || !packet)
 385                 return -pte_internal;
 386
 387         size = pt_pkt_read_ip(&packet->payload.ip, decoder->pos,
 388                               &decoder->config);
 389         if (size < 0)
 390                 return size;
 391
 392         packet->type = ppt_tip_pgd;
 393         packet->size = (uint8_t) size;
 394
 395         return size;
 396 }
 397
 398 int pt_pkt_decode_fup(struct pt_packet_decoder *decoder,
 399                       struct pt_packet *packet)
 400 {
 401         int size;
 402
 403         if (!decoder || !packet)
 404                 return -pte_internal;
 405
 406         size = pt_pkt_read_ip(&packet->payload.ip, decoder->pos,
 407                               &decoder->config);
 408         if (size < 0)
 409                 return size;
 410
 411         packet->type = ppt_fup;
 412         packet->size = (uint8_t) size;
 413
 414         return size;
 415 }
 416
 417 int pt_pkt_decode_pip(struct pt_packet_decoder *decoder,
 418                       struct pt_packet *packet)
 419 {
 420         int size;
 421
 422         if (!decoder || !packet)
 423                 return -pte_internal;
 424
 425         size = pt_pkt_read_pip(&packet->payload.pip, decoder->pos,
 426                                &decoder->config);
 427         if (size < 0)
 428                 return size;
 429
 430         packet->type = ppt_pip;
 431         packet->size = (uint8_t) size;
 432
 433         return size;
 434 }
 435
 436 int pt_pkt_decode_ovf(struct pt_packet_decoder *decoder,
 437                       struct pt_packet *packet)
 438 {
 439         (void) decoder;
 440
 441         if (!packet)
 442                 return -pte_internal;
 443
 444         packet->type = ppt_ovf;
 445         packet->size = ptps_ovf;
 446
 447         return ptps_ovf;
 448 }
 449
 450 int pt_pkt_decode_mode(struct pt_packet_decoder *decoder,
 451                        struct pt_packet *packet)
 452 {
 453         int size;
 454
 455         if (!decoder || !packet)
 456                 return -pte_internal;
 457
 458         size = pt_pkt_read_mode(&packet->payload.mode, decoder->pos,
 459                                 &decoder->config);
 460         if (size < 0)
 461                 return size;
 462
 463         packet->type = ppt_mode;
 464         packet->size = (uint8_t) size;
 465
 466         return size;
 467 }
 468
 469 int pt_pkt_decode_psbend(struct pt_packet_decoder *decoder,
 470                          struct pt_packet *packet)
 471 {
 472         (void) decoder;
 473
 474         if (!packet)
 475                 return -pte_internal;
 476
 477         packet->type = ppt_psbend;
 478         packet->size = ptps_psbend;
 479
 480         return ptps_psbend;
 481 }
 482
 483 int pt_pkt_decode_tsc(struct pt_packet_decoder *decoder,
 484                       struct pt_packet *packet)
 485 {
 486         int size;
 487
 488         if (!decoder || !packet)
 489                 return -pte_internal;
 490
 491         size = pt_pkt_read_tsc(&packet->payload.tsc, decoder->pos,
 492                                &decoder->config);
 493         if (size < 0)
 494                 return size;
 495
 496         packet->type = ppt_tsc;
 497         packet->size = (uint8_t) size;
 498
 499         return size;
 500 }
 501
 502 int pt_pkt_decode_cbr(struct pt_packet_decoder *decoder,
 503                       struct pt_packet *packet)
 504 {
 505         int size;
 506
 507         if (!decoder || !packet)
 508                 return -pte_internal;
 509
 510         size = pt_pkt_read_cbr(&packet->payload.cbr, decoder->pos,
 511                                &decoder->config);
 512         if (size < 0)
 513                 return size;
 514
 515         packet->type = ppt_cbr;
 516         packet->size = (uint8_t) size;
 517
 518         return size;
 519 }
 520
 521 int pt_pkt_decode_tma(struct pt_packet_decoder *decoder,
 522                       struct pt_packet *packet)
 523 {
 524         int size;
 525
 526         if (!decoder || !packet)
 527                 return -pte_internal;
 528
 529         size = pt_pkt_read_tma(&packet->payload.tma, decoder->pos,
 530                                &decoder->config);
 531         if (size < 0)
 532                 return size;
 533
 534         packet->type = ppt_tma;
 535         packet->size = (uint8_t) size;
 536
 537         return size;
 538 }
 539
 540 int pt_pkt_decode_mtc(struct pt_packet_decoder *decoder,
 541                       struct pt_packet *packet)
 542 {
 543         int size;
 544
 545         if (!decoder || !packet)
 546                 return -pte_internal;
 547
 548         size = pt_pkt_read_mtc(&packet->payload.mtc, decoder->pos,
 549                                &decoder->config);
 550         if (size < 0)
 551                 return size;
 552
 553         packet->type = ppt_mtc;
 554         packet->size = (uint8_t) size;
 555
 556         return size;
 557 }
 558
 559 int pt_pkt_decode_cyc(struct pt_packet_decoder *decoder,
 560                       struct pt_packet *packet)
 561 {
 562         int size;
 563
 564         if (!decoder || !packet)
 565                 return -pte_internal;
 566
 567         size = pt_pkt_read_cyc(&packet->payload.cyc, decoder->pos,
 568                                &decoder->config);
 569         if (size < 0)
 570                 return size;
 571
 572         packet->type = ppt_cyc;
 573         packet->size = (uint8_t) size;
 574
 575         return size;
 576 }
 577
 578 int pt_pkt_decode_stop(struct pt_packet_decoder *decoder,
 579                        struct pt_packet *packet)
 580 {
 581         (void) decoder;
 582
 583         if (!packet)
 584                 return -pte_internal;
 585
 586         packet->type = ppt_stop;
 587         packet->size = ptps_stop;
 588
 589         return ptps_stop;
 590 }
 591
 592 int pt_pkt_decode_vmcs(struct pt_packet_decoder *decoder,
 593                        struct pt_packet *packet)
 594 {
 595         int size;
 596
 597         if (!decoder || !packet)
 598                 return -pte_internal;
 599
 600         size = pt_pkt_read_vmcs(&packet->payload.vmcs, decoder->pos,
 601                                &decoder->config);
 602         if (size < 0)
 603                 return size;
 604
 605         packet->type = ppt_vmcs;
 606         packet->size = (uint8_t) size;
 607
 608         return size;
 609 }
 610
 611 int pt_pkt_decode_mnt(struct pt_packet_decoder *decoder,
 612                       struct pt_packet *packet)
 613 {
 614         int size;
 615
 616         if (!decoder || !packet)
 617                 return -pte_internal;
 618
 619         size = pt_pkt_read_mnt(&packet->payload.mnt, decoder->pos,
 620                                &decoder->config);
 621         if (size < 0)
 622                 return size;
 623
 624         packet->type = ppt_mnt;
 625         packet->size = (uint8_t) size;
 626
 627         return size;
 628 }
 629
 630 int pt_pkt_decode_exstop(struct pt_packet_decoder *decoder,
 631                          struct pt_packet *packet)
 632 {
 633         int size;
 634
 635         if (!decoder || !packet)
 636                 return -pte_internal;
 637
 638         size = pt_pkt_read_exstop(&packet->payload.exstop, decoder->pos,
 639                                   &decoder->config);
 640         if (size < 0)
 641                 return size;
 642
 643         packet->type = ppt_exstop;
 644         packet->size = (uint8_t) size;
 645
 646         return size;
 647 }
 648
 649 int pt_pkt_decode_mwait(struct pt_packet_decoder *decoder,
 650                         struct pt_packet *packet)
 651 {
 652         int size;
 653
 654         if (!decoder || !packet)
 655                 return -pte_internal;
 656
 657         size = pt_pkt_read_mwait(&packet->payload.mwait, decoder->pos,
 658                                  &decoder->config);
 659         if (size < 0)
 660                 return size;
 661
 662         packet->type = ppt_mwait;
 663         packet->size = (uint8_t) size;
 664
 665         return size;
 666 }
 667
 668 int pt_pkt_decode_pwre(struct pt_packet_decoder *decoder,
 669                        struct pt_packet *packet)
 670 {
 671         int size;
 672
 673         if (!decoder || !packet)
 674                 return -pte_internal;
 675
 676         size = pt_pkt_read_pwre(&packet->payload.pwre, decoder->pos,
 677                                 &decoder->config);
 678         if (size < 0)
 679                 return size;
 680
 681         packet->type = ppt_pwre;
 682         packet->size = (uint8_t) size;
 683
 684         return size;
 685 }
 686
 687 int pt_pkt_decode_pwrx(struct pt_packet_decoder *decoder,
 688                        struct pt_packet *packet)
 689 {
 690         int size;
 691
 692         if (!decoder || !packet)
 693                 return -pte_internal;
 694
 695         size = pt_pkt_read_pwrx(&packet->payload.pwrx, decoder->pos,
 696                                 &decoder->config);
 697         if (size < 0)
 698                 return size;
 699
 700         packet->type = ppt_pwrx;
 701         packet->size = (uint8_t) size;
 702
 703         return size;
 704 }
 705
 706 int pt_pkt_decode_ptw(struct pt_packet_decoder *decoder,
 707                       struct pt_packet *packet)
 708 {
 709         int size;
 710
 711         if (!decoder || !packet)
 712                 return -pte_internal;
 713
 714         size = pt_pkt_read_ptw(&packet->payload.ptw, decoder->pos,
 715                                &decoder->config);
 716         if (size < 0)
 717                 return size;
 718
 719         packet->type = ppt_ptw;
 720         packet->size = (uint8_t) size;
 721
 722         return size;
 723 }