Lines Matching defs:decoder
48 static int pt_blk_status(const struct pt_block_decoder *decoder, int flags)
52 if (!decoder)
55 status = decoder->status;
62 if (!decoder->enabled)
69 if ((status & pts_eos) && !decoder->process_event)
75 static void pt_blk_reset(struct pt_block_decoder *decoder)
77 if (!decoder)
80 decoder->mode = ptem_unknown;
81 decoder->ip = 0ull;
82 decoder->status = 0;
83 decoder->enabled = 0;
84 decoder->process_event = 0;
85 decoder->speculative = 0;
86 decoder->process_insn = 0;
87 decoder->bound_paging = 0;
88 decoder->bound_vmcs = 0;
89 decoder->bound_ptwrite = 0;
91 memset(&decoder->event, 0, sizeof(decoder->event));
92 pt_retstack_init(&decoder->retstack);
93 pt_asid_init(&decoder->asid);
96 /* Initialize the query decoder flags based on our flags. */
111 int pt_blk_decoder_init(struct pt_block_decoder *decoder,
117 if (!decoder)
124 /* The user supplied decoder flags. */
125 decoder->flags = config.flags;
127 /* Set the flags we need for the query decoder we use. */
128 errcode = pt_blk_init_qry_flags(&config.flags, &decoder->flags);
132 errcode = pt_qry_decoder_init(&decoder->query, &config);
136 pt_image_init(&decoder->default_image, NULL);
137 decoder->image = &decoder->default_image;
139 errcode = pt_msec_cache_init(&decoder->scache);
143 pt_blk_reset(decoder);
148 void pt_blk_decoder_fini(struct pt_block_decoder *decoder)
150 if (!decoder)
153 pt_msec_cache_fini(&decoder->scache);
154 pt_image_fini(&decoder->default_image);
155 pt_qry_decoder_fini(&decoder->query);
161 struct pt_block_decoder *decoder;
164 decoder = malloc(sizeof(*decoder));
165 if (!decoder)
168 errcode = pt_blk_decoder_init(decoder, config);
170 free(decoder);
174 return decoder;
177 void pt_blk_free_decoder(struct pt_block_decoder *decoder)
179 if (!decoder)
182 pt_blk_decoder_fini(decoder);
183 free(decoder);
195 static int pt_blk_tick(struct pt_block_decoder *decoder, uint64_t ip)
202 if (!decoder)
206 if (!decoder->enabled)
220 if (decoder->process_event)
223 errcode = pt_qry_time(&decoder->query, &tsc, &lost_mtc, &lost_cyc);
230 ev = &decoder->event;
249 decoder->process_event = 1;
258 static int pt_blk_indirect_branch(struct pt_block_decoder *decoder,
264 if (!decoder)
267 evip = decoder->ip;
269 status = pt_qry_indirect_branch(&decoder->query, ip);
273 if (decoder->flags.variant.block.enable_tick_events) {
274 errcode = pt_blk_tick(decoder, evip);
286 static int pt_blk_cond_branch(struct pt_block_decoder *decoder, int *taken)
290 if (!decoder)
293 status = pt_qry_cond_branch(&decoder->query, taken);
297 if (decoder->flags.variant.block.enable_tick_events) {
298 errcode = pt_blk_tick(decoder, decoder->ip);
306 static int pt_blk_start(struct pt_block_decoder *decoder, int status)
308 if (!decoder)
314 decoder->status = status;
316 decoder->enabled = 1;
326 return pt_blk_proceed_trailing_event(decoder, NULL);
329 static int pt_blk_sync_reset(struct pt_block_decoder *decoder)
331 if (!decoder)
334 pt_blk_reset(decoder);
339 int pt_blk_sync_forward(struct pt_block_decoder *decoder)
343 if (!decoder)
346 errcode = pt_blk_sync_reset(decoder);
350 status = pt_qry_sync_forward(&decoder->query, &decoder->ip);
352 return pt_blk_start(decoder, status);
355 int pt_blk_sync_backward(struct pt_block_decoder *decoder)
359 if (!decoder)
362 errcode = pt_blk_sync_reset(decoder);
366 status = pt_qry_sync_backward(&decoder->query, &decoder->ip);
368 return pt_blk_start(decoder, status);
371 int pt_blk_sync_set(struct pt_block_decoder *decoder, uint64_t offset)
375 if (!decoder)
378 errcode = pt_blk_sync_reset(decoder);
382 status = pt_qry_sync_set(&decoder->query, &decoder->ip, offset);
384 return pt_blk_start(decoder, status);
387 int pt_blk_get_offset(const struct pt_block_decoder *decoder, uint64_t *offset)
389 if (!decoder)
392 return pt_qry_get_offset(&decoder->query, offset);
395 int pt_blk_get_sync_offset(const struct pt_block_decoder *decoder,
398 if (!decoder)
401 return pt_qry_get_sync_offset(&decoder->query, offset);
404 struct pt_image *pt_blk_get_image(struct pt_block_decoder *decoder)
406 if (!decoder)
409 return decoder->image;
412 int pt_blk_set_image(struct pt_block_decoder *decoder, struct pt_image *image)
414 if (!decoder)
418 image = &decoder->default_image;
420 decoder->image = image;
425 pt_blk_get_config(const struct pt_block_decoder *decoder)
427 if (!decoder)
430 return pt_qry_get_config(&decoder->query);
433 int pt_blk_time(struct pt_block_decoder *decoder, uint64_t *time,
436 if (!decoder || !time)
439 return pt_qry_time(&decoder->query, time, lost_mtc, lost_cyc);
442 int pt_blk_core_bus_ratio(struct pt_block_decoder *decoder, uint32_t *cbr)
444 if (!decoder || !cbr)
447 return pt_qry_core_bus_ratio(&decoder->query, cbr);
450 int pt_blk_asid(const struct pt_block_decoder *decoder, struct pt_asid *asid,
453 if (!decoder || !asid)
456 return pt_asid_to_user(asid, &decoder->asid, size);
468 static inline int pt_blk_fetch_event(struct pt_block_decoder *decoder)
472 if (!decoder)
475 if (decoder->process_event)
478 if (!(decoder->status & pts_event_pending))
481 status = pt_qry_event(&decoder->query, &decoder->event,
482 sizeof(decoder->event));
486 decoder->process_event = 1;
487 decoder->status = status;
541 * Does not update @decoder->status. The caller is expected to do that.
545 * Returns -pte_internal if @pip, @decoder, @insn, or @iext are NULL.
548 static int pt_blk_next_ip(uint64_t *pip, struct pt_block_decoder *decoder,
554 if (!pip || !decoder || !insn || !iext)
567 status = pt_blk_cond_branch(decoder, &taken);
584 status = pt_blk_cond_branch(decoder, &taken);
598 errcode = pt_retstack_pop(&decoder->retstack, pip);
631 return pt_blk_indirect_branch(decoder, pip);
641 static int pt_blk_proceed_with_trace(struct pt_block_decoder *decoder,
647 if (!decoder)
650 status = pt_blk_next_ip(&decoder->ip, decoder, insn, iext);
654 /* Preserve the query decoder's response which indicates upcoming
657 decoder->status = status;
702 static inline int pt_blk_log_call(struct pt_block_decoder *decoder,
706 if (!decoder || !insn || !iext)
719 return pt_retstack_push(&decoder->retstack, insn->ip + insn->size);
724 * Tries to decode the instruction at @decoder->ip and, on success, adds it to
738 static int pt_blk_proceed_one_insn(struct pt_block_decoder *decoder,
748 if (!decoder || !block || !pinsn || !piext)
763 insn.mode = decoder->mode;
764 insn.ip = decoder->ip;
766 status = pt_insn_decode(&insn, &iext, decoder->image, &decoder->asid);
788 status = pt_blk_log_call(decoder, &insn, &iext);
816 * Update @decoder->ip to point to the last IP that was reached. If we fail due
824 static int pt_blk_proceed_to_insn(struct pt_block_decoder *decoder,
833 if (!decoder || !insn || !predicate)
837 status = pt_blk_proceed_one_insn(decoder, block, insn, iext);
849 status = pt_insn_next_ip(&decoder->ip, insn, iext);
859 if ((decoder->flags.variant.block.end_on_call &&
861 (decoder->flags.variant.block.end_on_jump &&
878 * Update @decoder->ip to point to the last IP that was reached. If we fail due
886 static int pt_blk_proceed_to_ip(struct pt_block_decoder *decoder,
892 if (!decoder || !insn)
899 if (decoder->ip == ip)
902 status = pt_blk_proceed_one_insn(decoder, block, insn, iext);
907 status = pt_insn_next_ip(&decoder->ip, insn, iext);
920 if ((decoder->flags.variant.block.end_on_call &&
922 (decoder->flags.variant.block.end_on_jump &&
924 return (decoder->ip == ip ? 1 : 0);
937 * Update @decoder->ip to point to the last IP that was reached.
945 static int pt_blk_proceed_to_ip_with_trace(struct pt_block_decoder *decoder,
958 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext, ip);
965 return pt_blk_proceed_with_trace(decoder, &insn, &iext);
1004 static int pt_blk_proceed_skl014(struct pt_block_decoder *decoder,
1011 if (!decoder || !block || !insn || !iext)
1014 addr_filter = &decoder->query.config.addr_filter;
1018 status = pt_blk_proceed_to_insn(decoder, block, insn, iext,
1050 decoder->ip = ip;
1058 if ((decoder->flags.variant.block.end_on_call &&
1060 (decoder->flags.variant.block.end_on_jump &&
1079 static int pt_blk_proceed_to_disabled(struct pt_block_decoder *decoder,
1085 if (!decoder || !block || !ev)
1097 if (decoder->query.config.addr_filter.config.addr_cfg &&
1098 decoder->query.config.errata.skl014)
1099 return pt_blk_proceed_skl014(decoder, block, insn,
1108 return pt_blk_proceed_to_insn(decoder, block, insn, iext,
1111 return pt_blk_proceed_to_ip(decoder, block, insn, iext,
1117 * On a synchronous disable, @decoder->ip still points to the instruction to
1125 static int pt_blk_set_disable_resume_ip(struct pt_block_decoder *decoder,
1128 if (!decoder || !insn)
1134 decoder->ip = insn->ip + insn->size;
1138 decoder->ip = 0ull;
1155 static int pt_blk_proceed_to_async_paging(struct pt_block_decoder *decoder,
1161 if (!decoder || !ev)
1168 status = pt_blk_proceed_to_ip_with_trace(decoder, block,
1174 return (decoder->ip == ev->variant.async_paging.ip ? 1 : 0);
1187 static int pt_blk_proceed_to_async_vmcs(struct pt_block_decoder *decoder,
1193 if (!decoder || !ev)
1200 status = pt_blk_proceed_to_ip_with_trace(decoder, block,
1206 return (decoder->ip == ev->variant.async_vmcs.ip ? 1 : 0);
1219 static int pt_blk_proceed_to_exec_mode(struct pt_block_decoder *decoder,
1225 if (!decoder || !ev)
1232 status = pt_blk_proceed_to_ip_with_trace(decoder, block,
1238 return (decoder->ip == ev->variant.exec_mode.ip ? 1 : 0);
1256 static int pt_blk_proceed_to_ptwrite(struct pt_block_decoder *decoder,
1277 * the last instruction in the current block and @decoder->ip will point
1281 status = pt_blk_proceed_to_insn(decoder, block, insn, iext,
1293 status = pt_blk_proceed_to_ip(decoder, block, insn, iext,
1298 /* We reached the PTWRITE instruction and @decoder->ip points to
1305 status = pt_blk_proceed_one_insn(decoder, block, insn, iext);
1322 static int pt_blk_handle_erratum_skd022(struct pt_block_decoder *decoder,
1329 if (!decoder || !ev)
1332 insn.mode = decoder->mode;
1335 errcode = pt_insn_decode(&insn, &iext, decoder->image, &decoder->asid);
1367 static int pt_blk_postpone_insn(struct pt_block_decoder *decoder,
1371 if (!decoder || !insn || !iext)
1375 if (decoder->process_insn)
1378 decoder->process_insn = 1;
1379 decoder->insn = *insn;
1380 decoder->iext = *iext;
1382 return pt_blk_status(decoder, pts_event_pending);
1385 /* Remove any postponed instruction from @decoder.
1389 static int pt_blk_clear_postponed_insn(struct pt_block_decoder *decoder)
1391 if (!decoder)
1394 decoder->process_insn = 0;
1395 decoder->bound_paging = 0;
1396 decoder->bound_vmcs = 0;
1397 decoder->bound_ptwrite = 0;
1404 * If an instruction has been postponed in @decoder, proceed past it.
1408 static int pt_blk_proceed_postponed_insn(struct pt_block_decoder *decoder)
1412 if (!decoder)
1416 if (!decoder->process_insn)
1420 if (!decoder->enabled)
1421 return pt_blk_clear_postponed_insn(decoder);
1423 status = pt_insn_next_ip(&decoder->ip, &decoder->insn, &decoder->iext);
1428 status = pt_blk_proceed_with_trace(decoder, &decoder->insn,
1429 &decoder->iext);
1434 return pt_blk_clear_postponed_insn(decoder);
1455 static int pt_blk_proceed_event(struct pt_block_decoder *decoder,
1463 if (!decoder || !decoder->process_event || !block)
1466 ev = &decoder->event;
1472 status = pt_blk_proceed_to_disabled(decoder, block, &insn,
1482 status = pt_blk_set_disable_resume_ip(decoder, &insn);
1490 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext,
1495 if (decoder->query.config.errata.skd022) {
1496 status = pt_blk_handle_erratum_skd022(decoder, ev);
1504 return pt_blk_proceed_event(decoder, block);
1511 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext,
1519 if (!decoder->enabled)
1522 status = pt_blk_proceed_to_insn(decoder, block, &insn, &iext,
1530 decoder->bound_paging = 1;
1532 return pt_blk_postpone_insn(decoder, &insn, &iext);
1535 status = pt_blk_proceed_to_async_paging(decoder, block, ev);
1542 if (!decoder->enabled)
1545 status = pt_blk_proceed_to_insn(decoder, block, &insn, &iext,
1553 decoder->bound_vmcs = 1;
1555 return pt_blk_postpone_insn(decoder, &insn, &iext);
1558 status = pt_blk_proceed_to_async_vmcs(decoder, block, ev);
1568 status = pt_blk_proceed_to_exec_mode(decoder, block, ev);
1578 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext,
1589 if (!decoder->enabled || ev->ip_suppressed)
1592 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext,
1600 if (!decoder->enabled || ev->ip_suppressed)
1603 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext,
1615 if (!decoder->enabled)
1618 status = pt_blk_proceed_to_ptwrite(decoder, block, &insn,
1626 decoder->bound_ptwrite = 1;
1628 return pt_blk_postpone_insn(decoder, &insn, &iext);
1636 return pt_blk_status(decoder, pts_event_pending);
1648 * block. This only updates @decoder's internal state, though.
1652 static int pt_blk_proceed_no_event_uncached(struct pt_block_decoder *decoder,
1659 if (!decoder || !block)
1669 status = pt_blk_proceed_to_insn(decoder, block, &insn, &iext,
1675 return pt_blk_proceed_with_trace(decoder, &insn, &iext);
1760 /* Proceed to the next instruction and fill the block cache for @decoder->ip.
1775 pt_blk_proceed_no_event_fill_cache(struct pt_block_decoder *decoder,
1788 if (!decoder || !steps)
1796 status = pt_blk_proceed_one_insn(decoder, block, &insn, &iext);
1806 status = pt_insn_next_ip(&decoder->ip, &insn, &iext);
1871 return pt_blk_proceed_with_trace(decoder, &insn, &iext);
1875 nip = decoder->ip;
1893 * @decoder->flags.variant.block.end_on_call is set, though.
1945 decoder->flags.variant.block.end_on_jump)
1981 status = pt_blk_proceed_no_event_fill_cache(decoder, block,
2052 * We were not able to decode the instruction at @decoder->ip in @decoder's
2061 static int pt_blk_proceed_truncated(struct pt_block_decoder *decoder,
2068 if (!decoder || !block)
2074 insn.mode = decoder->mode;
2075 insn.ip = decoder->ip;
2077 errcode = pt_insn_decode(&insn, &iext, decoder->image, &decoder->asid);
2092 errcode = pt_blk_log_call(decoder, &insn, &iext);
2101 errcode = pt_insn_next_ip(&decoder->ip, &insn, &iext);
2106 return pt_blk_proceed_with_trace(decoder, &insn, &iext);
2124 * block. This only updates @decoder's internal state, though.
2128 static int pt_blk_proceed_no_event_cached(struct pt_block_decoder *decoder,
2138 if (!decoder || !block)
2141 offset = pt_msec_unmap(msec, decoder->ip);
2148 return pt_blk_proceed_no_event_fill_cache(decoder, block,
2172 nip = decoder->ip + (uint64_t) (int64_t) bce.displacement;
2174 return pt_blk_proceed_no_event_uncached(decoder, block);
2195 decoder->ip = nip;
2218 return pt_blk_proceed_no_event_cached(decoder, block, bcache,
2237 * the instruction at @decoder->ip.
2243 status = pt_blk_cond_branch(decoder, &taken);
2247 /* Preserve the query decoder's response which indicates
2250 decoder->status = status;
2252 ip = decoder->ip;
2272 decoder->ip = ip + bce.isize;
2281 /* We need to decode the instruction at @decoder->ip and decide
2292 insn.ip = decoder->ip;
2299 return pt_blk_proceed_truncated(decoder, block);
2306 status = pt_blk_log_call(decoder, &insn, &iext);
2315 status = pt_insn_next_ip(&decoder->ip, &insn, &iext);
2323 return pt_blk_proceed_with_trace(decoder, &insn, &iext);
2332 if ((decoder->flags.variant.block.end_on_call &&
2334 (decoder->flags.variant.block.end_on_jump &&
2343 if (!pt_blk_is_in_section(msec, decoder->ip))
2346 return pt_blk_proceed_no_event_cached(decoder, block, bcache,
2359 ip = decoder->ip;
2383 status = pt_retstack_push(&decoder->retstack, ip);
2387 status = pt_blk_indirect_branch(decoder, &decoder->ip);
2391 /* Preserve the query decoder's response which indicates
2394 decoder->status = status;
2405 status = pt_blk_cond_branch(decoder, &taken);
2413 status = pt_blk_indirect_branch(decoder, &decoder->ip);
2417 /* Preserve the query decoder's response which indicates
2420 decoder->status = status;
2424 /* Preserve the query decoder's response which indicates
2427 decoder->status = status;
2435 return pt_retstack_pop(&decoder->retstack, &decoder->ip);
2454 status = pt_blk_indirect_branch(decoder, &decoder->ip);
2458 /* Preserve the query decoder's response which indicates
2461 decoder->status = status;
2468 static int pt_blk_msec_fill(struct pt_block_decoder *decoder,
2475 if (!decoder || !pmsec)
2478 isid = pt_msec_cache_fill(&decoder->scache, &msec, decoder->image,
2479 &decoder->asid, decoder->ip);
2496 static inline int pt_blk_msec_lookup(struct pt_block_decoder *decoder,
2501 if (!decoder)
2504 isid = pt_msec_cache_read(&decoder->scache, pmsec, decoder->image,
2505 decoder->ip);
2510 return pt_blk_msec_fill(decoder, pmsec);
2525 * block. This only updates @decoder's internal state, though.
2529 static int pt_blk_proceed_no_event(struct pt_block_decoder *decoder,
2537 if (!decoder || !block)
2540 isid = pt_blk_msec_lookup(decoder, &msec);
2548 return pt_blk_proceed_no_event_uncached(decoder, block);
2565 return pt_blk_proceed_no_event_uncached(decoder, block);
2567 return pt_blk_proceed_no_event_cached(decoder, block, bcache, msec);
2575 static int pt_blk_proceed(struct pt_block_decoder *decoder,
2580 status = pt_blk_fetch_event(decoder);
2585 return pt_blk_proceed_event(decoder, block);
2591 if (!decoder->enabled) {
2592 if (decoder->status & pts_eos)
2598 status = pt_blk_proceed_no_event(decoder, block);
2602 return pt_blk_proceed_trailing_event(decoder, block);
2621 static int pt_blk_handle_erratum_bdm64(struct pt_block_decoder *decoder,
2629 if (!decoder || !block || !ev)
2647 status = pt_insn_decode(&insn, &iext, decoder->image, &decoder->asid);
2659 status = pt_insn_range_is_contiguous(decoder->ip, ev->variant.tsx.ip,
2660 decoder->mode, decoder->image,
2661 &decoder->asid, bdm64_max_steps);
2671 decoder->ip = ev->variant.tsx.ip;
2684 static inline int pt_blk_postpone_trailing_tsx(struct pt_block_decoder *decoder,
2690 if (!decoder || !ev)
2696 if (block && decoder->query.config.errata.bdm64) {
2697 status = pt_blk_handle_erratum_bdm64(decoder, block, ev);
2702 if (decoder->ip != ev->variant.tsx.ip)
2708 /* Proceed with events that bind to the current decoder IP.
2722 static int pt_blk_proceed_trailing_event(struct pt_block_decoder *decoder,
2728 if (!decoder)
2731 status = pt_blk_fetch_event(decoder);
2736 status = pt_blk_proceed_postponed_insn(decoder);
2740 return pt_blk_status(decoder, 0);
2743 ev = &decoder->event;
2749 if (!decoder->process_insn)
2754 pt_insn_changes_cr3(&decoder->insn, &decoder->iext))
2755 return pt_blk_status(decoder, pts_event_pending);
2763 status = pt_insn_next_ip(&decoder->ip, &decoder->insn,
2764 &decoder->iext);
2769 status = pt_blk_set_disable_resume_ip(decoder,
2770 &decoder->insn);
2774 return pt_blk_status(decoder, pts_event_pending);
2778 status = pt_blk_clear_postponed_insn(decoder);
2784 decoder->ip == ev->variant.disabled.ip)
2785 return pt_blk_status(decoder, pts_event_pending);
2791 status = pt_blk_proceed_postponed_insn(decoder);
2795 return pt_blk_status(decoder, pts_event_pending);
2799 status = pt_blk_proceed_postponed_insn(decoder);
2803 if (decoder->ip != ev->variant.async_disabled.at)
2806 if (decoder->query.config.errata.skd022) {
2807 status = pt_blk_handle_erratum_skd022(decoder, ev);
2821 return pt_blk_status(decoder, pts_event_pending);
2825 status = pt_blk_proceed_postponed_insn(decoder);
2829 if (decoder->ip != ev->variant.async_branch.from)
2832 return pt_blk_status(decoder, pts_event_pending);
2836 if (!decoder->enabled)
2837 return pt_blk_status(decoder, pts_event_pending);
2845 if (!decoder->process_insn || decoder->bound_paging)
2852 if (!pt_insn_binds_to_pip(&decoder->insn, &decoder->iext))
2858 decoder->bound_paging = 1;
2860 return pt_blk_status(decoder, pts_event_pending);
2864 status = pt_blk_proceed_postponed_insn(decoder);
2869 decoder->ip != ev->variant.async_paging.ip)
2872 return pt_blk_status(decoder, pts_event_pending);
2876 if (!decoder->enabled)
2877 return pt_blk_status(decoder, pts_event_pending);
2885 if (!decoder->process_insn || decoder->bound_vmcs)
2892 if (!pt_insn_binds_to_vmcs(&decoder->insn, &decoder->iext))
2898 decoder->bound_vmcs = 1;
2900 return pt_blk_status(decoder, pts_event_pending);
2904 status = pt_blk_proceed_postponed_insn(decoder);
2909 decoder->ip != ev->variant.async_vmcs.ip)
2912 return pt_blk_status(decoder, pts_event_pending);
2916 status = pt_blk_proceed_postponed_insn(decoder);
2920 return pt_blk_status(decoder, pts_event_pending);
2924 status = pt_blk_proceed_postponed_insn(decoder);
2929 decoder->ip != ev->variant.exec_mode.ip)
2932 return pt_blk_status(decoder, pts_event_pending);
2936 status = pt_blk_proceed_postponed_insn(decoder);
2940 status = pt_blk_postpone_trailing_tsx(decoder, block, ev);
2948 return pt_blk_status(decoder, pts_event_pending);
2952 status = pt_blk_proceed_postponed_insn(decoder);
2956 return pt_blk_status(decoder, pts_event_pending);
2960 status = pt_blk_proceed_postponed_insn(decoder);
2964 if (!ev->ip_suppressed && decoder->enabled &&
2965 decoder->ip != ev->variant.exstop.ip)
2968 return pt_blk_status(decoder, pts_event_pending);
2972 status = pt_blk_proceed_postponed_insn(decoder);
2976 if (!ev->ip_suppressed && decoder->enabled &&
2977 decoder->ip != ev->variant.mwait.ip)
2980 return pt_blk_status(decoder, pts_event_pending);
2985 status = pt_blk_proceed_postponed_insn(decoder);
2989 return pt_blk_status(decoder, pts_event_pending);
2993 if (!decoder->enabled)
2994 return pt_blk_status(decoder, pts_event_pending);
3001 if (!decoder->process_insn || decoder->bound_ptwrite)
3009 !pt_insn_is_ptwrite(&decoder->insn, &decoder->iext))
3015 decoder->bound_ptwrite = 1;
3017 return pt_blk_status(decoder, pts_event_pending);
3023 status = pt_blk_proceed_postponed_insn(decoder);
3027 return pt_blk_status(decoder, pts_event_pending);
3031 status = pt_blk_proceed_postponed_insn(decoder);
3035 return pt_blk_status(decoder, 0);
3038 int pt_blk_next(struct pt_block_decoder *decoder, struct pt_block *ublock,
3044 if (!decoder || !ublock)
3060 pblock->ip = decoder->ip;
3061 pblock->mode = decoder->mode;
3062 if (decoder->speculative)
3066 status = pt_blk_proceed(decoder, pblock);
3079 static int pt_blk_process_enabled(struct pt_block_decoder *decoder,
3082 if (!decoder || !ev)
3094 if (decoder->enabled)
3097 decoder->ip = ev->variant.enabled.ip;
3098 decoder->enabled = 1;
3099 decoder->process_event = 0;
3108 static int pt_blk_process_disabled(struct pt_block_decoder *decoder,
3111 if (!decoder || !ev)
3119 if (!decoder->enabled)
3122 /* We preserve @decoder->ip. This is where we expect tracing to resume
3126 decoder->enabled = 0;
3127 decoder->process_event = 0;
3136 static int pt_blk_process_async_branch(struct pt_block_decoder *decoder,
3139 if (!decoder || !ev)
3147 if (!decoder->enabled)
3153 decoder->ip = ev->variant.async_branch.to;
3154 decoder->process_event = 0;
3163 static int pt_blk_process_paging(struct pt_block_decoder *decoder,
3169 if (!decoder || !ev)
3173 if (decoder->asid.cr3 != cr3) {
3174 errcode = pt_msec_cache_invalidate(&decoder->scache);
3178 decoder->asid.cr3 = cr3;
3181 decoder->process_event = 0;
3190 static int pt_blk_process_vmcs(struct pt_block_decoder *decoder,
3196 if (!decoder || !ev)
3200 if (decoder->asid.vmcs != vmcs) {
3201 errcode = pt_msec_cache_invalidate(&decoder->scache);
3205 decoder->asid.vmcs = vmcs;
3208 decoder->process_event = 0;
3217 static int pt_blk_process_overflow(struct pt_block_decoder *decoder,
3220 if (!decoder || !ev)
3236 decoder->enabled = 0;
3237 decoder->ip = 0ull;
3242 decoder->enabled = 1;
3243 decoder->ip = ev->variant.overflow.ip;
3252 decoder->speculative = 0;
3253 decoder->process_event = 0;
3262 static int pt_blk_process_exec_mode(struct pt_block_decoder *decoder,
3267 if (!decoder || !ev)
3272 if (ev->status_update && decoder->enabled &&
3273 decoder->mode != ptem_unknown && decoder->mode != mode)
3276 decoder->mode = mode;
3277 decoder->process_event = 0;
3286 static int pt_blk_process_tsx(struct pt_block_decoder *decoder,
3289 if (!decoder || !ev)
3292 decoder->speculative = ev->variant.tsx.speculative;
3293 decoder->process_event = 0;
3302 static int pt_blk_process_stop(struct pt_block_decoder *decoder,
3305 if (!decoder || !ev)
3313 if (decoder->enabled)
3316 decoder->process_event = 0;
3321 int pt_blk_event(struct pt_block_decoder *decoder, struct pt_event *uevent,
3327 if (!decoder || !uevent)
3331 if (!decoder->process_event)
3334 ev = &decoder->event;
3341 if (ev->variant.enabled.ip == decoder->ip)
3344 status = pt_blk_process_enabled(decoder, ev);
3351 if (decoder->ip != ev->variant.async_disabled.at)
3357 status = pt_blk_process_disabled(decoder, ev);
3364 if (decoder->ip != ev->variant.async_branch.from)
3367 status = pt_blk_process_async_branch(decoder, ev);
3375 decoder->ip != ev->variant.async_paging.ip)
3380 status = pt_blk_process_paging(decoder, ev);
3388 decoder->ip != ev->variant.async_vmcs.ip)
3393 status = pt_blk_process_vmcs(decoder, ev);
3400 status = pt_blk_process_overflow(decoder, ev);
3408 decoder->ip != ev->variant.exec_mode.ip)
3411 status = pt_blk_process_exec_mode(decoder, ev);
3418 if (!ev->ip_suppressed && decoder->ip != ev->variant.tsx.ip)
3421 status = pt_blk_process_tsx(decoder, ev);
3428 status = pt_blk_process_stop(decoder, ev);
3435 if (!ev->ip_suppressed && decoder->enabled &&
3436 decoder->ip != ev->variant.exstop.ip)
3439 decoder->process_event = 0;
3443 if (!ev->ip_suppressed && decoder->enabled &&
3444 decoder->ip != ev->variant.mwait.ip)
3447 decoder->process_event = 0;
3456 decoder->process_event = 0;
3472 return pt_blk_proceed_trailing_event(decoder, NULL);