1 /* 2 * Copyright (c) 2013-2019, 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 "ptunit.h" 30 31 #include "pt_last_ip.h" 32 #include "pt_decoder_function.h" 33 #include "pt_query_decoder.h" 34 #include "pt_encoder.h" 35 #include "pt_opcodes.h" 36 37 38 /* A query testing fixture. */ 39 40 struct ptu_decoder_fixture { 41 /* The test fixture initialization and finalization functions. */ 42 struct ptunit_result (*init)(struct ptu_decoder_fixture *); 43 struct ptunit_result (*fini)(struct ptu_decoder_fixture *); 44 45 /* Encode an optional header for the test to read over. */ 46 struct ptunit_result (*header)(struct ptu_decoder_fixture *); 47 48 /* The trace buffer. */ 49 uint8_t buffer[1024]; 50 51 /* The configuration under test. */ 52 struct pt_config config; 53 54 /* A encoder and query decoder for the above configuration. */ 55 struct pt_encoder encoder; 56 struct pt_query_decoder decoder; 57 58 /* For tracking last-ip in tests. */ 59 struct pt_last_ip last_ip; 60 }; 61 62 /* An invalid address. */ 63 static const uint64_t pt_dfix_bad_ip = (1ull << 62) - 1ull; 64 65 /* A sign-extended address. */ 66 static const uint64_t pt_dfix_sext_ip = 0xffffff00ff00ff00ull; 67 68 /* The highest possible address. */ 69 static const uint64_t pt_dfix_max_ip = (1ull << 47) - 1ull; 70 71 /* The highest possible cr3 value. */ 72 static const uint64_t pt_dfix_max_cr3 = ((1ull << 47) - 1ull) & ~0x1full; 73 74 /* Synchronize the decoder at the beginning of the trace stream, avoiding the 75 * initial PSB header. 76 */ 77 static struct ptunit_result ptu_sync_decoder(struct pt_query_decoder *decoder) 78 { 79 ptu_ptr(decoder); 80 decoder->enabled = 1; 81 82 (void) pt_df_fetch(&decoder->next, decoder->pos, &decoder->config); 83 return ptu_passed(); 84 } 85 86 /* Cut off the last encoded packet. */ 87 static struct ptunit_result cutoff(struct pt_query_decoder *decoder, 88 const struct pt_encoder *encoder) 89 { 90 uint8_t *pos; 91 92 ptu_ptr(decoder); 93 ptu_ptr(encoder); 94 95 pos = encoder->pos; 96 ptu_ptr(pos); 97 98 pos -= 1; 99 ptu_ptr_le(decoder->config.begin, pos); 100 101 decoder->config.end = pos; 102 return ptu_passed(); 103 } 104 105 static struct ptunit_result indir_not_synced(struct ptu_decoder_fixture *dfix) 106 { 107 struct pt_query_decoder *decoder = &dfix->decoder; 108 uint64_t ip = pt_dfix_bad_ip, addr = ip; 109 int errcode; 110 111 errcode = pt_qry_indirect_branch(decoder, &addr); 112 ptu_int_eq(errcode, -pte_nosync); 113 ptu_uint_eq(addr, ip); 114 115 return ptu_passed(); 116 } 117 118 static struct ptunit_result cond_not_synced(struct ptu_decoder_fixture *dfix) 119 { 120 struct pt_query_decoder *decoder = &dfix->decoder; 121 int errcode, tnt = 0xbc, taken = tnt; 122 123 errcode = pt_qry_cond_branch(decoder, &taken); 124 ptu_int_eq(errcode, -pte_nosync); 125 ptu_int_eq(taken, tnt); 126 127 return ptu_passed(); 128 } 129 130 static struct ptunit_result event_not_synced(struct ptu_decoder_fixture *dfix) 131 { 132 struct pt_query_decoder *decoder = &dfix->decoder; 133 struct pt_event event; 134 int errcode; 135 136 errcode = pt_qry_event(decoder, &event, sizeof(event)); 137 ptu_int_eq(errcode, -pte_nosync); 138 139 return ptu_passed(); 140 } 141 142 static struct ptunit_result sync_backward(struct ptu_decoder_fixture *dfix) 143 { 144 struct pt_query_decoder *decoder = &dfix->decoder; 145 struct pt_encoder *encoder = &dfix->encoder; 146 uint64_t sync[3], offset, ip; 147 int errcode; 148 149 /* Check that we can use repeated pt_qry_sync_backward() to iterate over 150 * synchronization points in backwards order. 151 */ 152 153 errcode = pt_enc_get_offset(encoder, &sync[0]); 154 ptu_int_ge(errcode, 0); 155 156 pt_encode_psb(encoder); 157 pt_encode_mode_exec(encoder, ptem_64bit); 158 pt_encode_psbend(encoder); 159 160 errcode = pt_enc_get_offset(encoder, &sync[1]); 161 ptu_int_ge(errcode, 0); 162 163 pt_encode_psb(encoder); 164 pt_encode_mode_exec(encoder, ptem_64bit); 165 pt_encode_psbend(encoder); 166 167 errcode = pt_enc_get_offset(encoder, &sync[2]); 168 ptu_int_ge(errcode, 0); 169 170 pt_encode_psb(encoder); 171 pt_encode_mode_exec(encoder, ptem_64bit); 172 pt_encode_psbend(encoder); 173 174 /* Synchronize repeatedly and check that we reach each PSB in the 175 * correct order. 176 */ 177 178 errcode = pt_qry_sync_backward(decoder, &ip); 179 ptu_int_ge(errcode, 0); 180 181 errcode = pt_qry_get_sync_offset(decoder, &offset); 182 ptu_int_eq(errcode, 0); 183 ptu_uint_eq(offset, sync[2]); 184 185 errcode = pt_qry_sync_backward(decoder, &ip); 186 ptu_int_ge(errcode, 0); 187 188 errcode = pt_qry_get_sync_offset(decoder, &offset); 189 ptu_int_eq(errcode, 0); 190 ptu_uint_eq(offset, sync[1]); 191 192 errcode = pt_qry_sync_backward(decoder, &ip); 193 ptu_int_ge(errcode, 0); 194 195 errcode = pt_qry_get_sync_offset(decoder, &offset); 196 ptu_int_eq(errcode, 0); 197 ptu_uint_eq(offset, sync[0]); 198 199 errcode = pt_qry_sync_backward(decoder, &ip); 200 ptu_int_eq(errcode, -pte_eos); 201 202 return ptu_passed(); 203 } 204 205 static struct ptunit_result 206 sync_backward_empty_end(struct ptu_decoder_fixture *dfix) 207 { 208 struct pt_query_decoder *decoder = &dfix->decoder; 209 struct pt_encoder *encoder = &dfix->encoder; 210 uint64_t sync[3], offset, ip; 211 int errcode; 212 213 /* Check that we can use repeated pt_qry_sync_backward() to iterate over 214 * synchronization points in backwards order. 215 * 216 * There's an empty PSB+ at the end. We skip it. 217 */ 218 219 errcode = pt_enc_get_offset(encoder, &sync[0]); 220 ptu_int_ge(errcode, 0); 221 222 pt_encode_psb(encoder); 223 pt_encode_mode_exec(encoder, ptem_64bit); 224 pt_encode_psbend(encoder); 225 226 errcode = pt_enc_get_offset(encoder, &sync[1]); 227 ptu_int_ge(errcode, 0); 228 229 pt_encode_psb(encoder); 230 pt_encode_mode_exec(encoder, ptem_64bit); 231 pt_encode_psbend(encoder); 232 233 errcode = pt_enc_get_offset(encoder, &sync[2]); 234 ptu_int_ge(errcode, 0); 235 236 pt_encode_psb(encoder); 237 pt_encode_psbend(encoder); 238 239 /* Synchronize repeatedly and check that we reach each PSB in the 240 * correct order. 241 */ 242 243 errcode = pt_qry_sync_backward(decoder, &ip); 244 ptu_int_ge(errcode, 0); 245 246 errcode = pt_qry_get_sync_offset(decoder, &offset); 247 ptu_int_eq(errcode, 0); 248 ptu_uint_eq(offset, sync[1]); 249 250 errcode = pt_qry_sync_backward(decoder, &ip); 251 ptu_int_ge(errcode, 0); 252 253 errcode = pt_qry_get_sync_offset(decoder, &offset); 254 ptu_int_eq(errcode, 0); 255 ptu_uint_eq(offset, sync[0]); 256 257 errcode = pt_qry_sync_backward(decoder, &ip); 258 ptu_int_eq(errcode, -pte_eos); 259 260 return ptu_passed(); 261 } 262 263 static struct ptunit_result 264 sync_backward_empty_mid(struct ptu_decoder_fixture *dfix) 265 { 266 struct pt_query_decoder *decoder = &dfix->decoder; 267 struct pt_encoder *encoder = &dfix->encoder; 268 uint64_t sync[3], offset, ip; 269 int errcode; 270 271 /* Check that we can use repeated pt_qry_sync_backward() to iterate over 272 * synchronization points in backwards order. 273 * 274 * There's an empty PSB+ in the middle. We skip it. 275 */ 276 277 errcode = pt_enc_get_offset(encoder, &sync[0]); 278 ptu_int_ge(errcode, 0); 279 280 pt_encode_psb(encoder); 281 pt_encode_mode_exec(encoder, ptem_64bit); 282 pt_encode_psbend(encoder); 283 284 errcode = pt_enc_get_offset(encoder, &sync[1]); 285 ptu_int_ge(errcode, 0); 286 287 pt_encode_psb(encoder); 288 pt_encode_psbend(encoder); 289 290 errcode = pt_enc_get_offset(encoder, &sync[2]); 291 ptu_int_ge(errcode, 0); 292 293 pt_encode_psb(encoder); 294 pt_encode_mode_exec(encoder, ptem_64bit); 295 pt_encode_psbend(encoder); 296 297 /* Synchronize repeatedly and check that we reach each PSB in the 298 * correct order. 299 */ 300 301 errcode = pt_qry_sync_backward(decoder, &ip); 302 ptu_int_ge(errcode, 0); 303 304 errcode = pt_qry_get_sync_offset(decoder, &offset); 305 ptu_int_eq(errcode, 0); 306 ptu_uint_eq(offset, sync[2]); 307 308 errcode = pt_qry_sync_backward(decoder, &ip); 309 ptu_int_ge(errcode, 0); 310 311 errcode = pt_qry_get_sync_offset(decoder, &offset); 312 ptu_int_eq(errcode, 0); 313 ptu_uint_eq(offset, sync[0]); 314 315 errcode = pt_qry_sync_backward(decoder, &ip); 316 ptu_int_eq(errcode, -pte_eos); 317 318 return ptu_passed(); 319 } 320 321 static struct ptunit_result 322 sync_backward_empty_begin(struct ptu_decoder_fixture *dfix) 323 { 324 struct pt_query_decoder *decoder = &dfix->decoder; 325 struct pt_encoder *encoder = &dfix->encoder; 326 uint64_t sync[3], offset, ip; 327 int errcode; 328 329 /* Check that we can use repeated pt_qry_sync_backward() to iterate over 330 * synchronization points in backwards order. 331 * 332 * There's an empty PSB+ at the beginning. We skip it. 333 */ 334 335 errcode = pt_enc_get_offset(encoder, &sync[0]); 336 ptu_int_ge(errcode, 0); 337 338 pt_encode_psb(encoder); 339 pt_encode_psbend(encoder); 340 341 errcode = pt_enc_get_offset(encoder, &sync[1]); 342 ptu_int_ge(errcode, 0); 343 344 pt_encode_psb(encoder); 345 pt_encode_mode_exec(encoder, ptem_64bit); 346 pt_encode_psbend(encoder); 347 348 errcode = pt_enc_get_offset(encoder, &sync[2]); 349 ptu_int_ge(errcode, 0); 350 351 pt_encode_psb(encoder); 352 pt_encode_mode_exec(encoder, ptem_64bit); 353 pt_encode_psbend(encoder); 354 355 /* Synchronize repeatedly and check that we reach each PSB in the 356 * correct order. 357 */ 358 359 errcode = pt_qry_sync_backward(decoder, &ip); 360 ptu_int_ge(errcode, 0); 361 362 errcode = pt_qry_get_sync_offset(decoder, &offset); 363 ptu_int_eq(errcode, 0); 364 ptu_uint_eq(offset, sync[2]); 365 366 errcode = pt_qry_sync_backward(decoder, &ip); 367 ptu_int_ge(errcode, 0); 368 369 errcode = pt_qry_get_sync_offset(decoder, &offset); 370 ptu_int_eq(errcode, 0); 371 ptu_uint_eq(offset, sync[1]); 372 373 errcode = pt_qry_sync_backward(decoder, &ip); 374 ptu_int_eq(errcode, -pte_eos); 375 376 return ptu_passed(); 377 } 378 379 static struct ptunit_result 380 decode_sync_backward(struct ptu_decoder_fixture *dfix) 381 { 382 struct pt_query_decoder *decoder = &dfix->decoder; 383 struct pt_encoder *encoder = &dfix->encoder; 384 struct pt_event event; 385 uint64_t sync[2], offset, ip; 386 int errcode; 387 388 /* Check that we can use sync_backward to re-sync at the current trace 389 * segment as well as to find the previous trace segment. 390 */ 391 392 errcode = pt_enc_get_offset(encoder, &sync[0]); 393 ptu_int_ge(errcode, 0); 394 395 pt_encode_psb(encoder); 396 pt_encode_mode_exec(encoder, ptem_64bit); 397 pt_encode_psbend(encoder); 398 399 errcode = pt_enc_get_offset(encoder, &sync[1]); 400 ptu_int_ge(errcode, 0); 401 402 pt_encode_psb(encoder); 403 pt_encode_mode_exec(encoder, ptem_64bit); 404 pt_encode_psbend(encoder); 405 406 407 errcode = pt_qry_sync_forward(decoder, &ip); 408 ptu_int_ge(errcode, 0); 409 410 errcode = pt_qry_get_sync_offset(decoder, &offset); 411 ptu_int_eq(errcode, 0); 412 ptu_uint_eq(offset, sync[0]); 413 414 errcode = pt_qry_event(decoder, &event, sizeof(event)); 415 ptu_int_ge(errcode, 0); 416 ptu_int_eq(event.type, ptev_exec_mode); 417 418 errcode = pt_qry_event(decoder, &event, sizeof(event)); 419 ptu_int_ge(errcode, 0); 420 ptu_int_eq(event.type, ptev_exec_mode); 421 422 errcode = pt_qry_sync_backward(decoder, &ip); 423 ptu_int_ge(errcode, 0); 424 425 errcode = pt_qry_get_sync_offset(decoder, &offset); 426 ptu_int_eq(errcode, 0); 427 ptu_uint_eq(offset, sync[1]); 428 429 errcode = pt_qry_sync_backward(decoder, &ip); 430 ptu_int_ge(errcode, 0); 431 432 errcode = pt_qry_get_sync_offset(decoder, &offset); 433 ptu_int_eq(errcode, 0); 434 ptu_uint_eq(offset, sync[0]); 435 436 errcode = pt_qry_sync_backward(decoder, &ip); 437 ptu_int_eq(errcode, -pte_eos); 438 439 return ptu_passed(); 440 } 441 442 static struct ptunit_result indir_null(struct ptu_decoder_fixture *dfix) 443 { 444 struct pt_query_decoder *decoder = &dfix->decoder; 445 struct pt_config *config = &decoder->config; 446 uint64_t ip = pt_dfix_bad_ip, addr = ip; 447 int errcode; 448 449 errcode = pt_qry_indirect_branch(NULL, &addr); 450 ptu_int_eq(errcode, -pte_invalid); 451 ptu_uint_eq(addr, ip); 452 453 errcode = pt_qry_indirect_branch(decoder, NULL); 454 ptu_int_eq(errcode, -pte_invalid); 455 ptu_ptr_eq(decoder->pos, config->begin); 456 457 return ptu_passed(); 458 } 459 460 static struct ptunit_result indir_empty(struct ptu_decoder_fixture *dfix) 461 { 462 struct pt_query_decoder *decoder = &dfix->decoder; 463 struct pt_config *config = &decoder->config; 464 uint64_t ip = pt_dfix_bad_ip, addr = ip; 465 int errcode; 466 467 decoder->pos = config->end; 468 469 errcode = pt_qry_indirect_branch(decoder, &addr); 470 ptu_int_eq(errcode, -pte_eos); 471 ptu_uint_eq(addr, ip); 472 473 return ptu_passed(); 474 } 475 476 static struct ptunit_result indir(struct ptu_decoder_fixture *dfix, 477 enum pt_ip_compression ipc) 478 { 479 struct pt_query_decoder *decoder = &dfix->decoder; 480 struct pt_encoder *encoder = &dfix->encoder; 481 struct pt_packet_ip packet; 482 uint64_t addr = pt_dfix_bad_ip; 483 int errcode; 484 485 packet.ipc = ipc; 486 packet.ip = pt_dfix_sext_ip; 487 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config); 488 489 pt_encode_tip(encoder, packet.ip, packet.ipc); 490 491 ptu_check(ptu_sync_decoder, decoder); 492 493 errcode = pt_qry_indirect_branch(decoder, &addr); 494 if (ipc == pt_ipc_suppressed) { 495 ptu_int_eq(errcode, pts_ip_suppressed | pts_eos); 496 ptu_uint_eq(addr, pt_dfix_bad_ip); 497 } else { 498 ptu_int_eq(errcode, pts_eos); 499 ptu_uint_eq(addr, dfix->last_ip.ip); 500 } 501 502 return ptu_passed(); 503 } 504 505 static struct ptunit_result indir_tnt(struct ptu_decoder_fixture *dfix, 506 enum pt_ip_compression ipc) 507 { 508 struct pt_query_decoder *decoder = &dfix->decoder; 509 struct pt_encoder *encoder = &dfix->encoder; 510 struct pt_packet_ip packet; 511 uint64_t addr = pt_dfix_bad_ip; 512 int errcode; 513 514 packet.ipc = ipc; 515 packet.ip = pt_dfix_sext_ip; 516 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config); 517 518 pt_encode_tnt_8(encoder, 0ull, 1); 519 pt_encode_tip(encoder, packet.ip, packet.ipc); 520 521 ptu_check(ptu_sync_decoder, decoder); 522 523 errcode = pt_qry_indirect_branch(decoder, &addr); 524 if (ipc == pt_ipc_suppressed) { 525 ptu_int_eq(errcode, pts_ip_suppressed); 526 ptu_uint_eq(addr, pt_dfix_bad_ip); 527 } else { 528 ptu_int_eq(errcode, 0); 529 ptu_uint_eq(addr, dfix->last_ip.ip); 530 } 531 532 return ptu_passed(); 533 } 534 535 static struct ptunit_result indir_cutoff_fail(struct ptu_decoder_fixture *dfix) 536 { 537 struct pt_query_decoder *decoder = &dfix->decoder; 538 struct pt_encoder *encoder = &dfix->encoder; 539 uint64_t ip = pt_dfix_bad_ip, addr = ip; 540 int errcode; 541 542 pt_encode_tip(encoder, 0, pt_ipc_sext_48); 543 544 ptu_check(cutoff, decoder, encoder); 545 ptu_check(ptu_sync_decoder, decoder); 546 547 errcode = pt_qry_indirect_branch(decoder, &addr); 548 ptu_int_eq(errcode, -pte_eos); 549 ptu_uint_eq(addr, ip); 550 551 return ptu_passed(); 552 } 553 554 static struct ptunit_result 555 indir_skip_tnt_fail(struct ptu_decoder_fixture *dfix) 556 { 557 struct pt_query_decoder *decoder = &dfix->decoder; 558 struct pt_encoder *encoder = &dfix->encoder; 559 uint64_t ip = pt_dfix_bad_ip, addr = ip; 560 int errcode; 561 562 pt_encode_tnt_8(encoder, 0, 1); 563 pt_encode_tnt_8(encoder, 0, 1); 564 pt_encode_tip(encoder, 0, pt_ipc_sext_48); 565 566 ptu_check(ptu_sync_decoder, decoder); 567 568 errcode = pt_qry_indirect_branch(decoder, &addr); 569 ptu_int_eq(errcode, -pte_bad_query); 570 ptu_uint_eq(addr, ip); 571 572 return ptu_passed(); 573 } 574 575 static struct ptunit_result 576 indir_skip_tip_pge_fail(struct ptu_decoder_fixture *dfix) 577 { 578 struct pt_query_decoder *decoder = &dfix->decoder; 579 struct pt_encoder *encoder = &dfix->encoder; 580 uint64_t ip = pt_dfix_bad_ip, addr = ip; 581 const uint8_t *pos; 582 int errcode; 583 584 pos = encoder->pos; 585 pt_encode_tip_pge(encoder, 0, pt_ipc_sext_48); 586 pt_encode_tip(encoder, 0, pt_ipc_sext_48); 587 588 ptu_check(ptu_sync_decoder, decoder); 589 590 errcode = pt_qry_indirect_branch(decoder, &addr); 591 ptu_int_eq(errcode, -pte_bad_query); 592 ptu_ptr_eq(decoder->pos, pos); 593 ptu_uint_eq(addr, ip); 594 595 return ptu_passed(); 596 } 597 598 static struct ptunit_result 599 indir_skip_tip_pgd_fail(struct ptu_decoder_fixture *dfix) 600 { 601 struct pt_query_decoder *decoder = &dfix->decoder; 602 struct pt_encoder *encoder = &dfix->encoder; 603 uint64_t ip = pt_dfix_bad_ip, addr = ip; 604 const uint8_t *pos; 605 int errcode; 606 607 pos = encoder->pos; 608 pt_encode_tip_pgd(encoder, 0, pt_ipc_sext_48); 609 pt_encode_tip(encoder, 0, pt_ipc_sext_48); 610 611 ptu_check(ptu_sync_decoder, decoder); 612 613 errcode = pt_qry_indirect_branch(decoder, &addr); 614 ptu_int_eq(errcode, -pte_bad_query); 615 ptu_ptr_eq(decoder->pos, pos); 616 ptu_uint_eq(addr, ip); 617 618 return ptu_passed(); 619 } 620 621 static struct ptunit_result 622 indir_skip_fup_tip_fail(struct ptu_decoder_fixture *dfix) 623 { 624 struct pt_query_decoder *decoder = &dfix->decoder; 625 struct pt_encoder *encoder = &dfix->encoder; 626 uint64_t ip = pt_dfix_bad_ip, addr = ip; 627 const uint8_t *pos; 628 int errcode; 629 630 pt_encode_fup(encoder, 0, pt_ipc_sext_48); 631 pos = encoder->pos; 632 pt_encode_tip(encoder, 0, pt_ipc_sext_48); 633 pt_encode_tip(encoder, 0, pt_ipc_sext_48); 634 635 ptu_check(ptu_sync_decoder, decoder); 636 637 errcode = pt_qry_indirect_branch(decoder, &addr); 638 ptu_int_eq(errcode, -pte_bad_query); 639 ptu_ptr_eq(decoder->pos, pos); 640 ptu_uint_eq(addr, ip); 641 642 return ptu_passed(); 643 } 644 645 static struct ptunit_result 646 indir_skip_fup_tip_pgd_fail(struct ptu_decoder_fixture *dfix) 647 { 648 struct pt_query_decoder *decoder = &dfix->decoder; 649 struct pt_encoder *encoder = &dfix->encoder; 650 uint64_t ip = pt_dfix_bad_ip, addr = ip; 651 const uint8_t *pos; 652 int errcode; 653 654 pt_encode_fup(encoder, 0, pt_ipc_sext_48); 655 pos = encoder->pos; 656 pt_encode_tip_pgd(encoder, 0, pt_ipc_sext_48); 657 pt_encode_tip(encoder, 0, pt_ipc_sext_48); 658 659 ptu_check(ptu_sync_decoder, decoder); 660 661 errcode = pt_qry_indirect_branch(decoder, &addr); 662 ptu_int_eq(errcode, -pte_bad_query); 663 ptu_ptr_eq(decoder->pos, pos); 664 ptu_uint_eq(addr, ip); 665 666 return ptu_passed(); 667 } 668 669 static struct ptunit_result cond_null(struct ptu_decoder_fixture *dfix) 670 { 671 struct pt_query_decoder *decoder = &dfix->decoder; 672 struct pt_config *config = &decoder->config; 673 int errcode, tnt = 0xbc, taken = tnt; 674 675 errcode = pt_qry_cond_branch(NULL, &taken); 676 ptu_int_eq(errcode, -pte_invalid); 677 ptu_int_eq(taken, tnt); 678 679 errcode = pt_qry_cond_branch(decoder, NULL); 680 ptu_int_eq(errcode, -pte_invalid); 681 ptu_ptr_eq(decoder->pos, config->begin); 682 683 return ptu_passed(); 684 } 685 686 static struct ptunit_result cond_empty(struct ptu_decoder_fixture *dfix) 687 { 688 struct pt_query_decoder *decoder = &dfix->decoder; 689 struct pt_config *config = &decoder->config; 690 int errcode, tnt = 0xbc, taken = tnt; 691 692 decoder->pos = config->end; 693 694 errcode = pt_qry_cond_branch(decoder, &taken); 695 ptu_int_eq(errcode, -pte_eos); 696 ptu_int_eq(taken, tnt); 697 698 return ptu_passed(); 699 } 700 701 static struct ptunit_result cond(struct ptu_decoder_fixture *dfix) 702 { 703 struct pt_query_decoder *decoder = &dfix->decoder; 704 struct pt_encoder *encoder = &dfix->encoder; 705 int errcode, tnt = 0xbc, taken = tnt; 706 707 pt_encode_tnt_8(encoder, 0x02, 3); 708 709 ptu_check(ptu_sync_decoder, decoder); 710 711 errcode = pt_qry_cond_branch(decoder, &taken); 712 ptu_int_eq(errcode, 0); 713 ptu_int_eq(taken, 0); 714 715 taken = tnt; 716 errcode = pt_qry_cond_branch(decoder, &taken); 717 ptu_int_eq(errcode, 0); 718 ptu_int_eq(taken, 1); 719 720 taken = tnt; 721 errcode = pt_qry_cond_branch(decoder, &taken); 722 ptu_int_eq(errcode, pts_eos); 723 ptu_int_eq(taken, 0); 724 725 taken = tnt; 726 errcode = pt_qry_cond_branch(decoder, &taken); 727 ptu_int_eq(errcode, -pte_eos); 728 ptu_int_eq(taken, tnt); 729 730 return ptu_passed(); 731 } 732 733 static struct ptunit_result cond_skip_tip_fail(struct ptu_decoder_fixture *dfix) 734 { 735 struct pt_query_decoder *decoder = &dfix->decoder; 736 struct pt_encoder *encoder = &dfix->encoder; 737 int errcode, tnt = 0xbc, taken = tnt; 738 const uint8_t *pos; 739 740 pos = encoder->pos; 741 pt_encode_tip(encoder, 0, pt_ipc_sext_48); 742 pt_encode_tnt_8(encoder, 0, 1); 743 744 ptu_check(ptu_sync_decoder, decoder); 745 746 errcode = pt_qry_cond_branch(decoder, &taken); 747 ptu_int_eq(errcode, -pte_bad_query); 748 ptu_ptr_eq(decoder->pos, pos); 749 ptu_int_eq(taken, tnt); 750 751 return ptu_passed(); 752 } 753 754 static struct ptunit_result 755 cond_skip_tip_pge_fail(struct ptu_decoder_fixture *dfix) 756 { 757 struct pt_query_decoder *decoder = &dfix->decoder; 758 struct pt_encoder *encoder = &dfix->encoder; 759 int errcode, tnt = 0xbc, taken = tnt; 760 const uint8_t *pos; 761 762 pos = encoder->pos; 763 pt_encode_tip_pge(encoder, 0, pt_ipc_sext_48); 764 pt_encode_tnt_8(encoder, 0, 1); 765 766 ptu_check(ptu_sync_decoder, decoder); 767 768 errcode = pt_qry_cond_branch(decoder, &taken); 769 ptu_int_eq(errcode, -pte_bad_query); 770 ptu_ptr_eq(decoder->pos, pos); 771 ptu_int_eq(taken, tnt); 772 773 return ptu_passed(); 774 } 775 776 static struct ptunit_result 777 cond_skip_tip_pgd_fail(struct ptu_decoder_fixture *dfix) 778 { 779 struct pt_query_decoder *decoder = &dfix->decoder; 780 struct pt_encoder *encoder = &dfix->encoder; 781 int errcode, tnt = 0xbc, taken = tnt; 782 const uint8_t *pos; 783 784 pos = encoder->pos; 785 pt_encode_tip_pgd(encoder, 0, pt_ipc_sext_48); 786 pt_encode_tnt_8(encoder, 0, 1); 787 788 ptu_check(ptu_sync_decoder, decoder); 789 790 errcode = pt_qry_cond_branch(decoder, &taken); 791 ptu_int_eq(errcode, -pte_bad_query); 792 ptu_ptr_eq(decoder->pos, pos); 793 ptu_int_eq(taken, tnt); 794 795 return ptu_passed(); 796 } 797 798 static struct ptunit_result 799 cond_skip_fup_tip_fail(struct ptu_decoder_fixture *dfix) 800 { 801 struct pt_query_decoder *decoder = &dfix->decoder; 802 struct pt_encoder *encoder = &dfix->encoder; 803 int errcode, tnt = 0xbc, taken = tnt; 804 const uint8_t *pos; 805 806 pt_encode_fup(encoder, 0, pt_ipc_sext_48); 807 pos = encoder->pos; 808 pt_encode_tip(encoder, 0, pt_ipc_sext_48); 809 pt_encode_tnt_8(encoder, 0, 1); 810 811 ptu_check(ptu_sync_decoder, decoder); 812 813 errcode = pt_qry_cond_branch(decoder, &taken); 814 ptu_int_eq(errcode, -pte_bad_query); 815 ptu_ptr_eq(decoder->pos, pos); 816 ptu_int_eq(taken, tnt); 817 818 return ptu_passed(); 819 } 820 821 static struct ptunit_result 822 cond_skip_fup_tip_pgd_fail(struct ptu_decoder_fixture *dfix) 823 { 824 struct pt_query_decoder *decoder = &dfix->decoder; 825 struct pt_encoder *encoder = &dfix->encoder; 826 int errcode, tnt = 0xbc, taken = tnt; 827 const uint8_t *pos; 828 829 pt_encode_fup(encoder, 0, pt_ipc_sext_48); 830 pos = encoder->pos; 831 pt_encode_tip_pgd(encoder, 0, pt_ipc_sext_48); 832 pt_encode_tnt_8(encoder, 0, 1); 833 834 ptu_check(ptu_sync_decoder, decoder); 835 836 errcode = pt_qry_cond_branch(decoder, &taken); 837 ptu_int_eq(errcode, -pte_bad_query); 838 ptu_ptr_eq(decoder->pos, pos); 839 ptu_int_eq(taken, tnt); 840 841 return ptu_passed(); 842 } 843 844 static struct ptunit_result event_null(struct ptu_decoder_fixture *dfix) 845 { 846 struct pt_query_decoder *decoder = &dfix->decoder; 847 struct pt_config *config = &decoder->config; 848 struct pt_event event; 849 int errcode; 850 851 errcode = pt_qry_event(NULL, &event, sizeof(event)); 852 ptu_int_eq(errcode, -pte_invalid); 853 854 errcode = pt_qry_event(decoder, NULL, sizeof(event)); 855 ptu_int_eq(errcode, -pte_invalid); 856 ptu_ptr_eq(decoder->pos, config->begin); 857 858 return ptu_passed(); 859 } 860 861 static struct ptunit_result event_bad_size(struct ptu_decoder_fixture *dfix) 862 { 863 struct pt_query_decoder *decoder = &dfix->decoder; 864 struct pt_event event; 865 int errcode; 866 867 errcode = pt_qry_event(decoder, &event, 4); 868 ptu_int_eq(errcode, -pte_invalid); 869 870 return ptu_passed(); 871 } 872 873 static struct ptunit_result event_small_size(struct ptu_decoder_fixture *dfix) 874 { 875 struct pt_query_decoder *decoder = &dfix->decoder; 876 struct pt_encoder *encoder = &dfix->encoder; 877 union { 878 struct pt_event event; 879 uint8_t buffer[41]; 880 } variant; 881 int errcode; 882 883 memset(variant.buffer, 0xcd, sizeof(variant.buffer)); 884 885 pt_encode_tip_pge(encoder, 0ull, pt_ipc_sext_48); 886 887 ptu_check(ptu_sync_decoder, decoder); 888 889 errcode = pt_qry_event(decoder, &variant.event, 40); 890 ptu_int_eq(errcode, pts_eos); 891 ptu_int_eq(variant.event.type, ptev_enabled); 892 ptu_uint_eq(variant.buffer[40], 0xcd); 893 894 return ptu_passed(); 895 } 896 897 static struct ptunit_result event_big_size(struct ptu_decoder_fixture *dfix) 898 { 899 struct pt_query_decoder *decoder = &dfix->decoder; 900 struct pt_encoder *encoder = &dfix->encoder; 901 union { 902 struct pt_event event; 903 uint8_t buffer[1024]; 904 } variant; 905 int errcode; 906 907 memset(variant.buffer, 0xcd, sizeof(variant.buffer)); 908 909 pt_encode_tip_pge(encoder, 0ull, pt_ipc_sext_48); 910 911 ptu_check(ptu_sync_decoder, decoder); 912 913 errcode = pt_qry_event(decoder, &variant.event, sizeof(variant.buffer)); 914 ptu_int_eq(errcode, pts_eos); 915 ptu_int_eq(variant.event.type, ptev_enabled); 916 ptu_uint_eq(variant.buffer[sizeof(variant.event)], 0xcd); 917 918 return ptu_passed(); 919 } 920 921 static struct ptunit_result event_empty(struct ptu_decoder_fixture *dfix) 922 { 923 struct pt_query_decoder *decoder = &dfix->decoder; 924 struct pt_config *config = &decoder->config; 925 struct pt_event event; 926 int errcode; 927 928 decoder->pos = config->end; 929 930 errcode = pt_qry_event(decoder, &event, sizeof(event)); 931 ptu_int_eq(errcode, -pte_eos); 932 933 return ptu_passed(); 934 } 935 936 static struct ptunit_result event_enabled(struct ptu_decoder_fixture *dfix, 937 enum pt_ip_compression ipc, 938 uint64_t tsc) 939 { 940 struct pt_query_decoder *decoder = &dfix->decoder; 941 struct pt_encoder *encoder = &dfix->encoder; 942 struct pt_packet_ip packet; 943 struct pt_event event; 944 int errcode; 945 946 packet.ipc = ipc; 947 packet.ip = pt_dfix_max_ip; 948 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config); 949 950 pt_encode_tip_pge(encoder, packet.ip, packet.ipc); 951 952 ptu_check(ptu_sync_decoder, decoder); 953 954 errcode = pt_qry_event(decoder, &event, sizeof(event)); 955 if (ipc == pt_ipc_suppressed) 956 ptu_int_eq(errcode, -pte_bad_packet); 957 else { 958 ptu_int_eq(errcode, pts_eos); 959 ptu_int_eq(event.type, ptev_enabled); 960 ptu_uint_eq(event.variant.enabled.ip, dfix->last_ip.ip); 961 962 if (!tsc) 963 ptu_int_eq(event.has_tsc, 0); 964 else { 965 ptu_int_eq(event.has_tsc, 1); 966 ptu_uint_eq(event.tsc, tsc); 967 } 968 } 969 970 return ptu_passed(); 971 } 972 973 static struct ptunit_result 974 event_enabled_cutoff_fail(struct ptu_decoder_fixture *dfix) 975 { 976 struct pt_query_decoder *decoder = &dfix->decoder; 977 struct pt_encoder *encoder = &dfix->encoder; 978 struct pt_event event; 979 int errcode; 980 981 pt_encode_tip_pge(encoder, 0, pt_ipc_sext_48); 982 983 ptu_check(cutoff, decoder, encoder); 984 ptu_check(ptu_sync_decoder, decoder); 985 986 errcode = pt_qry_event(decoder, &event, sizeof(event)); 987 ptu_int_eq(errcode, -pte_eos); 988 989 return ptu_passed(); 990 } 991 992 static struct ptunit_result event_disabled(struct ptu_decoder_fixture *dfix, 993 enum pt_ip_compression ipc, 994 uint64_t tsc) 995 { 996 struct pt_query_decoder *decoder = &dfix->decoder; 997 struct pt_encoder *encoder = &dfix->encoder; 998 struct pt_packet_ip packet; 999 struct pt_event event; 1000 int errcode; 1001 1002 packet.ipc = ipc; 1003 packet.ip = pt_dfix_sext_ip; 1004 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config); 1005 1006 pt_encode_tip_pgd(encoder, packet.ip, packet.ipc); 1007 1008 ptu_check(ptu_sync_decoder, decoder); 1009 1010 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1011 ptu_int_eq(errcode, pts_eos); 1012 if (ipc == pt_ipc_suppressed) 1013 ptu_uint_ne(event.ip_suppressed, 0); 1014 else { 1015 ptu_uint_eq(event.ip_suppressed, 0); 1016 ptu_uint_eq(event.variant.disabled.ip, dfix->last_ip.ip); 1017 } 1018 ptu_int_eq(event.type, ptev_disabled); 1019 1020 if (!tsc) 1021 ptu_int_eq(event.has_tsc, 0); 1022 else { 1023 ptu_int_eq(event.has_tsc, 1); 1024 ptu_uint_eq(event.tsc, tsc); 1025 } 1026 1027 return ptu_passed(); 1028 } 1029 1030 static struct ptunit_result 1031 event_disabled_cutoff_fail(struct ptu_decoder_fixture *dfix) 1032 { 1033 struct pt_query_decoder *decoder = &dfix->decoder; 1034 struct pt_encoder *encoder = &dfix->encoder; 1035 struct pt_event event; 1036 int errcode; 1037 1038 pt_encode_tip_pgd(encoder, 0, pt_ipc_update_32); 1039 1040 ptu_check(cutoff, decoder, encoder); 1041 ptu_check(ptu_sync_decoder, decoder); 1042 1043 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1044 ptu_int_eq(errcode, -pte_eos); 1045 1046 return ptu_passed(); 1047 } 1048 1049 static struct ptunit_result 1050 event_async_disabled(struct ptu_decoder_fixture *dfix, 1051 enum pt_ip_compression ipc, uint64_t tsc) 1052 { 1053 struct pt_query_decoder *decoder = &dfix->decoder; 1054 struct pt_encoder *encoder = &dfix->encoder; 1055 struct pt_packet_ip fup, tip; 1056 struct pt_event event; 1057 int errcode; 1058 1059 fup.ipc = pt_ipc_sext_48; 1060 fup.ip = pt_dfix_max_ip; 1061 pt_last_ip_update_ip(&dfix->last_ip, &fup, &dfix->config); 1062 1063 tip.ipc = ipc; 1064 tip.ip = pt_dfix_sext_ip; 1065 pt_last_ip_update_ip(&dfix->last_ip, &tip, &dfix->config); 1066 1067 pt_encode_fup(encoder, fup.ip, fup.ipc); 1068 pt_encode_tip_pgd(encoder, tip.ip, tip.ipc); 1069 1070 ptu_check(ptu_sync_decoder, decoder); 1071 1072 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1073 ptu_int_eq(errcode, pts_eos); 1074 if (ipc == pt_ipc_suppressed) 1075 ptu_uint_ne(event.ip_suppressed, 0); 1076 else { 1077 ptu_uint_eq(event.ip_suppressed, 0); 1078 ptu_uint_eq(event.variant.async_disabled.ip, dfix->last_ip.ip); 1079 } 1080 ptu_int_eq(event.type, ptev_async_disabled); 1081 ptu_uint_eq(event.variant.async_disabled.at, fup.ip); 1082 1083 if (!tsc) 1084 ptu_int_eq(event.has_tsc, 0); 1085 else { 1086 ptu_int_eq(event.has_tsc, 1); 1087 ptu_uint_eq(event.tsc, tsc); 1088 } 1089 1090 return ptu_passed(); 1091 } 1092 1093 static struct ptunit_result 1094 event_async_disabled_suppressed_fail(struct ptu_decoder_fixture *dfix) 1095 { 1096 struct pt_query_decoder *decoder = &dfix->decoder; 1097 struct pt_encoder *encoder = &dfix->encoder; 1098 struct pt_event event; 1099 int errcode; 1100 1101 pt_encode_fup(encoder, 0, pt_ipc_suppressed); 1102 pt_encode_tip_pgd(encoder, 0, pt_ipc_sext_48); 1103 1104 ptu_check(ptu_sync_decoder, decoder); 1105 1106 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1107 ptu_int_eq(errcode, -pte_ip_suppressed); 1108 1109 return ptu_passed(); 1110 } 1111 1112 static struct ptunit_result 1113 event_async_disabled_cutoff_fail_a(struct ptu_decoder_fixture *dfix) 1114 { 1115 struct pt_query_decoder *decoder = &dfix->decoder; 1116 struct pt_encoder *encoder = &dfix->encoder; 1117 struct pt_event event; 1118 uint64_t at = pt_dfix_sext_ip; 1119 int errcode; 1120 1121 pt_encode_fup(encoder, at, pt_ipc_sext_48); 1122 pt_encode_tip_pgd(encoder, 0, pt_ipc_update_16); 1123 1124 ptu_check(cutoff, decoder, encoder); 1125 ptu_check(ptu_sync_decoder, decoder); 1126 1127 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1128 ptu_int_eq(errcode, -pte_eos); 1129 1130 return ptu_passed(); 1131 } 1132 1133 static struct ptunit_result 1134 event_async_disabled_cutoff_fail_b(struct ptu_decoder_fixture *dfix) 1135 { 1136 struct pt_query_decoder *decoder = &dfix->decoder; 1137 struct pt_encoder *encoder = &dfix->encoder; 1138 struct pt_event event; 1139 int errcode; 1140 1141 pt_encode_fup(encoder, 0, pt_ipc_sext_48); 1142 1143 ptu_check(cutoff, decoder, encoder); 1144 ptu_check(ptu_sync_decoder, decoder); 1145 1146 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1147 ptu_int_eq(errcode, -pte_eos); 1148 1149 return ptu_passed(); 1150 } 1151 1152 static struct ptunit_result 1153 event_async_branch_suppressed_fail(struct ptu_decoder_fixture *dfix) 1154 { 1155 struct pt_query_decoder *decoder = &dfix->decoder; 1156 struct pt_encoder *encoder = &dfix->encoder; 1157 struct pt_event event; 1158 int errcode; 1159 1160 pt_encode_fup(encoder, 0, pt_ipc_suppressed); 1161 1162 ptu_check(ptu_sync_decoder, decoder); 1163 1164 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1165 ptu_int_eq(errcode, -pte_ip_suppressed); 1166 1167 return ptu_passed(); 1168 } 1169 1170 static struct ptunit_result event_async_branch(struct ptu_decoder_fixture *dfix, 1171 enum pt_ip_compression ipc, 1172 uint64_t tsc) 1173 { 1174 struct pt_query_decoder *decoder = &dfix->decoder; 1175 struct pt_encoder *encoder = &dfix->encoder; 1176 struct pt_packet_ip fup, tip; 1177 struct pt_event event; 1178 int errcode; 1179 1180 fup.ipc = pt_ipc_sext_48; 1181 fup.ip = pt_dfix_max_ip; 1182 pt_last_ip_update_ip(&dfix->last_ip, &fup, &dfix->config); 1183 1184 tip.ipc = ipc; 1185 tip.ip = pt_dfix_sext_ip; 1186 pt_last_ip_update_ip(&dfix->last_ip, &tip, &dfix->config); 1187 1188 pt_encode_fup(encoder, fup.ip, fup.ipc); 1189 pt_encode_tip(encoder, tip.ip, tip.ipc); 1190 1191 ptu_check(ptu_sync_decoder, decoder); 1192 1193 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1194 ptu_int_eq(errcode, pts_eos); 1195 if (ipc == pt_ipc_suppressed) 1196 ptu_uint_ne(event.ip_suppressed, 0); 1197 else { 1198 ptu_uint_eq(event.ip_suppressed, 0); 1199 ptu_uint_eq(event.variant.async_branch.to, dfix->last_ip.ip); 1200 } 1201 ptu_int_eq(event.type, ptev_async_branch); 1202 ptu_uint_eq(event.variant.async_branch.from, fup.ip); 1203 1204 if (!tsc) 1205 ptu_int_eq(event.has_tsc, 0); 1206 else { 1207 ptu_int_eq(event.has_tsc, 1); 1208 ptu_uint_eq(event.tsc, tsc); 1209 } 1210 1211 return ptu_passed(); 1212 } 1213 1214 static struct ptunit_result 1215 event_async_branch_cutoff_fail_a(struct ptu_decoder_fixture *dfix) 1216 { 1217 struct pt_query_decoder *decoder = &dfix->decoder; 1218 struct pt_encoder *encoder = &dfix->encoder; 1219 struct pt_event event; 1220 int errcode; 1221 1222 pt_encode_fup(encoder, 0, pt_ipc_sext_48); 1223 pt_encode_tip_pgd(encoder, 0, pt_ipc_update_16); 1224 1225 ptu_check(cutoff, decoder, encoder); 1226 ptu_check(ptu_sync_decoder, decoder); 1227 1228 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1229 ptu_int_eq(errcode, -pte_eos); 1230 1231 return ptu_passed(); 1232 } 1233 1234 static struct ptunit_result 1235 event_async_branch_cutoff_fail_b(struct ptu_decoder_fixture *dfix) 1236 { 1237 struct pt_query_decoder *decoder = &dfix->decoder; 1238 struct pt_encoder *encoder = &dfix->encoder; 1239 struct pt_event event; 1240 int errcode; 1241 1242 pt_encode_fup(encoder, 0, pt_ipc_sext_48); 1243 1244 ptu_check(cutoff, decoder, encoder); 1245 ptu_check(ptu_sync_decoder, decoder); 1246 1247 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1248 ptu_int_eq(errcode, -pte_eos); 1249 1250 return ptu_passed(); 1251 } 1252 1253 static struct ptunit_result event_paging(struct ptu_decoder_fixture *dfix, 1254 uint8_t flags, uint64_t tsc) 1255 { 1256 struct pt_query_decoder *decoder = &dfix->decoder; 1257 struct pt_encoder *encoder = &dfix->encoder; 1258 struct pt_event event; 1259 uint64_t cr3 = pt_dfix_max_cr3; 1260 int errcode; 1261 1262 pt_encode_pip(encoder, cr3, flags); 1263 1264 ptu_check(ptu_sync_decoder, decoder); 1265 1266 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1267 ptu_int_eq(errcode, pts_eos); 1268 ptu_int_eq(event.type, ptev_paging); 1269 ptu_uint_eq(event.variant.paging.cr3, cr3); 1270 ptu_uint_eq(event.variant.paging.non_root, (flags & pt_pl_pip_nr) != 0); 1271 1272 if (!tsc) 1273 ptu_int_eq(event.has_tsc, 0); 1274 else { 1275 ptu_int_eq(event.has_tsc, 1); 1276 ptu_uint_eq(event.tsc, tsc); 1277 } 1278 1279 return ptu_passed(); 1280 } 1281 1282 static struct ptunit_result 1283 event_paging_cutoff_fail(struct ptu_decoder_fixture *dfix) 1284 { 1285 struct pt_query_decoder *decoder = &dfix->decoder; 1286 struct pt_encoder *encoder = &dfix->encoder; 1287 struct pt_event event; 1288 int errcode; 1289 1290 pt_encode_pip(encoder, 0, 0); 1291 1292 ptu_check(cutoff, decoder, encoder); 1293 ptu_check(ptu_sync_decoder, decoder); 1294 1295 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1296 ptu_int_eq(errcode, -pte_eos); 1297 1298 return ptu_passed(); 1299 } 1300 1301 static struct ptunit_result 1302 event_async_paging(struct ptu_decoder_fixture *dfix, uint8_t flags, 1303 uint64_t tsc) 1304 { 1305 struct pt_query_decoder *decoder = &dfix->decoder; 1306 struct pt_encoder *encoder = &dfix->encoder; 1307 struct pt_event event; 1308 uint64_t to = pt_dfix_sext_ip, from = to & ~0xffffull; 1309 uint64_t cr3 = pt_dfix_max_cr3; 1310 int errcode; 1311 1312 pt_encode_fup(encoder, from, pt_ipc_sext_48); 1313 pt_encode_pip(encoder, cr3, flags); 1314 pt_encode_tip(encoder, to, pt_ipc_update_16); 1315 1316 ptu_check(ptu_sync_decoder, decoder); 1317 1318 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1319 ptu_int_eq(errcode, pts_event_pending); 1320 ptu_int_eq(event.type, ptev_async_branch); 1321 ptu_uint_eq(event.variant.async_branch.from, from); 1322 ptu_uint_eq(event.variant.async_branch.to, to); 1323 1324 if (!tsc) 1325 ptu_int_eq(event.has_tsc, 0); 1326 else { 1327 ptu_int_eq(event.has_tsc, 1); 1328 ptu_uint_eq(event.tsc, tsc); 1329 } 1330 1331 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1332 ptu_int_eq(errcode, pts_eos); 1333 ptu_int_eq(event.type, ptev_async_paging); 1334 ptu_uint_eq(event.variant.async_paging.cr3, cr3); 1335 ptu_uint_eq(event.variant.async_paging.non_root, 1336 (flags & pt_pl_pip_nr) != 0); 1337 ptu_uint_eq(event.variant.async_paging.ip, to); 1338 1339 if (!tsc) 1340 ptu_int_eq(event.has_tsc, 0); 1341 else { 1342 ptu_int_eq(event.has_tsc, 1); 1343 ptu_uint_eq(event.tsc, tsc); 1344 } 1345 1346 return ptu_passed(); 1347 } 1348 1349 static struct ptunit_result 1350 event_async_paging_suppressed(struct ptu_decoder_fixture *dfix, uint8_t flags, 1351 uint64_t tsc) 1352 { 1353 struct pt_query_decoder *decoder = &dfix->decoder; 1354 struct pt_encoder *encoder = &dfix->encoder; 1355 struct pt_event event; 1356 uint64_t from = pt_dfix_sext_ip, cr3 = pt_dfix_max_cr3; 1357 int errcode; 1358 1359 pt_encode_fup(encoder, from, pt_ipc_sext_48); 1360 pt_encode_pip(encoder, cr3, flags); 1361 pt_encode_tip(encoder, 0, pt_ipc_suppressed); 1362 1363 ptu_check(ptu_sync_decoder, decoder); 1364 1365 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1366 ptu_int_eq(errcode, pts_event_pending); 1367 ptu_uint_ne(event.ip_suppressed, 0); 1368 ptu_int_eq(event.type, ptev_async_branch); 1369 ptu_uint_eq(event.variant.async_branch.from, from); 1370 1371 if (!tsc) 1372 ptu_int_eq(event.has_tsc, 0); 1373 else { 1374 ptu_int_eq(event.has_tsc, 1); 1375 ptu_uint_eq(event.tsc, tsc); 1376 } 1377 1378 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1379 ptu_int_eq(errcode, pts_eos); 1380 ptu_uint_ne(event.ip_suppressed, 0); 1381 ptu_int_eq(event.type, ptev_async_paging); 1382 ptu_uint_eq(event.variant.async_paging.cr3, cr3); 1383 ptu_uint_eq(event.variant.async_paging.non_root, 1384 (flags & pt_pl_pip_nr) != 0); 1385 1386 if (!tsc) 1387 ptu_int_eq(event.has_tsc, 0); 1388 else { 1389 ptu_int_eq(event.has_tsc, 1); 1390 ptu_uint_eq(event.tsc, tsc); 1391 } 1392 1393 return ptu_passed(); 1394 } 1395 1396 static struct ptunit_result 1397 event_async_paging_cutoff_fail(struct ptu_decoder_fixture *dfix) 1398 { 1399 struct pt_query_decoder *decoder = &dfix->decoder; 1400 struct pt_encoder *encoder = &dfix->encoder; 1401 struct pt_event event; 1402 int errcode; 1403 1404 pt_encode_fup(encoder, 0, pt_ipc_sext_48); 1405 pt_encode_pip(encoder, 0, 0); 1406 1407 ptu_check(cutoff, decoder, encoder); 1408 ptu_check(ptu_sync_decoder, decoder); 1409 1410 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1411 ptu_int_eq(errcode, -pte_eos); 1412 1413 return ptu_passed(); 1414 } 1415 1416 static struct ptunit_result event_overflow_fup(struct ptu_decoder_fixture *dfix, 1417 enum pt_ip_compression ipc, 1418 uint64_t tsc) 1419 { 1420 struct pt_query_decoder *decoder = &dfix->decoder; 1421 struct pt_encoder *encoder = &dfix->encoder; 1422 struct pt_event event; 1423 struct pt_packet_ip packet; 1424 int errcode; 1425 1426 packet.ipc = ipc; 1427 packet.ip = 0xccull; 1428 1429 pt_last_ip_init(&dfix->last_ip); 1430 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config); 1431 1432 pt_encode_ovf(encoder); 1433 pt_encode_fup(encoder, packet.ip, packet.ipc); 1434 1435 ptu_check(ptu_sync_decoder, decoder); 1436 1437 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1438 switch (ipc) { 1439 case pt_ipc_suppressed: 1440 ptu_int_eq(errcode, -pte_noip); 1441 break; 1442 1443 case pt_ipc_update_16: 1444 case pt_ipc_update_32: 1445 case pt_ipc_update_48: 1446 case pt_ipc_sext_48: 1447 case pt_ipc_full: 1448 ptu_int_eq(errcode, pts_eos); 1449 ptu_int_eq(event.type, ptev_overflow); 1450 ptu_uint_eq(event.variant.overflow.ip, dfix->last_ip.ip); 1451 1452 if (!tsc) 1453 ptu_int_eq(event.has_tsc, 0); 1454 else { 1455 ptu_int_eq(event.has_tsc, 1); 1456 ptu_uint_eq(event.tsc, tsc); 1457 } 1458 break; 1459 } 1460 1461 return ptu_passed(); 1462 } 1463 1464 static struct ptunit_result 1465 event_overflow_tip_pge(struct ptu_decoder_fixture *dfix, 1466 enum pt_ip_compression ipc, uint64_t tsc) 1467 { 1468 struct pt_query_decoder *decoder = &dfix->decoder; 1469 struct pt_encoder *encoder = &dfix->encoder; 1470 struct pt_event event; 1471 struct pt_packet_ip packet; 1472 int errcode; 1473 1474 packet.ipc = ipc; 1475 packet.ip = 0xccull; 1476 1477 pt_last_ip_init(&dfix->last_ip); 1478 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config); 1479 1480 pt_encode_ovf(encoder); 1481 pt_encode_tip_pge(encoder, packet.ip, packet.ipc); 1482 1483 ptu_check(ptu_sync_decoder, decoder); 1484 1485 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1486 ptu_int_eq(errcode, pts_event_pending); 1487 ptu_int_eq(event.type, ptev_overflow); 1488 ptu_uint_ne(event.ip_suppressed, 0); 1489 1490 if (!tsc) 1491 ptu_int_eq(event.has_tsc, 0); 1492 else { 1493 ptu_int_eq(event.has_tsc, 1); 1494 ptu_uint_eq(event.tsc, tsc); 1495 } 1496 1497 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1498 switch (ipc) { 1499 case pt_ipc_suppressed: 1500 ptu_int_eq(errcode, -pte_bad_packet); 1501 break; 1502 1503 case pt_ipc_update_16: 1504 case pt_ipc_update_32: 1505 case pt_ipc_update_48: 1506 case pt_ipc_sext_48: 1507 case pt_ipc_full: 1508 ptu_int_eq(errcode, pts_eos); 1509 ptu_int_eq(event.type, ptev_enabled); 1510 ptu_uint_eq(event.variant.enabled.ip, dfix->last_ip.ip); 1511 1512 if (!tsc) 1513 ptu_int_eq(event.has_tsc, 0); 1514 else { 1515 ptu_int_eq(event.has_tsc, 1); 1516 ptu_uint_eq(event.tsc, tsc); 1517 } 1518 break; 1519 } 1520 1521 return ptu_passed(); 1522 } 1523 1524 static struct ptunit_result 1525 event_overflow_cutoff_fail(struct ptu_decoder_fixture *dfix) 1526 { 1527 struct pt_query_decoder *decoder = &dfix->decoder; 1528 struct pt_encoder *encoder = &dfix->encoder; 1529 struct pt_event event; 1530 int errcode; 1531 1532 pt_encode_ovf(encoder); 1533 1534 ptu_check(cutoff, decoder, encoder); 1535 ptu_check(ptu_sync_decoder, decoder); 1536 1537 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1538 ptu_int_eq(errcode, -pte_eos); 1539 1540 return ptu_passed(); 1541 } 1542 1543 static struct ptunit_result event_stop(struct ptu_decoder_fixture *dfix, 1544 uint64_t tsc) 1545 { 1546 struct pt_query_decoder *decoder = &dfix->decoder; 1547 struct pt_encoder *encoder = &dfix->encoder; 1548 struct pt_event event; 1549 int errcode; 1550 1551 pt_encode_stop(encoder); 1552 1553 ptu_sync_decoder(decoder); 1554 1555 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1556 ptu_int_eq(errcode, pts_eos); 1557 ptu_int_eq(event.type, ptev_stop); 1558 1559 if (!tsc) 1560 ptu_int_eq(event.has_tsc, 0); 1561 else { 1562 ptu_int_eq(event.has_tsc, 1); 1563 ptu_uint_eq(event.tsc, tsc); 1564 } 1565 1566 return ptu_passed(); 1567 } 1568 1569 static struct ptunit_result 1570 event_exec_mode_tip(struct ptu_decoder_fixture *dfix, 1571 enum pt_ip_compression ipc, uint64_t tsc) 1572 { 1573 struct pt_query_decoder *decoder = &dfix->decoder; 1574 struct pt_encoder *encoder = &dfix->encoder; 1575 enum pt_exec_mode mode = ptem_16bit; 1576 struct pt_packet_ip packet; 1577 struct pt_event event; 1578 uint64_t addr = 0ull; 1579 int errcode; 1580 1581 packet.ipc = ipc; 1582 packet.ip = pt_dfix_max_ip; 1583 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config); 1584 1585 pt_encode_mode_exec(encoder, mode); 1586 pt_encode_tip(encoder, packet.ip, packet.ipc); 1587 1588 ptu_check(ptu_sync_decoder, decoder); 1589 1590 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1591 ptu_int_eq(errcode, 0); 1592 if (ipc == pt_ipc_suppressed) 1593 ptu_uint_ne(event.ip_suppressed, 0); 1594 else { 1595 ptu_uint_eq(event.ip_suppressed, 0); 1596 ptu_uint_eq(event.variant.exec_mode.ip, dfix->last_ip.ip); 1597 } 1598 ptu_int_eq(event.type, ptev_exec_mode); 1599 ptu_int_eq(event.variant.exec_mode.mode, mode); 1600 1601 if (!tsc) 1602 ptu_int_eq(event.has_tsc, 0); 1603 else { 1604 ptu_int_eq(event.has_tsc, 1); 1605 ptu_uint_eq(event.tsc, tsc); 1606 } 1607 1608 errcode = pt_qry_indirect_branch(decoder, &addr); 1609 if (ipc == pt_ipc_suppressed) 1610 ptu_int_eq(errcode, pts_ip_suppressed | pts_eos); 1611 else { 1612 ptu_int_eq(errcode, pts_eos); 1613 ptu_uint_eq(addr, dfix->last_ip.ip); 1614 } 1615 1616 return ptu_passed(); 1617 } 1618 1619 static struct ptunit_result 1620 event_exec_mode_tip_cutoff_fail(struct ptu_decoder_fixture *dfix) 1621 { 1622 struct pt_query_decoder *decoder = &dfix->decoder; 1623 struct pt_encoder *encoder = &dfix->encoder; 1624 struct pt_event event; 1625 int errcode; 1626 1627 pt_encode_mode_exec(encoder, ptem_32bit); 1628 pt_encode_tip(encoder, 0, pt_ipc_update_16); 1629 1630 ptu_check(cutoff, decoder, encoder); 1631 ptu_check(ptu_sync_decoder, decoder); 1632 1633 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1634 ptu_int_eq(errcode, -pte_eos); 1635 1636 return ptu_passed(); 1637 } 1638 1639 static struct ptunit_result 1640 event_exec_mode_tip_pge(struct ptu_decoder_fixture *dfix, 1641 enum pt_ip_compression ipc, uint64_t tsc) 1642 { 1643 struct pt_query_decoder *decoder = &dfix->decoder; 1644 struct pt_encoder *encoder = &dfix->encoder; 1645 enum pt_exec_mode mode = ptem_16bit; 1646 struct pt_packet_ip packet; 1647 struct pt_event event; 1648 uint64_t addr = 0ull; 1649 int errcode; 1650 1651 packet.ipc = ipc; 1652 packet.ip = pt_dfix_max_ip; 1653 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config); 1654 1655 pt_encode_mode_exec(encoder, mode); 1656 pt_encode_tip_pge(encoder, packet.ip, packet.ipc); 1657 1658 ptu_check(ptu_sync_decoder, decoder); 1659 decoder->enabled = 0; 1660 1661 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1662 if (ipc == pt_ipc_suppressed) { 1663 ptu_int_eq(errcode, -pte_bad_packet); 1664 ptu_uint_eq(addr, 0ull); 1665 } else { 1666 ptu_int_eq(errcode, pts_event_pending); 1667 ptu_int_eq(event.type, ptev_enabled); 1668 ptu_uint_eq(event.variant.enabled.ip, dfix->last_ip.ip); 1669 1670 if (!tsc) 1671 ptu_int_eq(event.has_tsc, 0); 1672 else { 1673 ptu_int_eq(event.has_tsc, 1); 1674 ptu_uint_eq(event.tsc, tsc); 1675 } 1676 1677 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1678 ptu_int_eq(errcode, pts_eos); 1679 ptu_int_eq(event.type, ptev_exec_mode); 1680 ptu_int_eq(event.variant.exec_mode.mode, mode); 1681 ptu_uint_eq(event.variant.exec_mode.ip, dfix->last_ip.ip); 1682 1683 if (!tsc) 1684 ptu_int_eq(event.has_tsc, 0); 1685 else { 1686 ptu_int_eq(event.has_tsc, 1); 1687 ptu_uint_eq(event.tsc, tsc); 1688 } 1689 } 1690 1691 return ptu_passed(); 1692 } 1693 1694 static struct ptunit_result 1695 event_exec_mode_tip_pge_cutoff_fail(struct ptu_decoder_fixture *dfix) 1696 { 1697 struct pt_query_decoder *decoder = &dfix->decoder; 1698 struct pt_encoder *encoder = &dfix->encoder; 1699 struct pt_event event; 1700 int errcode; 1701 1702 pt_encode_mode_exec(encoder, ptem_16bit); 1703 pt_encode_tip_pge(encoder, 0, pt_ipc_sext_48); 1704 1705 ptu_check(cutoff, decoder, encoder); 1706 ptu_check(ptu_sync_decoder, decoder); 1707 1708 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1709 ptu_int_eq(errcode, -pte_eos); 1710 1711 return ptu_passed(); 1712 } 1713 1714 static struct ptunit_result 1715 event_exec_mode_cutoff_fail(struct ptu_decoder_fixture *dfix) 1716 { 1717 struct pt_query_decoder *decoder = &dfix->decoder; 1718 struct pt_encoder *encoder = &dfix->encoder; 1719 struct pt_event event; 1720 int errcode; 1721 1722 pt_encode_mode_exec(encoder, ptem_64bit); 1723 1724 ptu_check(cutoff, decoder, encoder); 1725 ptu_check(ptu_sync_decoder, decoder); 1726 1727 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1728 ptu_int_eq(errcode, -pte_eos); 1729 1730 return ptu_passed(); 1731 } 1732 1733 static struct ptunit_result event_tsx_fup(struct ptu_decoder_fixture *dfix, 1734 enum pt_ip_compression ipc, 1735 uint8_t flags, uint64_t tsc) 1736 { 1737 struct pt_query_decoder *decoder = &dfix->decoder; 1738 struct pt_encoder *encoder = &dfix->encoder; 1739 struct pt_packet_ip fup, tip; 1740 struct pt_event event; 1741 uint64_t addr = 0; 1742 int errcode; 1743 1744 fup.ipc = ipc; 1745 fup.ip = pt_dfix_max_ip; 1746 pt_last_ip_update_ip(&dfix->last_ip, &fup, &dfix->config); 1747 1748 tip.ipc = pt_ipc_sext_48; 1749 tip.ip = pt_dfix_sext_ip; 1750 1751 pt_encode_mode_tsx(encoder, flags); 1752 pt_encode_fup(encoder, fup.ip, fup.ipc); 1753 pt_encode_tip(encoder, tip.ip, tip.ipc); 1754 1755 ptu_check(ptu_sync_decoder, decoder); 1756 1757 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1758 ptu_int_eq(errcode, 0); 1759 if (ipc == pt_ipc_suppressed) 1760 ptu_uint_ne(event.ip_suppressed, 0); 1761 else { 1762 ptu_uint_eq(event.ip_suppressed, 0); 1763 ptu_uint_eq(event.variant.tsx.ip, dfix->last_ip.ip); 1764 } 1765 ptu_int_eq(event.type, ptev_tsx); 1766 ptu_int_eq(event.variant.tsx.speculative, 1767 (flags & pt_mob_tsx_intx) != 0); 1768 ptu_int_eq(event.variant.tsx.aborted, 1769 (flags & pt_mob_tsx_abrt) != 0); 1770 1771 if (!tsc) 1772 ptu_int_eq(event.has_tsc, 0); 1773 else { 1774 ptu_int_eq(event.has_tsc, 1); 1775 ptu_uint_eq(event.tsc, tsc); 1776 } 1777 1778 errcode = pt_qry_indirect_branch(decoder, &addr); 1779 ptu_int_eq(errcode, pts_eos); 1780 ptu_uint_eq(addr, tip.ip); 1781 1782 return ptu_passed(); 1783 } 1784 1785 static struct ptunit_result 1786 event_tsx_fup_cutoff_fail(struct ptu_decoder_fixture *dfix) 1787 { 1788 struct pt_query_decoder *decoder = &dfix->decoder; 1789 struct pt_encoder *encoder = &dfix->encoder; 1790 struct pt_event event; 1791 int errcode; 1792 1793 pt_encode_mode_tsx(encoder, 0); 1794 pt_encode_fup(encoder, 0, pt_ipc_update_16); 1795 1796 ptu_check(cutoff, decoder, encoder); 1797 ptu_check(ptu_sync_decoder, decoder); 1798 1799 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1800 ptu_int_eq(errcode, -pte_eos); 1801 1802 return ptu_passed(); 1803 } 1804 1805 static struct ptunit_result 1806 event_tsx_cutoff_fail(struct ptu_decoder_fixture *dfix) 1807 { 1808 struct pt_query_decoder *decoder = &dfix->decoder; 1809 struct pt_encoder *encoder = &dfix->encoder; 1810 struct pt_event event; 1811 int errcode; 1812 1813 pt_encode_mode_tsx(encoder, 0); 1814 1815 ptu_check(cutoff, decoder, encoder); 1816 ptu_check(ptu_sync_decoder, decoder); 1817 1818 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1819 ptu_int_eq(errcode, -pte_eos); 1820 1821 return ptu_passed(); 1822 } 1823 1824 static struct ptunit_result 1825 event_skip_tip_fail(struct ptu_decoder_fixture *dfix) 1826 { 1827 struct pt_query_decoder *decoder = &dfix->decoder; 1828 struct pt_encoder *encoder = &dfix->encoder; 1829 struct pt_event event; 1830 const uint8_t *pos; 1831 int errcode; 1832 1833 pos = encoder->pos; 1834 pt_encode_tip(encoder, 0, pt_ipc_sext_48); 1835 /* We omit the actual event - we don't get that far, anyway. */ 1836 1837 ptu_check(ptu_sync_decoder, decoder); 1838 1839 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1840 ptu_int_eq(errcode, -pte_bad_query); 1841 ptu_ptr_eq(decoder->pos, pos); 1842 1843 return ptu_passed(); 1844 } 1845 1846 static struct ptunit_result 1847 event_skip_tnt_8_fail(struct ptu_decoder_fixture *dfix) 1848 { 1849 struct pt_query_decoder *decoder = &dfix->decoder; 1850 struct pt_encoder *encoder = &dfix->encoder; 1851 struct pt_event event; 1852 int errcode; 1853 1854 pt_encode_tnt_8(encoder, 0, 1); 1855 pt_encode_tnt_8(encoder, 0, 1); 1856 /* We omit the actual event - we don't get that far, anyway. */ 1857 1858 ptu_check(ptu_sync_decoder, decoder); 1859 1860 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1861 ptu_int_eq(errcode, -pte_bad_query); 1862 /* The fail position depends on the fixture's header. */ 1863 1864 return ptu_passed(); 1865 } 1866 1867 static struct ptunit_result 1868 event_skip_tnt_64_fail(struct ptu_decoder_fixture *dfix) 1869 { 1870 struct pt_query_decoder *decoder = &dfix->decoder; 1871 struct pt_encoder *encoder = &dfix->encoder; 1872 struct pt_event event; 1873 int errcode; 1874 1875 pt_encode_tnt_64(encoder, 0, 1); 1876 pt_encode_tnt_64(encoder, 0, 1); 1877 /* We omit the actual event - we don't get that far, anyway. */ 1878 1879 ptu_check(ptu_sync_decoder, decoder); 1880 1881 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1882 ptu_int_eq(errcode, -pte_bad_query); 1883 /* The fail position depends on the fixture's header. */ 1884 1885 return ptu_passed(); 1886 } 1887 1888 static struct ptunit_result sync_event(struct ptu_decoder_fixture *dfix, 1889 enum pt_ip_compression ipc) 1890 { 1891 struct pt_query_decoder *decoder = &dfix->decoder; 1892 struct pt_encoder *encoder = &dfix->encoder; 1893 struct pt_packet_ip packet; 1894 struct pt_event event; 1895 uint64_t addr = 0ull; 1896 int errcode; 1897 1898 packet.ipc = ipc; 1899 packet.ip = 0xccull; 1900 1901 pt_last_ip_init(&dfix->last_ip); 1902 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config); 1903 1904 pt_encode_psb(encoder); 1905 pt_encode_mode_tsx(encoder, pt_mob_tsx_intx); 1906 pt_encode_fup(encoder, packet.ip, packet.ipc); 1907 pt_encode_psbend(encoder); 1908 1909 errcode = pt_qry_sync_forward(decoder, &addr); 1910 switch (ipc) { 1911 case pt_ipc_suppressed: 1912 ptu_int_eq(errcode, (pts_event_pending | pts_ip_suppressed)); 1913 break; 1914 1915 case pt_ipc_update_16: 1916 case pt_ipc_update_32: 1917 case pt_ipc_update_48: 1918 case pt_ipc_sext_48: 1919 case pt_ipc_full: 1920 ptu_int_eq(errcode, pts_event_pending); 1921 ptu_uint_eq(addr, dfix->last_ip.ip); 1922 break; 1923 } 1924 1925 errcode = pt_qry_event(decoder, &event, sizeof(event)); 1926 ptu_int_eq(errcode, pts_eos); 1927 ptu_uint_ne(event.status_update, 0); 1928 if (ipc == pt_ipc_suppressed) 1929 ptu_uint_ne(event.ip_suppressed, 0); 1930 else { 1931 ptu_uint_eq(event.ip_suppressed, 0); 1932 ptu_uint_eq(event.variant.tsx.ip, dfix->last_ip.ip); 1933 } 1934 ptu_int_eq(event.type, ptev_tsx); 1935 ptu_int_eq(event.variant.tsx.speculative, 1); 1936 ptu_int_eq(event.variant.tsx.aborted, 0); 1937 ptu_int_eq(event.has_tsc, 0); 1938 1939 return ptu_passed(); 1940 } 1941 1942 static struct ptunit_result 1943 sync_event_cutoff_fail(struct ptu_decoder_fixture *dfix) 1944 { 1945 struct pt_query_decoder *decoder = &dfix->decoder; 1946 struct pt_encoder *encoder = &dfix->encoder; 1947 uint64_t addr; 1948 int errcode; 1949 1950 pt_encode_psb(encoder); 1951 pt_encode_psbend(encoder); 1952 1953 ptu_check(cutoff, decoder, encoder); 1954 1955 errcode = pt_qry_sync_forward(decoder, &addr); 1956 ptu_int_eq(errcode, -pte_eos); 1957 1958 return ptu_passed(); 1959 } 1960 1961 static struct ptunit_result 1962 sync_event_incomplete_fail(struct ptu_decoder_fixture *dfix) 1963 { 1964 struct pt_query_decoder *decoder = &dfix->decoder; 1965 struct pt_encoder *encoder = &dfix->encoder; 1966 uint64_t addr; 1967 int errcode; 1968 1969 pt_encode_psb(encoder); 1970 1971 errcode = pt_qry_sync_forward(decoder, &addr); 1972 ptu_int_eq(errcode, -pte_eos); 1973 1974 return ptu_passed(); 1975 } 1976 1977 static struct ptunit_result sync_ovf_event(struct ptu_decoder_fixture *dfix, 1978 enum pt_ip_compression ipc) 1979 { 1980 struct pt_query_decoder *decoder = &dfix->decoder; 1981 struct pt_encoder *encoder = &dfix->encoder; 1982 struct pt_packet_ip fup, ovf; 1983 struct pt_event event; 1984 uint64_t addr = 0; 1985 int errcode; 1986 1987 fup.ipc = pt_ipc_sext_48; 1988 fup.ip = pt_dfix_max_ip; 1989 1990 ovf.ipc = ipc; 1991 ovf.ip = 0xccull; 1992 1993 pt_last_ip_init(&dfix->last_ip); 1994 pt_last_ip_update_ip(&dfix->last_ip, &ovf, &dfix->config); 1995 1996 pt_encode_psb(encoder); 1997 pt_encode_fup(encoder, fup.ip, fup.ipc); 1998 pt_encode_mode_tsx(encoder, 0); 1999 pt_encode_tsc(encoder, 0x1000); 2000 pt_encode_ovf(encoder); 2001 pt_encode_fup(encoder, ovf.ip, ovf.ipc); 2002 2003 errcode = pt_qry_sync_forward(decoder, &addr); 2004 ptu_int_eq(errcode, pts_event_pending); 2005 ptu_uint_eq(addr, fup.ip); 2006 2007 errcode = pt_qry_event(decoder, &event, sizeof(event)); 2008 ptu_int_eq(errcode, pts_event_pending); 2009 ptu_uint_ne(event.status_update, 0); 2010 ptu_int_eq(event.type, ptev_tsx); 2011 ptu_int_eq(event.variant.tsx.speculative, 0); 2012 ptu_int_eq(event.variant.tsx.aborted, 0); 2013 ptu_uint_eq(event.variant.tsx.ip, fup.ip); 2014 ptu_int_eq(event.has_tsc, 1); 2015 ptu_uint_eq(event.tsc, 0x1000); 2016 2017 errcode = pt_qry_event(decoder, &event, sizeof(event)); 2018 switch (ipc) { 2019 case pt_ipc_suppressed: 2020 ptu_int_eq(errcode, -pte_noip); 2021 return ptu_passed(); 2022 2023 case pt_ipc_update_16: 2024 case pt_ipc_update_32: 2025 case pt_ipc_update_48: 2026 case pt_ipc_sext_48: 2027 case pt_ipc_full: 2028 ptu_int_eq(errcode, pts_eos); 2029 ptu_int_eq(event.type, ptev_overflow); 2030 ptu_uint_eq(event.variant.overflow.ip, dfix->last_ip.ip); 2031 ptu_int_eq(event.has_tsc, 1); 2032 ptu_uint_eq(event.tsc, 0x1000); 2033 break; 2034 } 2035 2036 return ptu_passed(); 2037 } 2038 2039 static struct ptunit_result 2040 sync_ovf_event_cutoff_fail(struct ptu_decoder_fixture *dfix) 2041 { 2042 struct pt_query_decoder *decoder = &dfix->decoder; 2043 struct pt_encoder *encoder = &dfix->encoder; 2044 uint64_t addr; 2045 int errcode; 2046 2047 pt_encode_psb(encoder); 2048 pt_encode_ovf(encoder); 2049 2050 ptu_check(cutoff, decoder, encoder); 2051 2052 errcode = pt_qry_sync_forward(decoder, &addr); 2053 ptu_int_eq(errcode, -pte_eos); 2054 2055 return ptu_passed(); 2056 } 2057 2058 static struct ptunit_result time_null_fail(struct ptu_decoder_fixture *dfix) 2059 { 2060 struct pt_query_decoder *decoder = &dfix->decoder; 2061 uint64_t tsc; 2062 int errcode; 2063 2064 errcode = pt_qry_time(NULL, NULL, NULL, NULL); 2065 ptu_int_eq(errcode, -pte_invalid); 2066 2067 errcode = pt_qry_time(decoder, NULL, NULL, NULL); 2068 ptu_int_eq(errcode, -pte_invalid); 2069 2070 errcode = pt_qry_time(NULL, &tsc, NULL, NULL); 2071 ptu_int_eq(errcode, -pte_invalid); 2072 2073 return ptu_passed(); 2074 } 2075 2076 static struct ptunit_result time_initial(struct ptu_decoder_fixture *dfix) 2077 { 2078 struct pt_query_decoder *decoder = &dfix->decoder; 2079 uint64_t tsc; 2080 int errcode; 2081 2082 errcode = pt_qry_time(decoder, &tsc, NULL, NULL); 2083 ptu_int_eq(errcode, -pte_no_time); 2084 2085 return ptu_passed(); 2086 } 2087 2088 static struct ptunit_result time(struct ptu_decoder_fixture *dfix) 2089 { 2090 struct pt_query_decoder *decoder = &dfix->decoder; 2091 uint64_t tsc, exp; 2092 int errcode; 2093 2094 exp = 0x11223344556677ull; 2095 2096 decoder->last_time.have_tsc = 1; 2097 decoder->last_time.tsc = exp; 2098 2099 errcode = pt_qry_time(decoder, &tsc, NULL, NULL); 2100 ptu_int_eq(errcode, 0); 2101 ptu_uint_eq(tsc, exp); 2102 2103 return ptu_passed(); 2104 } 2105 2106 static struct ptunit_result cbr_null(struct ptu_decoder_fixture *dfix) 2107 { 2108 struct pt_query_decoder *decoder = &dfix->decoder; 2109 uint32_t cbr; 2110 int errcode; 2111 2112 errcode = pt_qry_core_bus_ratio(NULL, NULL); 2113 ptu_int_eq(errcode, -pte_invalid); 2114 2115 errcode = pt_qry_core_bus_ratio(decoder, NULL); 2116 ptu_int_eq(errcode, -pte_invalid); 2117 2118 errcode = pt_qry_core_bus_ratio(NULL, &cbr); 2119 ptu_int_eq(errcode, -pte_invalid); 2120 2121 return ptu_passed(); 2122 } 2123 2124 static struct ptunit_result cbr_initial(struct ptu_decoder_fixture *dfix) 2125 { 2126 struct pt_query_decoder *decoder = &dfix->decoder; 2127 uint32_t cbr; 2128 int errcode; 2129 2130 errcode = pt_qry_core_bus_ratio(decoder, &cbr); 2131 ptu_int_eq(errcode, -pte_no_cbr); 2132 2133 return ptu_passed(); 2134 } 2135 2136 static struct ptunit_result cbr(struct ptu_decoder_fixture *dfix) 2137 { 2138 struct pt_query_decoder *decoder = &dfix->decoder; 2139 uint32_t cbr; 2140 int errcode; 2141 2142 decoder->last_time.have_cbr = 1; 2143 decoder->last_time.cbr = 42; 2144 2145 errcode = pt_qry_core_bus_ratio(decoder, &cbr); 2146 ptu_int_eq(errcode, 0); 2147 ptu_uint_eq(cbr, 42); 2148 2149 return ptu_passed(); 2150 } 2151 2152 /* Test that end-of-stream is indicated correctly when the stream ends with a 2153 * partial non-query-relevant packet. 2154 */ 2155 static struct ptunit_result indir_cyc_cutoff(struct ptu_decoder_fixture *dfix) 2156 { 2157 struct pt_query_decoder *decoder = &dfix->decoder; 2158 struct pt_encoder *encoder = &dfix->encoder; 2159 uint64_t ip; 2160 int errcode; 2161 2162 pt_encode_tip(encoder, 0xa000ull, pt_ipc_full); 2163 pt_encode_cyc(encoder, 0xfff); 2164 2165 ptu_check(cutoff, decoder, encoder); 2166 ptu_check(ptu_sync_decoder, decoder); 2167 2168 errcode = pt_qry_indirect_branch(decoder, &ip); 2169 ptu_int_eq(errcode, pts_eos); 2170 2171 return ptu_passed(); 2172 } 2173 2174 /* Test that end-of-stream is indicated correctly when the stream ends with a 2175 * partial non-query-relevant packet. 2176 */ 2177 static struct ptunit_result cond_cyc_cutoff(struct ptu_decoder_fixture *dfix) 2178 { 2179 struct pt_query_decoder *decoder = &dfix->decoder; 2180 struct pt_encoder *encoder = &dfix->encoder; 2181 int errcode, taken; 2182 2183 pt_encode_tnt_8(encoder, 0, 1); 2184 pt_encode_cyc(encoder, 0xfff); 2185 2186 ptu_check(cutoff, decoder, encoder); 2187 ptu_check(ptu_sync_decoder, decoder); 2188 2189 errcode = pt_qry_cond_branch(decoder, &taken); 2190 ptu_int_eq(errcode, pts_eos); 2191 2192 return ptu_passed(); 2193 } 2194 2195 /* Test that end-of-stream is indicated correctly when the stream ends with a 2196 * partial non-query-relevant packet. 2197 */ 2198 static struct ptunit_result event_cyc_cutoff(struct ptu_decoder_fixture *dfix) 2199 { 2200 struct pt_query_decoder *decoder = &dfix->decoder; 2201 struct pt_encoder *encoder = &dfix->encoder; 2202 struct pt_event event; 2203 int errcode; 2204 2205 pt_encode_tip_pgd(encoder, 0ull, pt_ipc_full); 2206 pt_encode_cyc(encoder, 0xffff); 2207 2208 ptu_check(cutoff, decoder, encoder); 2209 ptu_check(ptu_sync_decoder, decoder); 2210 2211 errcode = pt_qry_event(decoder, &event, sizeof(event)); 2212 ptu_int_eq(errcode, pts_eos); 2213 2214 return ptu_passed(); 2215 } 2216 2217 static struct ptunit_result ptu_dfix_init(struct ptu_decoder_fixture *dfix) 2218 { 2219 struct pt_config *config = &dfix->config; 2220 int errcode; 2221 2222 (void) memset(dfix->buffer, 0, sizeof(dfix->buffer)); 2223 2224 pt_config_init(config); 2225 2226 config->begin = dfix->buffer; 2227 config->end = dfix->buffer + sizeof(dfix->buffer); 2228 2229 errcode = pt_encoder_init(&dfix->encoder, config); 2230 ptu_int_eq(errcode, 0); 2231 2232 errcode = pt_qry_decoder_init(&dfix->decoder, config); 2233 ptu_int_eq(errcode, 0); 2234 2235 dfix->decoder.ip.ip = pt_dfix_bad_ip; 2236 dfix->decoder.ip.have_ip = 1; 2237 dfix->decoder.ip.suppressed = 0; 2238 2239 dfix->last_ip = dfix->decoder.ip; 2240 2241 if (dfix->header) 2242 dfix->header(dfix); 2243 2244 return ptu_passed(); 2245 } 2246 2247 static struct ptunit_result ptu_dfix_fini(struct ptu_decoder_fixture *dfix) 2248 { 2249 pt_qry_decoder_fini(&dfix->decoder); 2250 pt_encoder_fini(&dfix->encoder); 2251 2252 return ptu_passed(); 2253 } 2254 2255 /* Synchronize the decoder at the beginnig of an empty buffer. */ 2256 static struct ptunit_result 2257 ptu_dfix_header_sync(struct ptu_decoder_fixture *dfix) 2258 { 2259 struct pt_query_decoder *decoder = &dfix->decoder; 2260 2261 /* Synchronize the decoder at the beginning of the buffer. */ 2262 decoder->pos = decoder->config.begin; 2263 2264 return ptu_passed(); 2265 } 2266 2267 /* Synchronize the decoder at the beginnig of a buffer containing packets that 2268 * should be skipped for unconditional indirect branch queries. 2269 */ 2270 static struct ptunit_result 2271 ptu_dfix_header_indir(struct ptu_decoder_fixture *dfix) 2272 { 2273 struct pt_query_decoder *decoder = &dfix->decoder; 2274 struct pt_encoder *encoder = &dfix->encoder; 2275 2276 pt_encode_pad(encoder); 2277 pt_encode_mtc(encoder, 1); 2278 pt_encode_pad(encoder); 2279 pt_encode_tsc(encoder, 0); 2280 2281 /* Synchronize the decoder at the beginning of the buffer. */ 2282 decoder->pos = decoder->config.begin; 2283 2284 return ptu_passed(); 2285 } 2286 2287 /* Synchronize the decoder at the beginnig of a buffer containing packets that 2288 * should be skipped for unconditional indirect branch queries including a PSB. 2289 */ 2290 static struct ptunit_result 2291 ptu_dfix_header_indir_psb(struct ptu_decoder_fixture *dfix) 2292 { 2293 struct pt_query_decoder *decoder = &dfix->decoder; 2294 struct pt_encoder *encoder = &dfix->encoder; 2295 2296 /* The psb must be empty since the tests won't skip status events. 2297 * On the other hand, we do need to provide an address since tests 2298 * may want to update last-ip, which requires a last-ip, of course. 2299 */ 2300 pt_encode_pad(encoder); 2301 pt_encode_tsc(encoder, 0); 2302 pt_encode_psb(encoder); 2303 pt_encode_mtc(encoder, 1); 2304 pt_encode_pad(encoder); 2305 pt_encode_tsc(encoder, 0); 2306 pt_encode_fup(encoder, pt_dfix_sext_ip, pt_ipc_sext_48); 2307 pt_encode_psbend(encoder); 2308 pt_encode_mtc(encoder, 1); 2309 pt_encode_pad(encoder); 2310 2311 /* Synchronize the decoder at the beginning of the buffer. */ 2312 decoder->pos = decoder->config.begin; 2313 2314 return ptu_passed(); 2315 } 2316 2317 /* Synchronize the decoder at the beginnig of a buffer containing packets that 2318 * should be skipped for conditional branch queries. 2319 */ 2320 static struct ptunit_result 2321 ptu_dfix_header_cond(struct ptu_decoder_fixture *dfix) 2322 { 2323 struct pt_query_decoder *decoder = &dfix->decoder; 2324 struct pt_encoder *encoder = &dfix->encoder; 2325 2326 /* The psb must be empty since the tests won't skip status events. 2327 * On the other hand, we do need to provide an address since tests 2328 * may want to update last-ip, which requires a last-ip, of course. 2329 */ 2330 pt_encode_pad(encoder); 2331 pt_encode_mtc(encoder, 1); 2332 pt_encode_psb(encoder); 2333 pt_encode_tsc(encoder, 0); 2334 pt_encode_pad(encoder); 2335 pt_encode_fup(encoder, pt_dfix_sext_ip, pt_ipc_sext_48); 2336 pt_encode_psbend(encoder); 2337 pt_encode_pad(encoder); 2338 pt_encode_tsc(encoder, 0); 2339 pt_encode_pad(encoder); 2340 2341 /* Synchronize the decoder at the beginning of the buffer. */ 2342 decoder->pos = decoder->config.begin; 2343 2344 return ptu_passed(); 2345 } 2346 2347 /* Synchronize the decoder at the beginnig of a buffer containing packets that 2348 * should be skipped for event queries. 2349 */ 2350 static struct ptunit_result 2351 ptu_dfix_header_event(struct ptu_decoder_fixture *dfix) 2352 { 2353 struct pt_query_decoder *decoder = &dfix->decoder; 2354 struct pt_encoder *encoder = &dfix->encoder; 2355 2356 pt_encode_pad(encoder); 2357 pt_encode_mtc(encoder, 1); 2358 pt_encode_pad(encoder); 2359 pt_encode_tsc(encoder, 0x1000); 2360 2361 /* Synchronize the decoder at the beginning of the buffer. */ 2362 decoder->pos = decoder->config.begin; 2363 2364 return ptu_passed(); 2365 } 2366 2367 /* Synchronize the decoder at the beginnig of a buffer containing packets that 2368 * should be skipped for event queries including a PSB. 2369 */ 2370 static struct ptunit_result 2371 ptu_dfix_header_event_psb(struct ptu_decoder_fixture *dfix) 2372 { 2373 struct pt_query_decoder *decoder = &dfix->decoder; 2374 struct pt_encoder *encoder = &dfix->encoder; 2375 2376 /* The psb must be empty since the tests won't skip status events. 2377 * On the other hand, we do need to provide an address since tests 2378 * may want to update last-ip, which requires a last-ip, of course. 2379 */ 2380 pt_encode_pad(encoder); 2381 pt_encode_tsc(encoder, 0); 2382 pt_encode_psb(encoder); 2383 pt_encode_mtc(encoder, 1); 2384 pt_encode_pad(encoder); 2385 pt_encode_tsc(encoder, 0x1000); 2386 pt_encode_fup(encoder, pt_dfix_sext_ip, pt_ipc_sext_48); 2387 pt_encode_psbend(encoder); 2388 pt_encode_mtc(encoder, 1); 2389 pt_encode_pad(encoder); 2390 2391 /* Synchronize the decoder at the beginning of the buffer. */ 2392 decoder->pos = decoder->config.begin; 2393 2394 return ptu_passed(); 2395 } 2396 2397 static struct ptu_decoder_fixture dfix_raw; 2398 static struct ptu_decoder_fixture dfix_empty; 2399 static struct ptu_decoder_fixture dfix_indir; 2400 static struct ptu_decoder_fixture dfix_indir_psb; 2401 static struct ptu_decoder_fixture dfix_cond; 2402 static struct ptu_decoder_fixture dfix_event; 2403 static struct ptu_decoder_fixture dfix_event_psb; 2404 2405 static void init_fixtures(void) 2406 { 2407 dfix_raw.init = ptu_dfix_init; 2408 dfix_raw.fini = ptu_dfix_fini; 2409 2410 dfix_empty = dfix_raw; 2411 dfix_empty.header = ptu_dfix_header_sync; 2412 2413 dfix_indir = dfix_raw; 2414 dfix_indir.header = ptu_dfix_header_indir; 2415 2416 dfix_indir_psb = dfix_raw; 2417 dfix_indir_psb.header = ptu_dfix_header_indir_psb; 2418 2419 dfix_cond = dfix_raw; 2420 dfix_cond.header = ptu_dfix_header_cond; 2421 2422 dfix_event = dfix_raw; 2423 dfix_event.header = ptu_dfix_header_event; 2424 2425 dfix_event_psb = dfix_raw; 2426 dfix_event_psb.header = ptu_dfix_header_event_psb; 2427 } 2428 2429 int main(int argc, char **argv) 2430 { 2431 struct ptunit_suite suite; 2432 2433 init_fixtures(); 2434 2435 suite = ptunit_mk_suite(argc, argv); 2436 2437 ptu_run_f(suite, indir_not_synced, dfix_raw); 2438 ptu_run_f(suite, cond_not_synced, dfix_raw); 2439 ptu_run_f(suite, event_not_synced, dfix_raw); 2440 2441 ptu_run_f(suite, sync_backward, dfix_raw); 2442 ptu_run_f(suite, sync_backward_empty_end, dfix_raw); 2443 ptu_run_f(suite, sync_backward_empty_mid, dfix_raw); 2444 ptu_run_f(suite, sync_backward_empty_begin, dfix_raw); 2445 ptu_run_f(suite, decode_sync_backward, dfix_raw); 2446 2447 ptu_run_f(suite, indir_null, dfix_empty); 2448 ptu_run_f(suite, indir_empty, dfix_empty); 2449 ptu_run_fp(suite, indir, dfix_empty, pt_ipc_suppressed); 2450 ptu_run_fp(suite, indir, dfix_empty, pt_ipc_update_16); 2451 ptu_run_fp(suite, indir, dfix_empty, pt_ipc_update_32); 2452 ptu_run_fp(suite, indir, dfix_empty, pt_ipc_update_48); 2453 ptu_run_fp(suite, indir, dfix_empty, pt_ipc_sext_48); 2454 ptu_run_fp(suite, indir, dfix_empty, pt_ipc_full); 2455 ptu_run_fp(suite, indir_tnt, dfix_empty, pt_ipc_suppressed); 2456 ptu_run_fp(suite, indir_tnt, dfix_empty, pt_ipc_update_16); 2457 ptu_run_fp(suite, indir_tnt, dfix_empty, pt_ipc_update_32); 2458 ptu_run_fp(suite, indir_tnt, dfix_empty, pt_ipc_update_48); 2459 ptu_run_fp(suite, indir_tnt, dfix_empty, pt_ipc_sext_48); 2460 ptu_run_fp(suite, indir_tnt, dfix_empty, pt_ipc_full); 2461 ptu_run_f(suite, indir_cutoff_fail, dfix_empty); 2462 ptu_run_f(suite, indir_skip_tnt_fail, dfix_empty); 2463 ptu_run_f(suite, indir_skip_tip_pge_fail, dfix_empty); 2464 ptu_run_f(suite, indir_skip_tip_pgd_fail, dfix_empty); 2465 ptu_run_f(suite, indir_skip_fup_tip_fail, dfix_empty); 2466 ptu_run_f(suite, indir_skip_fup_tip_pgd_fail, dfix_empty); 2467 2468 ptu_run_fp(suite, indir, dfix_indir, pt_ipc_suppressed); 2469 ptu_run_fp(suite, indir, dfix_indir, pt_ipc_update_16); 2470 ptu_run_fp(suite, indir, dfix_indir, pt_ipc_update_32); 2471 ptu_run_fp(suite, indir, dfix_indir, pt_ipc_update_48); 2472 ptu_run_fp(suite, indir, dfix_indir, pt_ipc_sext_48); 2473 ptu_run_fp(suite, indir, dfix_indir, pt_ipc_full); 2474 ptu_run_fp(suite, indir_tnt, dfix_indir, pt_ipc_suppressed); 2475 ptu_run_fp(suite, indir_tnt, dfix_indir, pt_ipc_update_16); 2476 ptu_run_fp(suite, indir_tnt, dfix_indir, pt_ipc_update_32); 2477 ptu_run_fp(suite, indir_tnt, dfix_indir, pt_ipc_update_48); 2478 ptu_run_fp(suite, indir_tnt, dfix_indir, pt_ipc_sext_48); 2479 ptu_run_fp(suite, indir_tnt, dfix_indir, pt_ipc_full); 2480 ptu_run_f(suite, indir_cutoff_fail, dfix_indir); 2481 ptu_run_f(suite, indir_skip_tnt_fail, dfix_indir); 2482 ptu_run_f(suite, indir_skip_tip_pge_fail, dfix_indir); 2483 ptu_run_f(suite, indir_skip_tip_pgd_fail, dfix_indir); 2484 ptu_run_f(suite, indir_skip_fup_tip_fail, dfix_indir); 2485 ptu_run_f(suite, indir_skip_fup_tip_pgd_fail, dfix_indir); 2486 2487 ptu_run_fp(suite, indir, dfix_indir_psb, pt_ipc_suppressed); 2488 ptu_run_fp(suite, indir, dfix_indir_psb, pt_ipc_sext_48); 2489 ptu_run_fp(suite, indir, dfix_indir_psb, pt_ipc_full); 2490 ptu_run_fp(suite, indir_tnt, dfix_indir_psb, pt_ipc_suppressed); 2491 ptu_run_fp(suite, indir_tnt, dfix_indir_psb, pt_ipc_sext_48); 2492 ptu_run_fp(suite, indir_tnt, dfix_indir_psb, pt_ipc_full); 2493 ptu_run_f(suite, indir_cutoff_fail, dfix_indir_psb); 2494 ptu_run_f(suite, indir_skip_tnt_fail, dfix_indir_psb); 2495 ptu_run_f(suite, indir_skip_tip_pge_fail, dfix_indir_psb); 2496 ptu_run_f(suite, indir_skip_tip_pgd_fail, dfix_indir_psb); 2497 ptu_run_f(suite, indir_skip_fup_tip_fail, dfix_indir_psb); 2498 ptu_run_f(suite, indir_skip_fup_tip_pgd_fail, dfix_indir_psb); 2499 2500 ptu_run_f(suite, cond_null, dfix_empty); 2501 ptu_run_f(suite, cond_empty, dfix_empty); 2502 ptu_run_f(suite, cond, dfix_empty); 2503 ptu_run_f(suite, cond_skip_tip_fail, dfix_empty); 2504 ptu_run_f(suite, cond_skip_tip_pge_fail, dfix_empty); 2505 ptu_run_f(suite, cond_skip_tip_pgd_fail, dfix_empty); 2506 ptu_run_f(suite, cond_skip_fup_tip_fail, dfix_empty); 2507 ptu_run_f(suite, cond_skip_fup_tip_pgd_fail, dfix_empty); 2508 2509 ptu_run_f(suite, cond, dfix_cond); 2510 ptu_run_f(suite, cond_skip_tip_fail, dfix_cond); 2511 ptu_run_f(suite, cond_skip_tip_pge_fail, dfix_cond); 2512 ptu_run_f(suite, cond_skip_tip_pgd_fail, dfix_cond); 2513 ptu_run_f(suite, cond_skip_fup_tip_fail, dfix_cond); 2514 ptu_run_f(suite, cond_skip_fup_tip_pgd_fail, dfix_cond); 2515 2516 ptu_run_f(suite, event_null, dfix_empty); 2517 ptu_run_f(suite, event_bad_size, dfix_empty); 2518 ptu_run_f(suite, event_small_size, dfix_empty); 2519 ptu_run_f(suite, event_big_size, dfix_empty); 2520 ptu_run_f(suite, event_empty, dfix_empty); 2521 ptu_run_fp(suite, event_enabled, dfix_empty, pt_ipc_suppressed, 0); 2522 ptu_run_fp(suite, event_enabled, dfix_empty, pt_ipc_update_16, 0); 2523 ptu_run_fp(suite, event_enabled, dfix_empty, pt_ipc_update_32, 0); 2524 ptu_run_fp(suite, event_enabled, dfix_empty, pt_ipc_update_48, 0); 2525 ptu_run_fp(suite, event_enabled, dfix_empty, pt_ipc_sext_48, 0); 2526 ptu_run_fp(suite, event_enabled, dfix_empty, pt_ipc_full, 0); 2527 ptu_run_f(suite, event_enabled_cutoff_fail, dfix_empty); 2528 ptu_run_fp(suite, event_disabled, dfix_empty, pt_ipc_suppressed, 0); 2529 ptu_run_fp(suite, event_disabled, dfix_empty, pt_ipc_update_16, 0); 2530 ptu_run_fp(suite, event_disabled, dfix_empty, pt_ipc_update_32, 0); 2531 ptu_run_fp(suite, event_disabled, dfix_empty, pt_ipc_update_48, 0); 2532 ptu_run_fp(suite, event_disabled, dfix_empty, pt_ipc_sext_48, 0); 2533 ptu_run_fp(suite, event_disabled, dfix_empty, pt_ipc_full, 0); 2534 ptu_run_f(suite, event_disabled_cutoff_fail, dfix_empty); 2535 ptu_run_fp(suite, event_async_disabled, dfix_empty, pt_ipc_suppressed, 2536 0); 2537 ptu_run_fp(suite, event_async_disabled, dfix_empty, pt_ipc_update_16, 2538 0); 2539 ptu_run_fp(suite, event_async_disabled, dfix_empty, pt_ipc_update_32, 2540 0); 2541 ptu_run_fp(suite, event_async_disabled, dfix_empty, pt_ipc_update_48, 2542 0); 2543 ptu_run_fp(suite, event_async_disabled, dfix_empty, pt_ipc_sext_48, 0); 2544 ptu_run_fp(suite, event_async_disabled, dfix_empty, pt_ipc_full, 0); 2545 ptu_run_f(suite, event_async_disabled_suppressed_fail, dfix_empty); 2546 ptu_run_f(suite, event_async_disabled_cutoff_fail_a, dfix_empty); 2547 ptu_run_f(suite, event_async_disabled_cutoff_fail_b, dfix_empty); 2548 ptu_run_fp(suite, event_async_branch, dfix_empty, pt_ipc_suppressed, 0); 2549 ptu_run_fp(suite, event_async_branch, dfix_empty, pt_ipc_update_16, 0); 2550 ptu_run_fp(suite, event_async_branch, dfix_empty, pt_ipc_update_32, 0); 2551 ptu_run_fp(suite, event_async_branch, dfix_empty, pt_ipc_update_48, 0); 2552 ptu_run_fp(suite, event_async_branch, dfix_empty, pt_ipc_sext_48, 0); 2553 ptu_run_fp(suite, event_async_branch, dfix_empty, pt_ipc_full, 0); 2554 ptu_run_f(suite, event_async_branch_suppressed_fail, dfix_empty); 2555 ptu_run_f(suite, event_async_branch_cutoff_fail_a, dfix_empty); 2556 ptu_run_f(suite, event_async_branch_cutoff_fail_b, dfix_empty); 2557 ptu_run_fp(suite, event_paging, dfix_empty, 0, 0); 2558 ptu_run_fp(suite, event_paging, dfix_empty, pt_pl_pip_nr, 0); 2559 ptu_run_f(suite, event_paging_cutoff_fail, dfix_empty); 2560 ptu_run_fp(suite, event_async_paging, dfix_empty, 0, 0); 2561 ptu_run_fp(suite, event_async_paging, dfix_empty, pt_pl_pip_nr, 0); 2562 ptu_run_fp(suite, event_async_paging_suppressed, dfix_empty, 0, 0); 2563 ptu_run_fp(suite, event_async_paging_suppressed, dfix_empty, 2564 pt_pl_pip_nr, 0); 2565 ptu_run_f(suite, event_async_paging_cutoff_fail, dfix_empty); 2566 ptu_run_fp(suite, event_overflow_fup, dfix_empty, pt_ipc_suppressed, 0); 2567 ptu_run_fp(suite, event_overflow_fup, dfix_empty, pt_ipc_update_16, 0); 2568 ptu_run_fp(suite, event_overflow_fup, dfix_empty, pt_ipc_update_32, 0); 2569 ptu_run_fp(suite, event_overflow_fup, dfix_empty, pt_ipc_update_48, 0); 2570 ptu_run_fp(suite, event_overflow_fup, dfix_empty, pt_ipc_sext_48, 0); 2571 ptu_run_fp(suite, event_overflow_fup, dfix_empty, pt_ipc_full, 0); 2572 ptu_run_fp(suite, event_overflow_tip_pge, dfix_empty, 2573 pt_ipc_suppressed, 0); 2574 ptu_run_fp(suite, event_overflow_tip_pge, dfix_empty, pt_ipc_update_16, 2575 0); 2576 ptu_run_fp(suite, event_overflow_tip_pge, dfix_empty, pt_ipc_update_32, 2577 0); 2578 ptu_run_fp(suite, event_overflow_tip_pge, dfix_empty, pt_ipc_update_48, 2579 0); 2580 ptu_run_fp(suite, event_overflow_tip_pge, dfix_empty, pt_ipc_sext_48, 2581 0); 2582 ptu_run_fp(suite, event_overflow_tip_pge, dfix_empty, pt_ipc_full, 2583 0); 2584 ptu_run_f(suite, event_overflow_cutoff_fail, dfix_empty); 2585 ptu_run_fp(suite, event_stop, dfix_empty, 0); 2586 ptu_run_fp(suite, event_exec_mode_tip, dfix_empty, pt_ipc_suppressed, 2587 0); 2588 ptu_run_fp(suite, event_exec_mode_tip, dfix_empty, pt_ipc_update_16, 0); 2589 ptu_run_fp(suite, event_exec_mode_tip, dfix_empty, pt_ipc_update_32, 0); 2590 ptu_run_fp(suite, event_exec_mode_tip, dfix_empty, pt_ipc_update_48, 0); 2591 ptu_run_fp(suite, event_exec_mode_tip, dfix_empty, pt_ipc_sext_48, 0); 2592 ptu_run_fp(suite, event_exec_mode_tip, dfix_empty, pt_ipc_full, 0); 2593 ptu_run_f(suite, event_exec_mode_tip_cutoff_fail, dfix_empty); 2594 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_empty, 2595 pt_ipc_suppressed, 0); 2596 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_empty, 2597 pt_ipc_update_16, 0); 2598 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_empty, 2599 pt_ipc_update_32, 0); 2600 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_empty, 2601 pt_ipc_update_48, 0); 2602 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_empty, pt_ipc_sext_48, 2603 0); 2604 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_empty, pt_ipc_full, 2605 0); 2606 ptu_run_f(suite, event_exec_mode_tip_pge_cutoff_fail, dfix_empty); 2607 ptu_run_f(suite, event_exec_mode_cutoff_fail, dfix_empty); 2608 ptu_run_fp(suite, event_tsx_fup, dfix_empty, pt_ipc_suppressed, 2609 pt_mob_tsx_intx, 0); 2610 ptu_run_fp(suite, event_tsx_fup, dfix_empty, pt_ipc_update_16, 0, 0); 2611 ptu_run_fp(suite, event_tsx_fup, dfix_empty, pt_ipc_update_32, 2612 pt_mob_tsx_intx, 0); 2613 ptu_run_fp(suite, event_tsx_fup, dfix_empty, pt_ipc_update_48, 2614 pt_mob_tsx_intx, 0); 2615 ptu_run_fp(suite, event_tsx_fup, dfix_empty, pt_ipc_sext_48, 0, 0); 2616 ptu_run_fp(suite, event_tsx_fup, dfix_empty, pt_ipc_full, 0, 0); 2617 ptu_run_f(suite, event_tsx_fup_cutoff_fail, dfix_empty); 2618 ptu_run_f(suite, event_tsx_cutoff_fail, dfix_empty); 2619 ptu_run_f(suite, event_skip_tip_fail, dfix_empty); 2620 ptu_run_f(suite, event_skip_tnt_8_fail, dfix_empty); 2621 ptu_run_f(suite, event_skip_tnt_64_fail, dfix_empty); 2622 ptu_run_fp(suite, sync_event, dfix_empty, pt_ipc_suppressed); 2623 ptu_run_fp(suite, sync_event, dfix_empty, pt_ipc_update_16); 2624 ptu_run_fp(suite, sync_event, dfix_empty, pt_ipc_update_32); 2625 ptu_run_fp(suite, sync_event, dfix_empty, pt_ipc_update_48); 2626 ptu_run_fp(suite, sync_event, dfix_empty, pt_ipc_sext_48); 2627 ptu_run_fp(suite, sync_event, dfix_empty, pt_ipc_full); 2628 ptu_run_f(suite, sync_event_cutoff_fail, dfix_empty); 2629 ptu_run_f(suite, sync_event_incomplete_fail, dfix_empty); 2630 ptu_run_fp(suite, sync_ovf_event, dfix_empty, pt_ipc_suppressed); 2631 ptu_run_fp(suite, sync_ovf_event, dfix_empty, pt_ipc_update_16); 2632 ptu_run_fp(suite, sync_ovf_event, dfix_empty, pt_ipc_update_32); 2633 ptu_run_fp(suite, sync_ovf_event, dfix_empty, pt_ipc_update_48); 2634 ptu_run_fp(suite, sync_ovf_event, dfix_empty, pt_ipc_sext_48); 2635 ptu_run_fp(suite, sync_ovf_event, dfix_empty, pt_ipc_full); 2636 ptu_run_f(suite, sync_ovf_event_cutoff_fail, dfix_empty); 2637 2638 ptu_run_fp(suite, event_enabled, dfix_event, pt_ipc_suppressed, 0x1000); 2639 ptu_run_fp(suite, event_enabled, dfix_event, pt_ipc_update_16, 0x1000); 2640 ptu_run_fp(suite, event_enabled, dfix_event, pt_ipc_update_32, 0x1000); 2641 ptu_run_fp(suite, event_enabled, dfix_event, pt_ipc_update_48, 0x1000); 2642 ptu_run_fp(suite, event_enabled, dfix_event, pt_ipc_sext_48, 0x1000); 2643 ptu_run_fp(suite, event_enabled, dfix_event, pt_ipc_full, 0x1000); 2644 ptu_run_f(suite, event_enabled_cutoff_fail, dfix_event); 2645 ptu_run_fp(suite, event_disabled, dfix_event, pt_ipc_suppressed, 2646 0x1000); 2647 ptu_run_fp(suite, event_disabled, dfix_event, pt_ipc_update_16, 0x1000); 2648 ptu_run_fp(suite, event_disabled, dfix_event, pt_ipc_update_32, 0x1000); 2649 ptu_run_fp(suite, event_disabled, dfix_event, pt_ipc_update_48, 0x1000); 2650 ptu_run_fp(suite, event_disabled, dfix_event, pt_ipc_sext_48, 0x1000); 2651 ptu_run_fp(suite, event_disabled, dfix_event, pt_ipc_full, 0x1000); 2652 ptu_run_f(suite, event_disabled_cutoff_fail, dfix_event); 2653 ptu_run_fp(suite, event_async_disabled, dfix_event, pt_ipc_suppressed, 2654 0x1000); 2655 ptu_run_fp(suite, event_async_disabled, dfix_event, pt_ipc_update_16, 2656 0x1000); 2657 ptu_run_fp(suite, event_async_disabled, dfix_event, pt_ipc_update_32, 2658 0x1000); 2659 ptu_run_fp(suite, event_async_disabled, dfix_event, pt_ipc_update_48, 2660 0x1000); 2661 ptu_run_fp(suite, event_async_disabled, dfix_event, pt_ipc_sext_48, 2662 0x1000); 2663 ptu_run_fp(suite, event_async_disabled, dfix_event, pt_ipc_full, 2664 0x1000); 2665 ptu_run_f(suite, event_async_disabled_suppressed_fail, dfix_event); 2666 ptu_run_f(suite, event_async_disabled_cutoff_fail_a, dfix_event); 2667 ptu_run_f(suite, event_async_disabled_cutoff_fail_b, dfix_event); 2668 ptu_run_fp(suite, event_async_branch, dfix_event, pt_ipc_suppressed, 2669 0x1000); 2670 ptu_run_fp(suite, event_async_branch, dfix_event, pt_ipc_update_16, 2671 0x1000); 2672 ptu_run_fp(suite, event_async_branch, dfix_event, pt_ipc_update_32, 2673 0x1000); 2674 ptu_run_fp(suite, event_async_branch, dfix_event, pt_ipc_update_48, 2675 0x1000); 2676 ptu_run_fp(suite, event_async_branch, dfix_event, pt_ipc_sext_48, 2677 0x1000); 2678 ptu_run_fp(suite, event_async_branch, dfix_event, pt_ipc_full, 2679 0x1000); 2680 ptu_run_f(suite, event_async_branch_suppressed_fail, dfix_event); 2681 ptu_run_f(suite, event_async_branch_cutoff_fail_a, dfix_event); 2682 ptu_run_f(suite, event_async_branch_cutoff_fail_b, dfix_event); 2683 ptu_run_fp(suite, event_paging, dfix_event, 0, 0x1000); 2684 ptu_run_fp(suite, event_paging, dfix_event, pt_pl_pip_nr, 0x1000); 2685 ptu_run_f(suite, event_paging_cutoff_fail, dfix_event); 2686 ptu_run_fp(suite, event_async_paging, dfix_event, 0, 0x1000); 2687 ptu_run_fp(suite, event_async_paging, dfix_event, pt_pl_pip_nr, 0x1000); 2688 ptu_run_fp(suite, event_async_paging_suppressed, dfix_event, 0, 0x1000); 2689 ptu_run_fp(suite, event_async_paging_suppressed, dfix_event, 2690 pt_pl_pip_nr, 0x1000); 2691 ptu_run_f(suite, event_async_paging_cutoff_fail, dfix_event); 2692 ptu_run_fp(suite, event_overflow_fup, dfix_event, pt_ipc_suppressed, 2693 0x1000); 2694 ptu_run_fp(suite, event_overflow_fup, dfix_event, pt_ipc_update_16, 2695 0x1000); 2696 ptu_run_fp(suite, event_overflow_fup, dfix_event, pt_ipc_update_32, 2697 0x1000); 2698 ptu_run_fp(suite, event_overflow_fup, dfix_event, pt_ipc_update_48, 2699 0x1000); 2700 ptu_run_fp(suite, event_overflow_fup, dfix_event, pt_ipc_sext_48, 2701 0x1000); 2702 ptu_run_fp(suite, event_overflow_fup, dfix_event, pt_ipc_full, 2703 0x1000); 2704 ptu_run_fp(suite, event_overflow_tip_pge, dfix_event, 2705 pt_ipc_suppressed, 0x1000); 2706 ptu_run_fp(suite, event_overflow_tip_pge, dfix_event, pt_ipc_update_16, 2707 0x1000); 2708 ptu_run_fp(suite, event_overflow_tip_pge, dfix_event, pt_ipc_update_32, 2709 0x1000); 2710 ptu_run_fp(suite, event_overflow_tip_pge, dfix_event, pt_ipc_update_48, 2711 0x1000); 2712 ptu_run_fp(suite, event_overflow_tip_pge, dfix_event, pt_ipc_sext_48, 2713 0x1000); 2714 ptu_run_fp(suite, event_overflow_tip_pge, dfix_event, pt_ipc_full, 2715 0x1000); 2716 ptu_run_f(suite, event_overflow_cutoff_fail, dfix_event); 2717 ptu_run_fp(suite, event_stop, dfix_event, 0x1000); 2718 ptu_run_fp(suite, event_exec_mode_tip, dfix_event, pt_ipc_suppressed, 2719 0x1000); 2720 ptu_run_fp(suite, event_exec_mode_tip, dfix_event, pt_ipc_update_16, 2721 0x1000); 2722 ptu_run_fp(suite, event_exec_mode_tip, dfix_event, pt_ipc_update_32, 2723 0x1000); 2724 ptu_run_fp(suite, event_exec_mode_tip, dfix_event, pt_ipc_update_48, 2725 0x1000); 2726 ptu_run_fp(suite, event_exec_mode_tip, dfix_event, pt_ipc_sext_48, 2727 0x1000); 2728 ptu_run_fp(suite, event_exec_mode_tip, dfix_event, pt_ipc_full, 2729 0x1000); 2730 ptu_run_f(suite, event_exec_mode_tip_cutoff_fail, dfix_event); 2731 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_event, 2732 pt_ipc_suppressed, 0x1000); 2733 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_event, 2734 pt_ipc_update_16, 0x1000); 2735 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_event, 2736 pt_ipc_update_32, 0x1000); 2737 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_event, 2738 pt_ipc_update_48, 0x1000); 2739 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_event, pt_ipc_sext_48, 2740 0x1000); 2741 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_event, pt_ipc_full, 2742 0x1000); 2743 ptu_run_f(suite, event_exec_mode_tip_pge_cutoff_fail, dfix_event); 2744 ptu_run_f(suite, event_exec_mode_cutoff_fail, dfix_event); 2745 ptu_run_fp(suite, event_tsx_fup, dfix_event, pt_ipc_suppressed, 0, 2746 0x1000); 2747 ptu_run_fp(suite, event_tsx_fup, dfix_event, pt_ipc_update_16, 2748 pt_mob_tsx_intx, 0x1000); 2749 ptu_run_fp(suite, event_tsx_fup, dfix_event, pt_ipc_update_32, 0, 2750 0x1000); 2751 ptu_run_fp(suite, event_tsx_fup, dfix_event, pt_ipc_update_48, 0, 2752 0x1000); 2753 ptu_run_fp(suite, event_tsx_fup, dfix_event, pt_ipc_sext_48, 2754 pt_mob_tsx_intx, 0x1000); 2755 ptu_run_fp(suite, event_tsx_fup, dfix_event, pt_ipc_full, 2756 pt_mob_tsx_intx, 0x1000); 2757 ptu_run_f(suite, event_tsx_fup_cutoff_fail, dfix_event); 2758 ptu_run_f(suite, event_tsx_cutoff_fail, dfix_event); 2759 ptu_run_f(suite, event_skip_tip_fail, dfix_event); 2760 ptu_run_f(suite, event_skip_tnt_8_fail, dfix_event); 2761 ptu_run_f(suite, event_skip_tnt_64_fail, dfix_event); 2762 ptu_run_fp(suite, sync_event, dfix_event, pt_ipc_suppressed); 2763 ptu_run_fp(suite, sync_event, dfix_event, pt_ipc_update_16); 2764 ptu_run_fp(suite, sync_event, dfix_event, pt_ipc_update_32); 2765 ptu_run_fp(suite, sync_event, dfix_event, pt_ipc_update_48); 2766 ptu_run_fp(suite, sync_event, dfix_event, pt_ipc_sext_48); 2767 ptu_run_fp(suite, sync_event, dfix_event, pt_ipc_full); 2768 ptu_run_f(suite, sync_event_cutoff_fail, dfix_event); 2769 ptu_run_f(suite, sync_event_incomplete_fail, dfix_event); 2770 ptu_run_fp(suite, sync_ovf_event, dfix_event, pt_ipc_suppressed); 2771 ptu_run_fp(suite, sync_ovf_event, dfix_event, pt_ipc_update_16); 2772 ptu_run_fp(suite, sync_ovf_event, dfix_event, pt_ipc_update_32); 2773 ptu_run_fp(suite, sync_ovf_event, dfix_event, pt_ipc_update_48); 2774 ptu_run_fp(suite, sync_ovf_event, dfix_event, pt_ipc_sext_48); 2775 ptu_run_fp(suite, sync_ovf_event, dfix_event, pt_ipc_full); 2776 ptu_run_f(suite, sync_ovf_event_cutoff_fail, dfix_event); 2777 2778 ptu_run_fp(suite, event_enabled, dfix_event_psb, pt_ipc_suppressed, 2779 0x1000); 2780 ptu_run_fp(suite, event_enabled, dfix_event_psb, pt_ipc_sext_48, 2781 0x1000); 2782 ptu_run_fp(suite, event_enabled, dfix_event_psb, pt_ipc_full, 2783 0x1000); 2784 ptu_run_f(suite, event_enabled_cutoff_fail, dfix_event_psb); 2785 ptu_run_fp(suite, event_disabled, dfix_event_psb, pt_ipc_suppressed, 2786 0x1000); 2787 ptu_run_fp(suite, event_disabled, dfix_event_psb, pt_ipc_sext_48, 2788 0x1000); 2789 ptu_run_fp(suite, event_disabled, dfix_event_psb, pt_ipc_full, 2790 0x1000); 2791 ptu_run_f(suite, event_disabled_cutoff_fail, dfix_event_psb); 2792 ptu_run_fp(suite, event_async_disabled, dfix_event_psb, 2793 pt_ipc_suppressed, 0x1000); 2794 ptu_run_fp(suite, event_async_disabled, dfix_event_psb, 2795 pt_ipc_update_16, 0x1000); 2796 ptu_run_fp(suite, event_async_disabled, dfix_event_psb, 2797 pt_ipc_update_32, 0x1000); 2798 ptu_run_fp(suite, event_async_disabled, dfix_event_psb, 2799 pt_ipc_update_48, 0x1000); 2800 ptu_run_fp(suite, event_async_disabled, dfix_event_psb, 2801 pt_ipc_sext_48, 0x1000); 2802 ptu_run_fp(suite, event_async_disabled, dfix_event_psb, 2803 pt_ipc_full, 0x1000); 2804 ptu_run_f(suite, event_async_disabled_suppressed_fail, dfix_event_psb); 2805 ptu_run_f(suite, event_async_disabled_cutoff_fail_a, dfix_event_psb); 2806 ptu_run_f(suite, event_async_disabled_cutoff_fail_b, dfix_event_psb); 2807 ptu_run_fp(suite, event_async_branch, dfix_event_psb, 2808 pt_ipc_suppressed, 0x1000); 2809 ptu_run_fp(suite, event_async_branch, dfix_event_psb, pt_ipc_update_16, 2810 0x1000); 2811 ptu_run_fp(suite, event_async_branch, dfix_event_psb, pt_ipc_update_32, 2812 0x1000); 2813 ptu_run_fp(suite, event_async_branch, dfix_event_psb, pt_ipc_update_48, 2814 0x1000); 2815 ptu_run_fp(suite, event_async_branch, dfix_event_psb, pt_ipc_sext_48, 2816 0x1000); 2817 ptu_run_fp(suite, event_async_branch, dfix_event_psb, pt_ipc_full, 2818 0x1000); 2819 ptu_run_f(suite, event_async_branch_suppressed_fail, dfix_event_psb); 2820 ptu_run_f(suite, event_async_branch_cutoff_fail_a, dfix_event_psb); 2821 ptu_run_f(suite, event_async_branch_cutoff_fail_b, dfix_event_psb); 2822 ptu_run_fp(suite, event_paging, dfix_event_psb, 0, 0x1000); 2823 ptu_run_fp(suite, event_paging, dfix_event_psb, pt_pl_pip_nr, 0x1000); 2824 ptu_run_f(suite, event_paging_cutoff_fail, dfix_event_psb); 2825 ptu_run_fp(suite, event_async_paging, dfix_event_psb, 0, 0x1000); 2826 ptu_run_fp(suite, event_async_paging, dfix_event_psb, pt_pl_pip_nr, 2827 0x1000); 2828 ptu_run_fp(suite, event_async_paging_suppressed, dfix_event_psb, 0, 2829 0x1000); 2830 ptu_run_fp(suite, event_async_paging_suppressed, dfix_event_psb, 2831 pt_pl_pip_nr, 0x1000); 2832 ptu_run_f(suite, event_async_paging_cutoff_fail, dfix_event_psb); 2833 ptu_run_f(suite, event_overflow_cutoff_fail, dfix_event_psb); 2834 ptu_run_fp(suite, event_stop, dfix_event_psb, 0x1000); 2835 ptu_run_fp(suite, event_exec_mode_tip, dfix_event_psb, 2836 pt_ipc_suppressed, 0x1000); 2837 ptu_run_fp(suite, event_exec_mode_tip, dfix_event_psb, pt_ipc_sext_48, 2838 0x1000); 2839 ptu_run_fp(suite, event_exec_mode_tip, dfix_event_psb, pt_ipc_full, 2840 0x1000); 2841 ptu_run_f(suite, event_exec_mode_tip_cutoff_fail, dfix_event_psb); 2842 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_event_psb, 2843 pt_ipc_sext_48, 0x1000); 2844 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_event_psb, 2845 pt_ipc_full, 0x1000); 2846 ptu_run_f(suite, event_exec_mode_tip_pge_cutoff_fail, dfix_event_psb); 2847 ptu_run_f(suite, event_exec_mode_cutoff_fail, dfix_event_psb); 2848 ptu_run_fp(suite, event_tsx_fup, dfix_event_psb, pt_ipc_suppressed, 0, 2849 0x1000); 2850 ptu_run_fp(suite, event_tsx_fup, dfix_event_psb, pt_ipc_sext_48, 2851 pt_mob_tsx_intx, 0x1000); 2852 ptu_run_fp(suite, event_tsx_fup, dfix_event_psb, pt_ipc_full, 2853 pt_mob_tsx_intx, 0x1000); 2854 ptu_run_f(suite, event_tsx_fup_cutoff_fail, dfix_event_psb); 2855 ptu_run_f(suite, event_tsx_cutoff_fail, dfix_event_psb); 2856 ptu_run_f(suite, event_skip_tip_fail, dfix_event_psb); 2857 ptu_run_f(suite, event_skip_tnt_8_fail, dfix_event_psb); 2858 ptu_run_f(suite, event_skip_tnt_64_fail, dfix_event_psb); 2859 2860 ptu_run_f(suite, time_null_fail, dfix_empty); 2861 ptu_run_f(suite, time_initial, dfix_empty); 2862 ptu_run_f(suite, time, dfix_empty); 2863 2864 ptu_run_f(suite, cbr_null, dfix_empty); 2865 ptu_run_f(suite, cbr_initial, dfix_empty); 2866 ptu_run_f(suite, cbr, dfix_empty); 2867 2868 ptu_run_f(suite, indir_cyc_cutoff, dfix_empty); 2869 ptu_run_f(suite, cond_cyc_cutoff, dfix_empty); 2870 ptu_run_f(suite, event_cyc_cutoff, dfix_empty); 2871 2872 return ptunit_report(&suite); 2873 } 2874