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 */
ptu_sync_decoder(struct pt_query_decoder * decoder)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. */
cutoff(struct pt_query_decoder * decoder,const struct pt_encoder * encoder)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
indir_not_synced(struct ptu_decoder_fixture * dfix)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
cond_not_synced(struct ptu_decoder_fixture * dfix)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
event_not_synced(struct ptu_decoder_fixture * dfix)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
sync_backward(struct ptu_decoder_fixture * dfix)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
sync_backward_empty_end(struct ptu_decoder_fixture * dfix)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
sync_backward_empty_mid(struct ptu_decoder_fixture * dfix)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
sync_backward_empty_begin(struct ptu_decoder_fixture * dfix)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
decode_sync_backward(struct ptu_decoder_fixture * dfix)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
indir_null(struct ptu_decoder_fixture * dfix)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
indir_empty(struct ptu_decoder_fixture * dfix)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
indir(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc)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
indir_tnt(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc)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
indir_cutoff_fail(struct ptu_decoder_fixture * dfix)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
indir_skip_tnt_fail(struct ptu_decoder_fixture * dfix)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
indir_skip_tip_pge_fail(struct ptu_decoder_fixture * dfix)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
indir_skip_tip_pgd_fail(struct ptu_decoder_fixture * dfix)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
indir_skip_fup_tip_fail(struct ptu_decoder_fixture * dfix)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
indir_skip_fup_tip_pgd_fail(struct ptu_decoder_fixture * dfix)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
cond_null(struct ptu_decoder_fixture * dfix)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
cond_empty(struct ptu_decoder_fixture * dfix)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
cond(struct ptu_decoder_fixture * dfix)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
cond_skip_tip_fail(struct ptu_decoder_fixture * dfix)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
cond_skip_tip_pge_fail(struct ptu_decoder_fixture * dfix)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
cond_skip_tip_pgd_fail(struct ptu_decoder_fixture * dfix)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
cond_skip_fup_tip_fail(struct ptu_decoder_fixture * dfix)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
cond_skip_fup_tip_pgd_fail(struct ptu_decoder_fixture * dfix)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
event_null(struct ptu_decoder_fixture * dfix)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
event_bad_size(struct ptu_decoder_fixture * dfix)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
event_small_size(struct ptu_decoder_fixture * dfix)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
event_big_size(struct ptu_decoder_fixture * dfix)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
event_empty(struct ptu_decoder_fixture * dfix)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
event_enabled(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc,uint64_t tsc)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
event_enabled_cutoff_fail(struct ptu_decoder_fixture * dfix)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
event_disabled(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc,uint64_t tsc)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
event_disabled_cutoff_fail(struct ptu_decoder_fixture * dfix)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
event_async_disabled(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc,uint64_t tsc)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
event_async_disabled_suppressed_fail(struct ptu_decoder_fixture * dfix)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
event_async_disabled_cutoff_fail_a(struct ptu_decoder_fixture * dfix)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
event_async_disabled_cutoff_fail_b(struct ptu_decoder_fixture * dfix)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
event_async_branch_suppressed_fail(struct ptu_decoder_fixture * dfix)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
event_async_branch(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc,uint64_t tsc)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
event_async_branch_cutoff_fail_a(struct ptu_decoder_fixture * dfix)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
event_async_branch_cutoff_fail_b(struct ptu_decoder_fixture * dfix)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
event_paging(struct ptu_decoder_fixture * dfix,uint8_t flags,uint64_t tsc)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
event_paging_cutoff_fail(struct ptu_decoder_fixture * dfix)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
event_async_paging(struct ptu_decoder_fixture * dfix,uint8_t flags,uint64_t tsc)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
event_async_paging_suppressed(struct ptu_decoder_fixture * dfix,uint8_t flags,uint64_t tsc)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
event_async_paging_cutoff_fail(struct ptu_decoder_fixture * dfix)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
event_overflow_fup(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc,uint64_t tsc)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
event_overflow_tip_pge(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc,uint64_t tsc)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
event_overflow_cutoff_fail(struct ptu_decoder_fixture * dfix)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
event_stop(struct ptu_decoder_fixture * dfix,uint64_t tsc)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
event_exec_mode_tip(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc,uint64_t tsc)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
event_exec_mode_tip_cutoff_fail(struct ptu_decoder_fixture * dfix)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
event_exec_mode_tip_pge(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc,uint64_t tsc)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
event_exec_mode_tip_pge_cutoff_fail(struct ptu_decoder_fixture * dfix)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
event_exec_mode_cutoff_fail(struct ptu_decoder_fixture * dfix)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
event_tsx_fup(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc,uint8_t flags,uint64_t tsc)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
event_tsx_fup_cutoff_fail(struct ptu_decoder_fixture * dfix)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
event_tsx_cutoff_fail(struct ptu_decoder_fixture * dfix)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
event_skip_tip_fail(struct ptu_decoder_fixture * dfix)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
event_skip_tnt_8_fail(struct ptu_decoder_fixture * dfix)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
event_skip_tnt_64_fail(struct ptu_decoder_fixture * dfix)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
sync_event(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc)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
sync_event_cutoff_fail(struct ptu_decoder_fixture * dfix)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
sync_event_incomplete_fail(struct ptu_decoder_fixture * dfix)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
sync_ovf_event(struct ptu_decoder_fixture * dfix,enum pt_ip_compression ipc)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
sync_ovf_event_cutoff_fail(struct ptu_decoder_fixture * dfix)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
time_null_fail(struct ptu_decoder_fixture * dfix)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
time_initial(struct ptu_decoder_fixture * dfix)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
time(struct ptu_decoder_fixture * dfix)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
cbr_null(struct ptu_decoder_fixture * dfix)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
cbr_initial(struct ptu_decoder_fixture * dfix)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
cbr(struct ptu_decoder_fixture * dfix)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 */
indir_cyc_cutoff(struct ptu_decoder_fixture * dfix)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 */
cond_cyc_cutoff(struct ptu_decoder_fixture * dfix)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 */
event_cyc_cutoff(struct ptu_decoder_fixture * dfix)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
ptu_dfix_init(struct ptu_decoder_fixture * dfix)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
ptu_dfix_fini(struct ptu_decoder_fixture * dfix)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
ptu_dfix_header_sync(struct ptu_decoder_fixture * dfix)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
ptu_dfix_header_indir(struct ptu_decoder_fixture * dfix)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
ptu_dfix_header_indir_psb(struct ptu_decoder_fixture * dfix)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
ptu_dfix_header_cond(struct ptu_decoder_fixture * dfix)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
ptu_dfix_header_event(struct ptu_decoder_fixture * dfix)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
ptu_dfix_header_event_psb(struct ptu_decoder_fixture * dfix)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
init_fixtures(void)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
main(int argc,char ** argv)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