2 * Copyright (c) 2013-2019, Intel Corporation
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
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.
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.
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"
38 /* A query testing fixture. */
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 *);
45 /* Encode an optional header for the test to read over. */
46 struct ptunit_result (*header)(struct ptu_decoder_fixture *);
48 /* The trace buffer. */
51 /* The configuration under test. */
52 struct pt_config config;
54 /* A encoder and query decoder for the above configuration. */
55 struct pt_encoder encoder;
56 struct pt_query_decoder decoder;
58 /* For tracking last-ip in tests. */
59 struct pt_last_ip last_ip;
62 /* An invalid address. */
63 static const uint64_t pt_dfix_bad_ip = (1ull << 62) - 1ull;
65 /* A sign-extended address. */
66 static const uint64_t pt_dfix_sext_ip = 0xffffff00ff00ff00ull;
68 /* The highest possible address. */
69 static const uint64_t pt_dfix_max_ip = (1ull << 47) - 1ull;
71 /* The highest possible cr3 value. */
72 static const uint64_t pt_dfix_max_cr3 = ((1ull << 47) - 1ull) & ~0x1full;
74 /* Synchronize the decoder at the beginning of the trace stream, avoiding the
77 static struct ptunit_result ptu_sync_decoder(struct pt_query_decoder *decoder)
82 (void) pt_df_fetch(&decoder->next, decoder->pos, &decoder->config);
86 /* Cut off the last encoded packet. */
87 static struct ptunit_result cutoff(struct pt_query_decoder *decoder,
88 const struct pt_encoder *encoder)
99 ptu_ptr_le(decoder->config.begin, pos);
101 decoder->config.end = pos;
105 static struct ptunit_result indir_not_synced(struct ptu_decoder_fixture *dfix)
107 struct pt_query_decoder *decoder = &dfix->decoder;
108 uint64_t ip = pt_dfix_bad_ip, addr = ip;
111 errcode = pt_qry_indirect_branch(decoder, &addr);
112 ptu_int_eq(errcode, -pte_nosync);
113 ptu_uint_eq(addr, ip);
118 static struct ptunit_result cond_not_synced(struct ptu_decoder_fixture *dfix)
120 struct pt_query_decoder *decoder = &dfix->decoder;
121 int errcode, tnt = 0xbc, taken = tnt;
123 errcode = pt_qry_cond_branch(decoder, &taken);
124 ptu_int_eq(errcode, -pte_nosync);
125 ptu_int_eq(taken, tnt);
130 static struct ptunit_result event_not_synced(struct ptu_decoder_fixture *dfix)
132 struct pt_query_decoder *decoder = &dfix->decoder;
133 struct pt_event event;
136 errcode = pt_qry_event(decoder, &event, sizeof(event));
137 ptu_int_eq(errcode, -pte_nosync);
142 static struct ptunit_result sync_backward(struct ptu_decoder_fixture *dfix)
144 struct pt_query_decoder *decoder = &dfix->decoder;
145 struct pt_encoder *encoder = &dfix->encoder;
146 uint64_t sync[3], offset, ip;
149 /* Check that we can use repeated pt_qry_sync_backward() to iterate over
150 * synchronization points in backwards order.
153 errcode = pt_enc_get_offset(encoder, &sync[0]);
154 ptu_int_ge(errcode, 0);
156 pt_encode_psb(encoder);
157 pt_encode_mode_exec(encoder, ptem_64bit);
158 pt_encode_psbend(encoder);
160 errcode = pt_enc_get_offset(encoder, &sync[1]);
161 ptu_int_ge(errcode, 0);
163 pt_encode_psb(encoder);
164 pt_encode_mode_exec(encoder, ptem_64bit);
165 pt_encode_psbend(encoder);
167 errcode = pt_enc_get_offset(encoder, &sync[2]);
168 ptu_int_ge(errcode, 0);
170 pt_encode_psb(encoder);
171 pt_encode_mode_exec(encoder, ptem_64bit);
172 pt_encode_psbend(encoder);
174 /* Synchronize repeatedly and check that we reach each PSB in the
178 errcode = pt_qry_sync_backward(decoder, &ip);
179 ptu_int_ge(errcode, 0);
181 errcode = pt_qry_get_sync_offset(decoder, &offset);
182 ptu_int_eq(errcode, 0);
183 ptu_uint_eq(offset, sync[2]);
185 errcode = pt_qry_sync_backward(decoder, &ip);
186 ptu_int_ge(errcode, 0);
188 errcode = pt_qry_get_sync_offset(decoder, &offset);
189 ptu_int_eq(errcode, 0);
190 ptu_uint_eq(offset, sync[1]);
192 errcode = pt_qry_sync_backward(decoder, &ip);
193 ptu_int_ge(errcode, 0);
195 errcode = pt_qry_get_sync_offset(decoder, &offset);
196 ptu_int_eq(errcode, 0);
197 ptu_uint_eq(offset, sync[0]);
199 errcode = pt_qry_sync_backward(decoder, &ip);
200 ptu_int_eq(errcode, -pte_eos);
205 static struct ptunit_result
206 sync_backward_empty_end(struct ptu_decoder_fixture *dfix)
208 struct pt_query_decoder *decoder = &dfix->decoder;
209 struct pt_encoder *encoder = &dfix->encoder;
210 uint64_t sync[3], offset, ip;
213 /* Check that we can use repeated pt_qry_sync_backward() to iterate over
214 * synchronization points in backwards order.
216 * There's an empty PSB+ at the end. We skip it.
219 errcode = pt_enc_get_offset(encoder, &sync[0]);
220 ptu_int_ge(errcode, 0);
222 pt_encode_psb(encoder);
223 pt_encode_mode_exec(encoder, ptem_64bit);
224 pt_encode_psbend(encoder);
226 errcode = pt_enc_get_offset(encoder, &sync[1]);
227 ptu_int_ge(errcode, 0);
229 pt_encode_psb(encoder);
230 pt_encode_mode_exec(encoder, ptem_64bit);
231 pt_encode_psbend(encoder);
233 errcode = pt_enc_get_offset(encoder, &sync[2]);
234 ptu_int_ge(errcode, 0);
236 pt_encode_psb(encoder);
237 pt_encode_psbend(encoder);
239 /* Synchronize repeatedly and check that we reach each PSB in the
243 errcode = pt_qry_sync_backward(decoder, &ip);
244 ptu_int_ge(errcode, 0);
246 errcode = pt_qry_get_sync_offset(decoder, &offset);
247 ptu_int_eq(errcode, 0);
248 ptu_uint_eq(offset, sync[1]);
250 errcode = pt_qry_sync_backward(decoder, &ip);
251 ptu_int_ge(errcode, 0);
253 errcode = pt_qry_get_sync_offset(decoder, &offset);
254 ptu_int_eq(errcode, 0);
255 ptu_uint_eq(offset, sync[0]);
257 errcode = pt_qry_sync_backward(decoder, &ip);
258 ptu_int_eq(errcode, -pte_eos);
263 static struct ptunit_result
264 sync_backward_empty_mid(struct ptu_decoder_fixture *dfix)
266 struct pt_query_decoder *decoder = &dfix->decoder;
267 struct pt_encoder *encoder = &dfix->encoder;
268 uint64_t sync[3], offset, ip;
271 /* Check that we can use repeated pt_qry_sync_backward() to iterate over
272 * synchronization points in backwards order.
274 * There's an empty PSB+ in the middle. We skip it.
277 errcode = pt_enc_get_offset(encoder, &sync[0]);
278 ptu_int_ge(errcode, 0);
280 pt_encode_psb(encoder);
281 pt_encode_mode_exec(encoder, ptem_64bit);
282 pt_encode_psbend(encoder);
284 errcode = pt_enc_get_offset(encoder, &sync[1]);
285 ptu_int_ge(errcode, 0);
287 pt_encode_psb(encoder);
288 pt_encode_psbend(encoder);
290 errcode = pt_enc_get_offset(encoder, &sync[2]);
291 ptu_int_ge(errcode, 0);
293 pt_encode_psb(encoder);
294 pt_encode_mode_exec(encoder, ptem_64bit);
295 pt_encode_psbend(encoder);
297 /* Synchronize repeatedly and check that we reach each PSB in the
301 errcode = pt_qry_sync_backward(decoder, &ip);
302 ptu_int_ge(errcode, 0);
304 errcode = pt_qry_get_sync_offset(decoder, &offset);
305 ptu_int_eq(errcode, 0);
306 ptu_uint_eq(offset, sync[2]);
308 errcode = pt_qry_sync_backward(decoder, &ip);
309 ptu_int_ge(errcode, 0);
311 errcode = pt_qry_get_sync_offset(decoder, &offset);
312 ptu_int_eq(errcode, 0);
313 ptu_uint_eq(offset, sync[0]);
315 errcode = pt_qry_sync_backward(decoder, &ip);
316 ptu_int_eq(errcode, -pte_eos);
321 static struct ptunit_result
322 sync_backward_empty_begin(struct ptu_decoder_fixture *dfix)
324 struct pt_query_decoder *decoder = &dfix->decoder;
325 struct pt_encoder *encoder = &dfix->encoder;
326 uint64_t sync[3], offset, ip;
329 /* Check that we can use repeated pt_qry_sync_backward() to iterate over
330 * synchronization points in backwards order.
332 * There's an empty PSB+ at the beginning. We skip it.
335 errcode = pt_enc_get_offset(encoder, &sync[0]);
336 ptu_int_ge(errcode, 0);
338 pt_encode_psb(encoder);
339 pt_encode_psbend(encoder);
341 errcode = pt_enc_get_offset(encoder, &sync[1]);
342 ptu_int_ge(errcode, 0);
344 pt_encode_psb(encoder);
345 pt_encode_mode_exec(encoder, ptem_64bit);
346 pt_encode_psbend(encoder);
348 errcode = pt_enc_get_offset(encoder, &sync[2]);
349 ptu_int_ge(errcode, 0);
351 pt_encode_psb(encoder);
352 pt_encode_mode_exec(encoder, ptem_64bit);
353 pt_encode_psbend(encoder);
355 /* Synchronize repeatedly and check that we reach each PSB in the
359 errcode = pt_qry_sync_backward(decoder, &ip);
360 ptu_int_ge(errcode, 0);
362 errcode = pt_qry_get_sync_offset(decoder, &offset);
363 ptu_int_eq(errcode, 0);
364 ptu_uint_eq(offset, sync[2]);
366 errcode = pt_qry_sync_backward(decoder, &ip);
367 ptu_int_ge(errcode, 0);
369 errcode = pt_qry_get_sync_offset(decoder, &offset);
370 ptu_int_eq(errcode, 0);
371 ptu_uint_eq(offset, sync[1]);
373 errcode = pt_qry_sync_backward(decoder, &ip);
374 ptu_int_eq(errcode, -pte_eos);
379 static struct ptunit_result
380 decode_sync_backward(struct ptu_decoder_fixture *dfix)
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;
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.
392 errcode = pt_enc_get_offset(encoder, &sync[0]);
393 ptu_int_ge(errcode, 0);
395 pt_encode_psb(encoder);
396 pt_encode_mode_exec(encoder, ptem_64bit);
397 pt_encode_psbend(encoder);
399 errcode = pt_enc_get_offset(encoder, &sync[1]);
400 ptu_int_ge(errcode, 0);
402 pt_encode_psb(encoder);
403 pt_encode_mode_exec(encoder, ptem_64bit);
404 pt_encode_psbend(encoder);
407 errcode = pt_qry_sync_forward(decoder, &ip);
408 ptu_int_ge(errcode, 0);
410 errcode = pt_qry_get_sync_offset(decoder, &offset);
411 ptu_int_eq(errcode, 0);
412 ptu_uint_eq(offset, sync[0]);
414 errcode = pt_qry_event(decoder, &event, sizeof(event));
415 ptu_int_ge(errcode, 0);
416 ptu_int_eq(event.type, ptev_exec_mode);
418 errcode = pt_qry_event(decoder, &event, sizeof(event));
419 ptu_int_ge(errcode, 0);
420 ptu_int_eq(event.type, ptev_exec_mode);
422 errcode = pt_qry_sync_backward(decoder, &ip);
423 ptu_int_ge(errcode, 0);
425 errcode = pt_qry_get_sync_offset(decoder, &offset);
426 ptu_int_eq(errcode, 0);
427 ptu_uint_eq(offset, sync[1]);
429 errcode = pt_qry_sync_backward(decoder, &ip);
430 ptu_int_ge(errcode, 0);
432 errcode = pt_qry_get_sync_offset(decoder, &offset);
433 ptu_int_eq(errcode, 0);
434 ptu_uint_eq(offset, sync[0]);
436 errcode = pt_qry_sync_backward(decoder, &ip);
437 ptu_int_eq(errcode, -pte_eos);
442 static struct ptunit_result indir_null(struct ptu_decoder_fixture *dfix)
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;
449 errcode = pt_qry_indirect_branch(NULL, &addr);
450 ptu_int_eq(errcode, -pte_invalid);
451 ptu_uint_eq(addr, ip);
453 errcode = pt_qry_indirect_branch(decoder, NULL);
454 ptu_int_eq(errcode, -pte_invalid);
455 ptu_ptr_eq(decoder->pos, config->begin);
460 static struct ptunit_result indir_empty(struct ptu_decoder_fixture *dfix)
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;
467 decoder->pos = config->end;
469 errcode = pt_qry_indirect_branch(decoder, &addr);
470 ptu_int_eq(errcode, -pte_eos);
471 ptu_uint_eq(addr, ip);
476 static struct ptunit_result indir(struct ptu_decoder_fixture *dfix,
477 enum pt_ip_compression ipc)
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;
486 packet.ip = pt_dfix_sext_ip;
487 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config);
489 pt_encode_tip(encoder, packet.ip, packet.ipc);
491 ptu_check(ptu_sync_decoder, decoder);
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);
498 ptu_int_eq(errcode, pts_eos);
499 ptu_uint_eq(addr, dfix->last_ip.ip);
505 static struct ptunit_result indir_tnt(struct ptu_decoder_fixture *dfix,
506 enum pt_ip_compression ipc)
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;
515 packet.ip = pt_dfix_sext_ip;
516 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config);
518 pt_encode_tnt_8(encoder, 0ull, 1);
519 pt_encode_tip(encoder, packet.ip, packet.ipc);
521 ptu_check(ptu_sync_decoder, decoder);
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);
528 ptu_int_eq(errcode, 0);
529 ptu_uint_eq(addr, dfix->last_ip.ip);
535 static struct ptunit_result indir_cutoff_fail(struct ptu_decoder_fixture *dfix)
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;
542 pt_encode_tip(encoder, 0, pt_ipc_sext_48);
544 ptu_check(cutoff, decoder, encoder);
545 ptu_check(ptu_sync_decoder, decoder);
547 errcode = pt_qry_indirect_branch(decoder, &addr);
548 ptu_int_eq(errcode, -pte_eos);
549 ptu_uint_eq(addr, ip);
554 static struct ptunit_result
555 indir_skip_tnt_fail(struct ptu_decoder_fixture *dfix)
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;
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);
566 ptu_check(ptu_sync_decoder, decoder);
568 errcode = pt_qry_indirect_branch(decoder, &addr);
569 ptu_int_eq(errcode, -pte_bad_query);
570 ptu_uint_eq(addr, ip);
575 static struct ptunit_result
576 indir_skip_tip_pge_fail(struct ptu_decoder_fixture *dfix)
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;
585 pt_encode_tip_pge(encoder, 0, pt_ipc_sext_48);
586 pt_encode_tip(encoder, 0, pt_ipc_sext_48);
588 ptu_check(ptu_sync_decoder, decoder);
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);
598 static struct ptunit_result
599 indir_skip_tip_pgd_fail(struct ptu_decoder_fixture *dfix)
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;
608 pt_encode_tip_pgd(encoder, 0, pt_ipc_sext_48);
609 pt_encode_tip(encoder, 0, pt_ipc_sext_48);
611 ptu_check(ptu_sync_decoder, decoder);
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);
621 static struct ptunit_result
622 indir_skip_fup_tip_fail(struct ptu_decoder_fixture *dfix)
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;
630 pt_encode_fup(encoder, 0, pt_ipc_sext_48);
632 pt_encode_tip(encoder, 0, pt_ipc_sext_48);
633 pt_encode_tip(encoder, 0, pt_ipc_sext_48);
635 ptu_check(ptu_sync_decoder, decoder);
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);
645 static struct ptunit_result
646 indir_skip_fup_tip_pgd_fail(struct ptu_decoder_fixture *dfix)
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;
654 pt_encode_fup(encoder, 0, pt_ipc_sext_48);
656 pt_encode_tip_pgd(encoder, 0, pt_ipc_sext_48);
657 pt_encode_tip(encoder, 0, pt_ipc_sext_48);
659 ptu_check(ptu_sync_decoder, decoder);
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);
669 static struct ptunit_result cond_null(struct ptu_decoder_fixture *dfix)
671 struct pt_query_decoder *decoder = &dfix->decoder;
672 struct pt_config *config = &decoder->config;
673 int errcode, tnt = 0xbc, taken = tnt;
675 errcode = pt_qry_cond_branch(NULL, &taken);
676 ptu_int_eq(errcode, -pte_invalid);
677 ptu_int_eq(taken, tnt);
679 errcode = pt_qry_cond_branch(decoder, NULL);
680 ptu_int_eq(errcode, -pte_invalid);
681 ptu_ptr_eq(decoder->pos, config->begin);
686 static struct ptunit_result cond_empty(struct ptu_decoder_fixture *dfix)
688 struct pt_query_decoder *decoder = &dfix->decoder;
689 struct pt_config *config = &decoder->config;
690 int errcode, tnt = 0xbc, taken = tnt;
692 decoder->pos = config->end;
694 errcode = pt_qry_cond_branch(decoder, &taken);
695 ptu_int_eq(errcode, -pte_eos);
696 ptu_int_eq(taken, tnt);
701 static struct ptunit_result cond(struct ptu_decoder_fixture *dfix)
703 struct pt_query_decoder *decoder = &dfix->decoder;
704 struct pt_encoder *encoder = &dfix->encoder;
705 int errcode, tnt = 0xbc, taken = tnt;
707 pt_encode_tnt_8(encoder, 0x02, 3);
709 ptu_check(ptu_sync_decoder, decoder);
711 errcode = pt_qry_cond_branch(decoder, &taken);
712 ptu_int_eq(errcode, 0);
713 ptu_int_eq(taken, 0);
716 errcode = pt_qry_cond_branch(decoder, &taken);
717 ptu_int_eq(errcode, 0);
718 ptu_int_eq(taken, 1);
721 errcode = pt_qry_cond_branch(decoder, &taken);
722 ptu_int_eq(errcode, pts_eos);
723 ptu_int_eq(taken, 0);
726 errcode = pt_qry_cond_branch(decoder, &taken);
727 ptu_int_eq(errcode, -pte_eos);
728 ptu_int_eq(taken, tnt);
733 static struct ptunit_result cond_skip_tip_fail(struct ptu_decoder_fixture *dfix)
735 struct pt_query_decoder *decoder = &dfix->decoder;
736 struct pt_encoder *encoder = &dfix->encoder;
737 int errcode, tnt = 0xbc, taken = tnt;
741 pt_encode_tip(encoder, 0, pt_ipc_sext_48);
742 pt_encode_tnt_8(encoder, 0, 1);
744 ptu_check(ptu_sync_decoder, decoder);
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);
754 static struct ptunit_result
755 cond_skip_tip_pge_fail(struct ptu_decoder_fixture *dfix)
757 struct pt_query_decoder *decoder = &dfix->decoder;
758 struct pt_encoder *encoder = &dfix->encoder;
759 int errcode, tnt = 0xbc, taken = tnt;
763 pt_encode_tip_pge(encoder, 0, pt_ipc_sext_48);
764 pt_encode_tnt_8(encoder, 0, 1);
766 ptu_check(ptu_sync_decoder, decoder);
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);
776 static struct ptunit_result
777 cond_skip_tip_pgd_fail(struct ptu_decoder_fixture *dfix)
779 struct pt_query_decoder *decoder = &dfix->decoder;
780 struct pt_encoder *encoder = &dfix->encoder;
781 int errcode, tnt = 0xbc, taken = tnt;
785 pt_encode_tip_pgd(encoder, 0, pt_ipc_sext_48);
786 pt_encode_tnt_8(encoder, 0, 1);
788 ptu_check(ptu_sync_decoder, decoder);
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);
798 static struct ptunit_result
799 cond_skip_fup_tip_fail(struct ptu_decoder_fixture *dfix)
801 struct pt_query_decoder *decoder = &dfix->decoder;
802 struct pt_encoder *encoder = &dfix->encoder;
803 int errcode, tnt = 0xbc, taken = tnt;
806 pt_encode_fup(encoder, 0, pt_ipc_sext_48);
808 pt_encode_tip(encoder, 0, pt_ipc_sext_48);
809 pt_encode_tnt_8(encoder, 0, 1);
811 ptu_check(ptu_sync_decoder, decoder);
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);
821 static struct ptunit_result
822 cond_skip_fup_tip_pgd_fail(struct ptu_decoder_fixture *dfix)
824 struct pt_query_decoder *decoder = &dfix->decoder;
825 struct pt_encoder *encoder = &dfix->encoder;
826 int errcode, tnt = 0xbc, taken = tnt;
829 pt_encode_fup(encoder, 0, pt_ipc_sext_48);
831 pt_encode_tip_pgd(encoder, 0, pt_ipc_sext_48);
832 pt_encode_tnt_8(encoder, 0, 1);
834 ptu_check(ptu_sync_decoder, decoder);
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);
844 static struct ptunit_result event_null(struct ptu_decoder_fixture *dfix)
846 struct pt_query_decoder *decoder = &dfix->decoder;
847 struct pt_config *config = &decoder->config;
848 struct pt_event event;
851 errcode = pt_qry_event(NULL, &event, sizeof(event));
852 ptu_int_eq(errcode, -pte_invalid);
854 errcode = pt_qry_event(decoder, NULL, sizeof(event));
855 ptu_int_eq(errcode, -pte_invalid);
856 ptu_ptr_eq(decoder->pos, config->begin);
861 static struct ptunit_result event_bad_size(struct ptu_decoder_fixture *dfix)
863 struct pt_query_decoder *decoder = &dfix->decoder;
864 struct pt_event event;
867 errcode = pt_qry_event(decoder, &event, 4);
868 ptu_int_eq(errcode, -pte_invalid);
873 static struct ptunit_result event_small_size(struct ptu_decoder_fixture *dfix)
875 struct pt_query_decoder *decoder = &dfix->decoder;
876 struct pt_encoder *encoder = &dfix->encoder;
878 struct pt_event event;
883 memset(variant.buffer, 0xcd, sizeof(variant.buffer));
885 pt_encode_tip_pge(encoder, 0ull, pt_ipc_sext_48);
887 ptu_check(ptu_sync_decoder, decoder);
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);
897 static struct ptunit_result event_big_size(struct ptu_decoder_fixture *dfix)
899 struct pt_query_decoder *decoder = &dfix->decoder;
900 struct pt_encoder *encoder = &dfix->encoder;
902 struct pt_event event;
903 uint8_t buffer[1024];
907 memset(variant.buffer, 0xcd, sizeof(variant.buffer));
909 pt_encode_tip_pge(encoder, 0ull, pt_ipc_sext_48);
911 ptu_check(ptu_sync_decoder, decoder);
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);
921 static struct ptunit_result event_empty(struct ptu_decoder_fixture *dfix)
923 struct pt_query_decoder *decoder = &dfix->decoder;
924 struct pt_config *config = &decoder->config;
925 struct pt_event event;
928 decoder->pos = config->end;
930 errcode = pt_qry_event(decoder, &event, sizeof(event));
931 ptu_int_eq(errcode, -pte_eos);
936 static struct ptunit_result event_enabled(struct ptu_decoder_fixture *dfix,
937 enum pt_ip_compression ipc,
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;
947 packet.ip = pt_dfix_max_ip;
948 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config);
950 pt_encode_tip_pge(encoder, packet.ip, packet.ipc);
952 ptu_check(ptu_sync_decoder, decoder);
954 errcode = pt_qry_event(decoder, &event, sizeof(event));
955 if (ipc == pt_ipc_suppressed)
956 ptu_int_eq(errcode, -pte_bad_packet);
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);
963 ptu_int_eq(event.has_tsc, 0);
965 ptu_int_eq(event.has_tsc, 1);
966 ptu_uint_eq(event.tsc, tsc);
973 static struct ptunit_result
974 event_enabled_cutoff_fail(struct ptu_decoder_fixture *dfix)
976 struct pt_query_decoder *decoder = &dfix->decoder;
977 struct pt_encoder *encoder = &dfix->encoder;
978 struct pt_event event;
981 pt_encode_tip_pge(encoder, 0, pt_ipc_sext_48);
983 ptu_check(cutoff, decoder, encoder);
984 ptu_check(ptu_sync_decoder, decoder);
986 errcode = pt_qry_event(decoder, &event, sizeof(event));
987 ptu_int_eq(errcode, -pte_eos);
992 static struct ptunit_result event_disabled(struct ptu_decoder_fixture *dfix,
993 enum pt_ip_compression ipc,
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;
1003 packet.ip = pt_dfix_sext_ip;
1004 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config);
1006 pt_encode_tip_pgd(encoder, packet.ip, packet.ipc);
1008 ptu_check(ptu_sync_decoder, decoder);
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);
1015 ptu_uint_eq(event.ip_suppressed, 0);
1016 ptu_uint_eq(event.variant.disabled.ip, dfix->last_ip.ip);
1018 ptu_int_eq(event.type, ptev_disabled);
1021 ptu_int_eq(event.has_tsc, 0);
1023 ptu_int_eq(event.has_tsc, 1);
1024 ptu_uint_eq(event.tsc, tsc);
1027 return ptu_passed();
1030 static struct ptunit_result
1031 event_disabled_cutoff_fail(struct ptu_decoder_fixture *dfix)
1033 struct pt_query_decoder *decoder = &dfix->decoder;
1034 struct pt_encoder *encoder = &dfix->encoder;
1035 struct pt_event event;
1038 pt_encode_tip_pgd(encoder, 0, pt_ipc_update_32);
1040 ptu_check(cutoff, decoder, encoder);
1041 ptu_check(ptu_sync_decoder, decoder);
1043 errcode = pt_qry_event(decoder, &event, sizeof(event));
1044 ptu_int_eq(errcode, -pte_eos);
1046 return ptu_passed();
1049 static struct ptunit_result
1050 event_async_disabled(struct ptu_decoder_fixture *dfix,
1051 enum pt_ip_compression ipc, uint64_t tsc)
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;
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);
1064 tip.ip = pt_dfix_sext_ip;
1065 pt_last_ip_update_ip(&dfix->last_ip, &tip, &dfix->config);
1067 pt_encode_fup(encoder, fup.ip, fup.ipc);
1068 pt_encode_tip_pgd(encoder, tip.ip, tip.ipc);
1070 ptu_check(ptu_sync_decoder, decoder);
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);
1077 ptu_uint_eq(event.ip_suppressed, 0);
1078 ptu_uint_eq(event.variant.async_disabled.ip, dfix->last_ip.ip);
1080 ptu_int_eq(event.type, ptev_async_disabled);
1081 ptu_uint_eq(event.variant.async_disabled.at, fup.ip);
1084 ptu_int_eq(event.has_tsc, 0);
1086 ptu_int_eq(event.has_tsc, 1);
1087 ptu_uint_eq(event.tsc, tsc);
1090 return ptu_passed();
1093 static struct ptunit_result
1094 event_async_disabled_suppressed_fail(struct ptu_decoder_fixture *dfix)
1096 struct pt_query_decoder *decoder = &dfix->decoder;
1097 struct pt_encoder *encoder = &dfix->encoder;
1098 struct pt_event event;
1101 pt_encode_fup(encoder, 0, pt_ipc_suppressed);
1102 pt_encode_tip_pgd(encoder, 0, pt_ipc_sext_48);
1104 ptu_check(ptu_sync_decoder, decoder);
1106 errcode = pt_qry_event(decoder, &event, sizeof(event));
1107 ptu_int_eq(errcode, -pte_ip_suppressed);
1109 return ptu_passed();
1112 static struct ptunit_result
1113 event_async_disabled_cutoff_fail_a(struct ptu_decoder_fixture *dfix)
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;
1121 pt_encode_fup(encoder, at, pt_ipc_sext_48);
1122 pt_encode_tip_pgd(encoder, 0, pt_ipc_update_16);
1124 ptu_check(cutoff, decoder, encoder);
1125 ptu_check(ptu_sync_decoder, decoder);
1127 errcode = pt_qry_event(decoder, &event, sizeof(event));
1128 ptu_int_eq(errcode, -pte_eos);
1130 return ptu_passed();
1133 static struct ptunit_result
1134 event_async_disabled_cutoff_fail_b(struct ptu_decoder_fixture *dfix)
1136 struct pt_query_decoder *decoder = &dfix->decoder;
1137 struct pt_encoder *encoder = &dfix->encoder;
1138 struct pt_event event;
1141 pt_encode_fup(encoder, 0, pt_ipc_sext_48);
1143 ptu_check(cutoff, decoder, encoder);
1144 ptu_check(ptu_sync_decoder, decoder);
1146 errcode = pt_qry_event(decoder, &event, sizeof(event));
1147 ptu_int_eq(errcode, -pte_eos);
1149 return ptu_passed();
1152 static struct ptunit_result
1153 event_async_branch_suppressed_fail(struct ptu_decoder_fixture *dfix)
1155 struct pt_query_decoder *decoder = &dfix->decoder;
1156 struct pt_encoder *encoder = &dfix->encoder;
1157 struct pt_event event;
1160 pt_encode_fup(encoder, 0, pt_ipc_suppressed);
1162 ptu_check(ptu_sync_decoder, decoder);
1164 errcode = pt_qry_event(decoder, &event, sizeof(event));
1165 ptu_int_eq(errcode, -pte_ip_suppressed);
1167 return ptu_passed();
1170 static struct ptunit_result event_async_branch(struct ptu_decoder_fixture *dfix,
1171 enum pt_ip_compression ipc,
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;
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);
1185 tip.ip = pt_dfix_sext_ip;
1186 pt_last_ip_update_ip(&dfix->last_ip, &tip, &dfix->config);
1188 pt_encode_fup(encoder, fup.ip, fup.ipc);
1189 pt_encode_tip(encoder, tip.ip, tip.ipc);
1191 ptu_check(ptu_sync_decoder, decoder);
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);
1198 ptu_uint_eq(event.ip_suppressed, 0);
1199 ptu_uint_eq(event.variant.async_branch.to, dfix->last_ip.ip);
1201 ptu_int_eq(event.type, ptev_async_branch);
1202 ptu_uint_eq(event.variant.async_branch.from, fup.ip);
1205 ptu_int_eq(event.has_tsc, 0);
1207 ptu_int_eq(event.has_tsc, 1);
1208 ptu_uint_eq(event.tsc, tsc);
1211 return ptu_passed();
1214 static struct ptunit_result
1215 event_async_branch_cutoff_fail_a(struct ptu_decoder_fixture *dfix)
1217 struct pt_query_decoder *decoder = &dfix->decoder;
1218 struct pt_encoder *encoder = &dfix->encoder;
1219 struct pt_event event;
1222 pt_encode_fup(encoder, 0, pt_ipc_sext_48);
1223 pt_encode_tip_pgd(encoder, 0, pt_ipc_update_16);
1225 ptu_check(cutoff, decoder, encoder);
1226 ptu_check(ptu_sync_decoder, decoder);
1228 errcode = pt_qry_event(decoder, &event, sizeof(event));
1229 ptu_int_eq(errcode, -pte_eos);
1231 return ptu_passed();
1234 static struct ptunit_result
1235 event_async_branch_cutoff_fail_b(struct ptu_decoder_fixture *dfix)
1237 struct pt_query_decoder *decoder = &dfix->decoder;
1238 struct pt_encoder *encoder = &dfix->encoder;
1239 struct pt_event event;
1242 pt_encode_fup(encoder, 0, pt_ipc_sext_48);
1244 ptu_check(cutoff, decoder, encoder);
1245 ptu_check(ptu_sync_decoder, decoder);
1247 errcode = pt_qry_event(decoder, &event, sizeof(event));
1248 ptu_int_eq(errcode, -pte_eos);
1250 return ptu_passed();
1253 static struct ptunit_result event_paging(struct ptu_decoder_fixture *dfix,
1254 uint8_t flags, uint64_t tsc)
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;
1262 pt_encode_pip(encoder, cr3, flags);
1264 ptu_check(ptu_sync_decoder, decoder);
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);
1273 ptu_int_eq(event.has_tsc, 0);
1275 ptu_int_eq(event.has_tsc, 1);
1276 ptu_uint_eq(event.tsc, tsc);
1279 return ptu_passed();
1282 static struct ptunit_result
1283 event_paging_cutoff_fail(struct ptu_decoder_fixture *dfix)
1285 struct pt_query_decoder *decoder = &dfix->decoder;
1286 struct pt_encoder *encoder = &dfix->encoder;
1287 struct pt_event event;
1290 pt_encode_pip(encoder, 0, 0);
1292 ptu_check(cutoff, decoder, encoder);
1293 ptu_check(ptu_sync_decoder, decoder);
1295 errcode = pt_qry_event(decoder, &event, sizeof(event));
1296 ptu_int_eq(errcode, -pte_eos);
1298 return ptu_passed();
1301 static struct ptunit_result
1302 event_async_paging(struct ptu_decoder_fixture *dfix, uint8_t flags,
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;
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);
1316 ptu_check(ptu_sync_decoder, decoder);
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);
1325 ptu_int_eq(event.has_tsc, 0);
1327 ptu_int_eq(event.has_tsc, 1);
1328 ptu_uint_eq(event.tsc, tsc);
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);
1340 ptu_int_eq(event.has_tsc, 0);
1342 ptu_int_eq(event.has_tsc, 1);
1343 ptu_uint_eq(event.tsc, tsc);
1346 return ptu_passed();
1349 static struct ptunit_result
1350 event_async_paging_suppressed(struct ptu_decoder_fixture *dfix, uint8_t flags,
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;
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);
1363 ptu_check(ptu_sync_decoder, decoder);
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);
1372 ptu_int_eq(event.has_tsc, 0);
1374 ptu_int_eq(event.has_tsc, 1);
1375 ptu_uint_eq(event.tsc, tsc);
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);
1387 ptu_int_eq(event.has_tsc, 0);
1389 ptu_int_eq(event.has_tsc, 1);
1390 ptu_uint_eq(event.tsc, tsc);
1393 return ptu_passed();
1396 static struct ptunit_result
1397 event_async_paging_cutoff_fail(struct ptu_decoder_fixture *dfix)
1399 struct pt_query_decoder *decoder = &dfix->decoder;
1400 struct pt_encoder *encoder = &dfix->encoder;
1401 struct pt_event event;
1404 pt_encode_fup(encoder, 0, pt_ipc_sext_48);
1405 pt_encode_pip(encoder, 0, 0);
1407 ptu_check(cutoff, decoder, encoder);
1408 ptu_check(ptu_sync_decoder, decoder);
1410 errcode = pt_qry_event(decoder, &event, sizeof(event));
1411 ptu_int_eq(errcode, -pte_eos);
1413 return ptu_passed();
1416 static struct ptunit_result event_overflow_fup(struct ptu_decoder_fixture *dfix,
1417 enum pt_ip_compression ipc,
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;
1427 packet.ip = 0xccull;
1429 pt_last_ip_init(&dfix->last_ip);
1430 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config);
1432 pt_encode_ovf(encoder);
1433 pt_encode_fup(encoder, packet.ip, packet.ipc);
1435 ptu_check(ptu_sync_decoder, decoder);
1437 errcode = pt_qry_event(decoder, &event, sizeof(event));
1439 case pt_ipc_suppressed:
1440 ptu_int_eq(errcode, -pte_noip);
1443 case pt_ipc_update_16:
1444 case pt_ipc_update_32:
1445 case pt_ipc_update_48:
1446 case pt_ipc_sext_48:
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);
1453 ptu_int_eq(event.has_tsc, 0);
1455 ptu_int_eq(event.has_tsc, 1);
1456 ptu_uint_eq(event.tsc, tsc);
1461 return ptu_passed();
1464 static struct ptunit_result
1465 event_overflow_tip_pge(struct ptu_decoder_fixture *dfix,
1466 enum pt_ip_compression ipc, uint64_t tsc)
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;
1475 packet.ip = 0xccull;
1477 pt_last_ip_init(&dfix->last_ip);
1478 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config);
1480 pt_encode_ovf(encoder);
1481 pt_encode_tip_pge(encoder, packet.ip, packet.ipc);
1483 ptu_check(ptu_sync_decoder, decoder);
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);
1491 ptu_int_eq(event.has_tsc, 0);
1493 ptu_int_eq(event.has_tsc, 1);
1494 ptu_uint_eq(event.tsc, tsc);
1497 errcode = pt_qry_event(decoder, &event, sizeof(event));
1499 case pt_ipc_suppressed:
1500 ptu_int_eq(errcode, -pte_bad_packet);
1503 case pt_ipc_update_16:
1504 case pt_ipc_update_32:
1505 case pt_ipc_update_48:
1506 case pt_ipc_sext_48:
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);
1513 ptu_int_eq(event.has_tsc, 0);
1515 ptu_int_eq(event.has_tsc, 1);
1516 ptu_uint_eq(event.tsc, tsc);
1521 return ptu_passed();
1524 static struct ptunit_result
1525 event_overflow_cutoff_fail(struct ptu_decoder_fixture *dfix)
1527 struct pt_query_decoder *decoder = &dfix->decoder;
1528 struct pt_encoder *encoder = &dfix->encoder;
1529 struct pt_event event;
1532 pt_encode_ovf(encoder);
1534 ptu_check(cutoff, decoder, encoder);
1535 ptu_check(ptu_sync_decoder, decoder);
1537 errcode = pt_qry_event(decoder, &event, sizeof(event));
1538 ptu_int_eq(errcode, -pte_eos);
1540 return ptu_passed();
1543 static struct ptunit_result event_stop(struct ptu_decoder_fixture *dfix,
1546 struct pt_query_decoder *decoder = &dfix->decoder;
1547 struct pt_encoder *encoder = &dfix->encoder;
1548 struct pt_event event;
1551 pt_encode_stop(encoder);
1553 ptu_sync_decoder(decoder);
1555 errcode = pt_qry_event(decoder, &event, sizeof(event));
1556 ptu_int_eq(errcode, pts_eos);
1557 ptu_int_eq(event.type, ptev_stop);
1560 ptu_int_eq(event.has_tsc, 0);
1562 ptu_int_eq(event.has_tsc, 1);
1563 ptu_uint_eq(event.tsc, tsc);
1566 return ptu_passed();
1569 static struct ptunit_result
1570 event_exec_mode_tip(struct ptu_decoder_fixture *dfix,
1571 enum pt_ip_compression ipc, uint64_t tsc)
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;
1582 packet.ip = pt_dfix_max_ip;
1583 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config);
1585 pt_encode_mode_exec(encoder, mode);
1586 pt_encode_tip(encoder, packet.ip, packet.ipc);
1588 ptu_check(ptu_sync_decoder, decoder);
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);
1595 ptu_uint_eq(event.ip_suppressed, 0);
1596 ptu_uint_eq(event.variant.exec_mode.ip, dfix->last_ip.ip);
1598 ptu_int_eq(event.type, ptev_exec_mode);
1599 ptu_int_eq(event.variant.exec_mode.mode, mode);
1602 ptu_int_eq(event.has_tsc, 0);
1604 ptu_int_eq(event.has_tsc, 1);
1605 ptu_uint_eq(event.tsc, tsc);
1608 errcode = pt_qry_indirect_branch(decoder, &addr);
1609 if (ipc == pt_ipc_suppressed)
1610 ptu_int_eq(errcode, pts_ip_suppressed | pts_eos);
1612 ptu_int_eq(errcode, pts_eos);
1613 ptu_uint_eq(addr, dfix->last_ip.ip);
1616 return ptu_passed();
1619 static struct ptunit_result
1620 event_exec_mode_tip_cutoff_fail(struct ptu_decoder_fixture *dfix)
1622 struct pt_query_decoder *decoder = &dfix->decoder;
1623 struct pt_encoder *encoder = &dfix->encoder;
1624 struct pt_event event;
1627 pt_encode_mode_exec(encoder, ptem_32bit);
1628 pt_encode_tip(encoder, 0, pt_ipc_update_16);
1630 ptu_check(cutoff, decoder, encoder);
1631 ptu_check(ptu_sync_decoder, decoder);
1633 errcode = pt_qry_event(decoder, &event, sizeof(event));
1634 ptu_int_eq(errcode, -pte_eos);
1636 return ptu_passed();
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)
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;
1652 packet.ip = pt_dfix_max_ip;
1653 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config);
1655 pt_encode_mode_exec(encoder, mode);
1656 pt_encode_tip_pge(encoder, packet.ip, packet.ipc);
1658 ptu_check(ptu_sync_decoder, decoder);
1659 decoder->enabled = 0;
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);
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);
1671 ptu_int_eq(event.has_tsc, 0);
1673 ptu_int_eq(event.has_tsc, 1);
1674 ptu_uint_eq(event.tsc, tsc);
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);
1684 ptu_int_eq(event.has_tsc, 0);
1686 ptu_int_eq(event.has_tsc, 1);
1687 ptu_uint_eq(event.tsc, tsc);
1691 return ptu_passed();
1694 static struct ptunit_result
1695 event_exec_mode_tip_pge_cutoff_fail(struct ptu_decoder_fixture *dfix)
1697 struct pt_query_decoder *decoder = &dfix->decoder;
1698 struct pt_encoder *encoder = &dfix->encoder;
1699 struct pt_event event;
1702 pt_encode_mode_exec(encoder, ptem_16bit);
1703 pt_encode_tip_pge(encoder, 0, pt_ipc_sext_48);
1705 ptu_check(cutoff, decoder, encoder);
1706 ptu_check(ptu_sync_decoder, decoder);
1708 errcode = pt_qry_event(decoder, &event, sizeof(event));
1709 ptu_int_eq(errcode, -pte_eos);
1711 return ptu_passed();
1714 static struct ptunit_result
1715 event_exec_mode_cutoff_fail(struct ptu_decoder_fixture *dfix)
1717 struct pt_query_decoder *decoder = &dfix->decoder;
1718 struct pt_encoder *encoder = &dfix->encoder;
1719 struct pt_event event;
1722 pt_encode_mode_exec(encoder, ptem_64bit);
1724 ptu_check(cutoff, decoder, encoder);
1725 ptu_check(ptu_sync_decoder, decoder);
1727 errcode = pt_qry_event(decoder, &event, sizeof(event));
1728 ptu_int_eq(errcode, -pte_eos);
1730 return ptu_passed();
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)
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;
1745 fup.ip = pt_dfix_max_ip;
1746 pt_last_ip_update_ip(&dfix->last_ip, &fup, &dfix->config);
1748 tip.ipc = pt_ipc_sext_48;
1749 tip.ip = pt_dfix_sext_ip;
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);
1755 ptu_check(ptu_sync_decoder, decoder);
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);
1762 ptu_uint_eq(event.ip_suppressed, 0);
1763 ptu_uint_eq(event.variant.tsx.ip, dfix->last_ip.ip);
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);
1772 ptu_int_eq(event.has_tsc, 0);
1774 ptu_int_eq(event.has_tsc, 1);
1775 ptu_uint_eq(event.tsc, tsc);
1778 errcode = pt_qry_indirect_branch(decoder, &addr);
1779 ptu_int_eq(errcode, pts_eos);
1780 ptu_uint_eq(addr, tip.ip);
1782 return ptu_passed();
1785 static struct ptunit_result
1786 event_tsx_fup_cutoff_fail(struct ptu_decoder_fixture *dfix)
1788 struct pt_query_decoder *decoder = &dfix->decoder;
1789 struct pt_encoder *encoder = &dfix->encoder;
1790 struct pt_event event;
1793 pt_encode_mode_tsx(encoder, 0);
1794 pt_encode_fup(encoder, 0, pt_ipc_update_16);
1796 ptu_check(cutoff, decoder, encoder);
1797 ptu_check(ptu_sync_decoder, decoder);
1799 errcode = pt_qry_event(decoder, &event, sizeof(event));
1800 ptu_int_eq(errcode, -pte_eos);
1802 return ptu_passed();
1805 static struct ptunit_result
1806 event_tsx_cutoff_fail(struct ptu_decoder_fixture *dfix)
1808 struct pt_query_decoder *decoder = &dfix->decoder;
1809 struct pt_encoder *encoder = &dfix->encoder;
1810 struct pt_event event;
1813 pt_encode_mode_tsx(encoder, 0);
1815 ptu_check(cutoff, decoder, encoder);
1816 ptu_check(ptu_sync_decoder, decoder);
1818 errcode = pt_qry_event(decoder, &event, sizeof(event));
1819 ptu_int_eq(errcode, -pte_eos);
1821 return ptu_passed();
1824 static struct ptunit_result
1825 event_skip_tip_fail(struct ptu_decoder_fixture *dfix)
1827 struct pt_query_decoder *decoder = &dfix->decoder;
1828 struct pt_encoder *encoder = &dfix->encoder;
1829 struct pt_event event;
1834 pt_encode_tip(encoder, 0, pt_ipc_sext_48);
1835 /* We omit the actual event - we don't get that far, anyway. */
1837 ptu_check(ptu_sync_decoder, decoder);
1839 errcode = pt_qry_event(decoder, &event, sizeof(event));
1840 ptu_int_eq(errcode, -pte_bad_query);
1841 ptu_ptr_eq(decoder->pos, pos);
1843 return ptu_passed();
1846 static struct ptunit_result
1847 event_skip_tnt_8_fail(struct ptu_decoder_fixture *dfix)
1849 struct pt_query_decoder *decoder = &dfix->decoder;
1850 struct pt_encoder *encoder = &dfix->encoder;
1851 struct pt_event event;
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. */
1858 ptu_check(ptu_sync_decoder, decoder);
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. */
1864 return ptu_passed();
1867 static struct ptunit_result
1868 event_skip_tnt_64_fail(struct ptu_decoder_fixture *dfix)
1870 struct pt_query_decoder *decoder = &dfix->decoder;
1871 struct pt_encoder *encoder = &dfix->encoder;
1872 struct pt_event event;
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. */
1879 ptu_check(ptu_sync_decoder, decoder);
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. */
1885 return ptu_passed();
1888 static struct ptunit_result sync_event(struct ptu_decoder_fixture *dfix,
1889 enum pt_ip_compression ipc)
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;
1899 packet.ip = 0xccull;
1901 pt_last_ip_init(&dfix->last_ip);
1902 pt_last_ip_update_ip(&dfix->last_ip, &packet, &dfix->config);
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);
1909 errcode = pt_qry_sync_forward(decoder, &addr);
1911 case pt_ipc_suppressed:
1912 ptu_int_eq(errcode, (pts_event_pending | pts_ip_suppressed));
1915 case pt_ipc_update_16:
1916 case pt_ipc_update_32:
1917 case pt_ipc_update_48:
1918 case pt_ipc_sext_48:
1920 ptu_int_eq(errcode, pts_event_pending);
1921 ptu_uint_eq(addr, dfix->last_ip.ip);
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);
1931 ptu_uint_eq(event.ip_suppressed, 0);
1932 ptu_uint_eq(event.variant.tsx.ip, dfix->last_ip.ip);
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);
1939 return ptu_passed();
1942 static struct ptunit_result
1943 sync_event_cutoff_fail(struct ptu_decoder_fixture *dfix)
1945 struct pt_query_decoder *decoder = &dfix->decoder;
1946 struct pt_encoder *encoder = &dfix->encoder;
1950 pt_encode_psb(encoder);
1951 pt_encode_psbend(encoder);
1953 ptu_check(cutoff, decoder, encoder);
1955 errcode = pt_qry_sync_forward(decoder, &addr);
1956 ptu_int_eq(errcode, -pte_eos);
1958 return ptu_passed();
1961 static struct ptunit_result
1962 sync_event_incomplete_fail(struct ptu_decoder_fixture *dfix)
1964 struct pt_query_decoder *decoder = &dfix->decoder;
1965 struct pt_encoder *encoder = &dfix->encoder;
1969 pt_encode_psb(encoder);
1971 errcode = pt_qry_sync_forward(decoder, &addr);
1972 ptu_int_eq(errcode, -pte_eos);
1974 return ptu_passed();
1977 static struct ptunit_result sync_ovf_event(struct ptu_decoder_fixture *dfix,
1978 enum pt_ip_compression ipc)
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;
1987 fup.ipc = pt_ipc_sext_48;
1988 fup.ip = pt_dfix_max_ip;
1993 pt_last_ip_init(&dfix->last_ip);
1994 pt_last_ip_update_ip(&dfix->last_ip, &ovf, &dfix->config);
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);
2003 errcode = pt_qry_sync_forward(decoder, &addr);
2004 ptu_int_eq(errcode, pts_event_pending);
2005 ptu_uint_eq(addr, fup.ip);
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);
2017 errcode = pt_qry_event(decoder, &event, sizeof(event));
2019 case pt_ipc_suppressed:
2020 ptu_int_eq(errcode, -pte_noip);
2021 return ptu_passed();
2023 case pt_ipc_update_16:
2024 case pt_ipc_update_32:
2025 case pt_ipc_update_48:
2026 case pt_ipc_sext_48:
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);
2036 return ptu_passed();
2039 static struct ptunit_result
2040 sync_ovf_event_cutoff_fail(struct ptu_decoder_fixture *dfix)
2042 struct pt_query_decoder *decoder = &dfix->decoder;
2043 struct pt_encoder *encoder = &dfix->encoder;
2047 pt_encode_psb(encoder);
2048 pt_encode_ovf(encoder);
2050 ptu_check(cutoff, decoder, encoder);
2052 errcode = pt_qry_sync_forward(decoder, &addr);
2053 ptu_int_eq(errcode, -pte_eos);
2055 return ptu_passed();
2058 static struct ptunit_result time_null_fail(struct ptu_decoder_fixture *dfix)
2060 struct pt_query_decoder *decoder = &dfix->decoder;
2064 errcode = pt_qry_time(NULL, NULL, NULL, NULL);
2065 ptu_int_eq(errcode, -pte_invalid);
2067 errcode = pt_qry_time(decoder, NULL, NULL, NULL);
2068 ptu_int_eq(errcode, -pte_invalid);
2070 errcode = pt_qry_time(NULL, &tsc, NULL, NULL);
2071 ptu_int_eq(errcode, -pte_invalid);
2073 return ptu_passed();
2076 static struct ptunit_result time_initial(struct ptu_decoder_fixture *dfix)
2078 struct pt_query_decoder *decoder = &dfix->decoder;
2082 errcode = pt_qry_time(decoder, &tsc, NULL, NULL);
2083 ptu_int_eq(errcode, -pte_no_time);
2085 return ptu_passed();
2088 static struct ptunit_result time(struct ptu_decoder_fixture *dfix)
2090 struct pt_query_decoder *decoder = &dfix->decoder;
2094 exp = 0x11223344556677ull;
2096 decoder->last_time.have_tsc = 1;
2097 decoder->last_time.tsc = exp;
2099 errcode = pt_qry_time(decoder, &tsc, NULL, NULL);
2100 ptu_int_eq(errcode, 0);
2101 ptu_uint_eq(tsc, exp);
2103 return ptu_passed();
2106 static struct ptunit_result cbr_null(struct ptu_decoder_fixture *dfix)
2108 struct pt_query_decoder *decoder = &dfix->decoder;
2112 errcode = pt_qry_core_bus_ratio(NULL, NULL);
2113 ptu_int_eq(errcode, -pte_invalid);
2115 errcode = pt_qry_core_bus_ratio(decoder, NULL);
2116 ptu_int_eq(errcode, -pte_invalid);
2118 errcode = pt_qry_core_bus_ratio(NULL, &cbr);
2119 ptu_int_eq(errcode, -pte_invalid);
2121 return ptu_passed();
2124 static struct ptunit_result cbr_initial(struct ptu_decoder_fixture *dfix)
2126 struct pt_query_decoder *decoder = &dfix->decoder;
2130 errcode = pt_qry_core_bus_ratio(decoder, &cbr);
2131 ptu_int_eq(errcode, -pte_no_cbr);
2133 return ptu_passed();
2136 static struct ptunit_result cbr(struct ptu_decoder_fixture *dfix)
2138 struct pt_query_decoder *decoder = &dfix->decoder;
2142 decoder->last_time.have_cbr = 1;
2143 decoder->last_time.cbr = 42;
2145 errcode = pt_qry_core_bus_ratio(decoder, &cbr);
2146 ptu_int_eq(errcode, 0);
2147 ptu_uint_eq(cbr, 42);
2149 return ptu_passed();
2152 /* Test that end-of-stream is indicated correctly when the stream ends with a
2153 * partial non-query-relevant packet.
2155 static struct ptunit_result indir_cyc_cutoff(struct ptu_decoder_fixture *dfix)
2157 struct pt_query_decoder *decoder = &dfix->decoder;
2158 struct pt_encoder *encoder = &dfix->encoder;
2162 pt_encode_tip(encoder, 0xa000ull, pt_ipc_full);
2163 pt_encode_cyc(encoder, 0xfff);
2165 ptu_check(cutoff, decoder, encoder);
2166 ptu_check(ptu_sync_decoder, decoder);
2168 errcode = pt_qry_indirect_branch(decoder, &ip);
2169 ptu_int_eq(errcode, pts_eos);
2171 return ptu_passed();
2174 /* Test that end-of-stream is indicated correctly when the stream ends with a
2175 * partial non-query-relevant packet.
2177 static struct ptunit_result cond_cyc_cutoff(struct ptu_decoder_fixture *dfix)
2179 struct pt_query_decoder *decoder = &dfix->decoder;
2180 struct pt_encoder *encoder = &dfix->encoder;
2183 pt_encode_tnt_8(encoder, 0, 1);
2184 pt_encode_cyc(encoder, 0xfff);
2186 ptu_check(cutoff, decoder, encoder);
2187 ptu_check(ptu_sync_decoder, decoder);
2189 errcode = pt_qry_cond_branch(decoder, &taken);
2190 ptu_int_eq(errcode, pts_eos);
2192 return ptu_passed();
2195 /* Test that end-of-stream is indicated correctly when the stream ends with a
2196 * partial non-query-relevant packet.
2198 static struct ptunit_result event_cyc_cutoff(struct ptu_decoder_fixture *dfix)
2200 struct pt_query_decoder *decoder = &dfix->decoder;
2201 struct pt_encoder *encoder = &dfix->encoder;
2202 struct pt_event event;
2205 pt_encode_tip_pgd(encoder, 0ull, pt_ipc_full);
2206 pt_encode_cyc(encoder, 0xffff);
2208 ptu_check(cutoff, decoder, encoder);
2209 ptu_check(ptu_sync_decoder, decoder);
2211 errcode = pt_qry_event(decoder, &event, sizeof(event));
2212 ptu_int_eq(errcode, pts_eos);
2214 return ptu_passed();
2217 static struct ptunit_result ptu_dfix_init(struct ptu_decoder_fixture *dfix)
2219 struct pt_config *config = &dfix->config;
2222 (void) memset(dfix->buffer, 0, sizeof(dfix->buffer));
2224 pt_config_init(config);
2226 config->begin = dfix->buffer;
2227 config->end = dfix->buffer + sizeof(dfix->buffer);
2229 errcode = pt_encoder_init(&dfix->encoder, config);
2230 ptu_int_eq(errcode, 0);
2232 errcode = pt_qry_decoder_init(&dfix->decoder, config);
2233 ptu_int_eq(errcode, 0);
2235 dfix->decoder.ip.ip = pt_dfix_bad_ip;
2236 dfix->decoder.ip.have_ip = 1;
2237 dfix->decoder.ip.suppressed = 0;
2239 dfix->last_ip = dfix->decoder.ip;
2244 return ptu_passed();
2247 static struct ptunit_result ptu_dfix_fini(struct ptu_decoder_fixture *dfix)
2249 pt_qry_decoder_fini(&dfix->decoder);
2250 pt_encoder_fini(&dfix->encoder);
2252 return ptu_passed();
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)
2259 struct pt_query_decoder *decoder = &dfix->decoder;
2261 /* Synchronize the decoder at the beginning of the buffer. */
2262 decoder->pos = decoder->config.begin;
2264 return ptu_passed();
2267 /* Synchronize the decoder at the beginnig of a buffer containing packets that
2268 * should be skipped for unconditional indirect branch queries.
2270 static struct ptunit_result
2271 ptu_dfix_header_indir(struct ptu_decoder_fixture *dfix)
2273 struct pt_query_decoder *decoder = &dfix->decoder;
2274 struct pt_encoder *encoder = &dfix->encoder;
2276 pt_encode_pad(encoder);
2277 pt_encode_mtc(encoder, 1);
2278 pt_encode_pad(encoder);
2279 pt_encode_tsc(encoder, 0);
2281 /* Synchronize the decoder at the beginning of the buffer. */
2282 decoder->pos = decoder->config.begin;
2284 return ptu_passed();
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.
2290 static struct ptunit_result
2291 ptu_dfix_header_indir_psb(struct ptu_decoder_fixture *dfix)
2293 struct pt_query_decoder *decoder = &dfix->decoder;
2294 struct pt_encoder *encoder = &dfix->encoder;
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.
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);
2311 /* Synchronize the decoder at the beginning of the buffer. */
2312 decoder->pos = decoder->config.begin;
2314 return ptu_passed();
2317 /* Synchronize the decoder at the beginnig of a buffer containing packets that
2318 * should be skipped for conditional branch queries.
2320 static struct ptunit_result
2321 ptu_dfix_header_cond(struct ptu_decoder_fixture *dfix)
2323 struct pt_query_decoder *decoder = &dfix->decoder;
2324 struct pt_encoder *encoder = &dfix->encoder;
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.
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);
2341 /* Synchronize the decoder at the beginning of the buffer. */
2342 decoder->pos = decoder->config.begin;
2344 return ptu_passed();
2347 /* Synchronize the decoder at the beginnig of a buffer containing packets that
2348 * should be skipped for event queries.
2350 static struct ptunit_result
2351 ptu_dfix_header_event(struct ptu_decoder_fixture *dfix)
2353 struct pt_query_decoder *decoder = &dfix->decoder;
2354 struct pt_encoder *encoder = &dfix->encoder;
2356 pt_encode_pad(encoder);
2357 pt_encode_mtc(encoder, 1);
2358 pt_encode_pad(encoder);
2359 pt_encode_tsc(encoder, 0x1000);
2361 /* Synchronize the decoder at the beginning of the buffer. */
2362 decoder->pos = decoder->config.begin;
2364 return ptu_passed();
2367 /* Synchronize the decoder at the beginnig of a buffer containing packets that
2368 * should be skipped for event queries including a PSB.
2370 static struct ptunit_result
2371 ptu_dfix_header_event_psb(struct ptu_decoder_fixture *dfix)
2373 struct pt_query_decoder *decoder = &dfix->decoder;
2374 struct pt_encoder *encoder = &dfix->encoder;
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.
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);
2391 /* Synchronize the decoder at the beginning of the buffer. */
2392 decoder->pos = decoder->config.begin;
2394 return ptu_passed();
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;
2405 static void init_fixtures(void)
2407 dfix_raw.init = ptu_dfix_init;
2408 dfix_raw.fini = ptu_dfix_fini;
2410 dfix_empty = dfix_raw;
2411 dfix_empty.header = ptu_dfix_header_sync;
2413 dfix_indir = dfix_raw;
2414 dfix_indir.header = ptu_dfix_header_indir;
2416 dfix_indir_psb = dfix_raw;
2417 dfix_indir_psb.header = ptu_dfix_header_indir_psb;
2419 dfix_cond = dfix_raw;
2420 dfix_cond.header = ptu_dfix_header_cond;
2422 dfix_event = dfix_raw;
2423 dfix_event.header = ptu_dfix_header_event;
2425 dfix_event_psb = dfix_raw;
2426 dfix_event_psb.header = ptu_dfix_header_event_psb;
2429 int main(int argc, char **argv)
2431 struct ptunit_suite suite;
2435 suite = ptunit_mk_suite(argc, argv);
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);
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);
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);
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);
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);
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);
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);
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,
2537 ptu_run_fp(suite, event_async_disabled, dfix_empty, pt_ipc_update_16,
2539 ptu_run_fp(suite, event_async_disabled, dfix_empty, pt_ipc_update_32,
2541 ptu_run_fp(suite, event_async_disabled, dfix_empty, pt_ipc_update_48,
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,
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,
2576 ptu_run_fp(suite, event_overflow_tip_pge, dfix_empty, pt_ipc_update_32,
2578 ptu_run_fp(suite, event_overflow_tip_pge, dfix_empty, pt_ipc_update_48,
2580 ptu_run_fp(suite, event_overflow_tip_pge, dfix_empty, pt_ipc_sext_48,
2582 ptu_run_fp(suite, event_overflow_tip_pge, dfix_empty, pt_ipc_full,
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,
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,
2604 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_empty, pt_ipc_full,
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);
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,
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,
2655 ptu_run_fp(suite, event_async_disabled, dfix_event, pt_ipc_update_16,
2657 ptu_run_fp(suite, event_async_disabled, dfix_event, pt_ipc_update_32,
2659 ptu_run_fp(suite, event_async_disabled, dfix_event, pt_ipc_update_48,
2661 ptu_run_fp(suite, event_async_disabled, dfix_event, pt_ipc_sext_48,
2663 ptu_run_fp(suite, event_async_disabled, dfix_event, pt_ipc_full,
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,
2670 ptu_run_fp(suite, event_async_branch, dfix_event, pt_ipc_update_16,
2672 ptu_run_fp(suite, event_async_branch, dfix_event, pt_ipc_update_32,
2674 ptu_run_fp(suite, event_async_branch, dfix_event, pt_ipc_update_48,
2676 ptu_run_fp(suite, event_async_branch, dfix_event, pt_ipc_sext_48,
2678 ptu_run_fp(suite, event_async_branch, dfix_event, pt_ipc_full,
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,
2694 ptu_run_fp(suite, event_overflow_fup, dfix_event, pt_ipc_update_16,
2696 ptu_run_fp(suite, event_overflow_fup, dfix_event, pt_ipc_update_32,
2698 ptu_run_fp(suite, event_overflow_fup, dfix_event, pt_ipc_update_48,
2700 ptu_run_fp(suite, event_overflow_fup, dfix_event, pt_ipc_sext_48,
2702 ptu_run_fp(suite, event_overflow_fup, dfix_event, pt_ipc_full,
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,
2708 ptu_run_fp(suite, event_overflow_tip_pge, dfix_event, pt_ipc_update_32,
2710 ptu_run_fp(suite, event_overflow_tip_pge, dfix_event, pt_ipc_update_48,
2712 ptu_run_fp(suite, event_overflow_tip_pge, dfix_event, pt_ipc_sext_48,
2714 ptu_run_fp(suite, event_overflow_tip_pge, dfix_event, pt_ipc_full,
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,
2720 ptu_run_fp(suite, event_exec_mode_tip, dfix_event, pt_ipc_update_16,
2722 ptu_run_fp(suite, event_exec_mode_tip, dfix_event, pt_ipc_update_32,
2724 ptu_run_fp(suite, event_exec_mode_tip, dfix_event, pt_ipc_update_48,
2726 ptu_run_fp(suite, event_exec_mode_tip, dfix_event, pt_ipc_sext_48,
2728 ptu_run_fp(suite, event_exec_mode_tip, dfix_event, pt_ipc_full,
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,
2741 ptu_run_fp(suite, event_exec_mode_tip_pge, dfix_event, pt_ipc_full,
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,
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,
2751 ptu_run_fp(suite, event_tsx_fup, dfix_event, pt_ipc_update_48, 0,
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);
2778 ptu_run_fp(suite, event_enabled, dfix_event_psb, pt_ipc_suppressed,
2780 ptu_run_fp(suite, event_enabled, dfix_event_psb, pt_ipc_sext_48,
2782 ptu_run_fp(suite, event_enabled, dfix_event_psb, pt_ipc_full,
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,
2787 ptu_run_fp(suite, event_disabled, dfix_event_psb, pt_ipc_sext_48,
2789 ptu_run_fp(suite, event_disabled, dfix_event_psb, pt_ipc_full,
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,
2811 ptu_run_fp(suite, event_async_branch, dfix_event_psb, pt_ipc_update_32,
2813 ptu_run_fp(suite, event_async_branch, dfix_event_psb, pt_ipc_update_48,
2815 ptu_run_fp(suite, event_async_branch, dfix_event_psb, pt_ipc_sext_48,
2817 ptu_run_fp(suite, event_async_branch, dfix_event_psb, pt_ipc_full,
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,
2828 ptu_run_fp(suite, event_async_paging_suppressed, dfix_event_psb, 0,
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,
2839 ptu_run_fp(suite, event_exec_mode_tip, dfix_event_psb, pt_ipc_full,
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,
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);
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);
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);
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);
2872 return ptunit_report(&suite);