Lines Matching refs: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. */
109 int pt_blk_decoder_init(struct pt_block_decoder *decoder,
115 if (!decoder)
122 /* The user supplied decoder flags. */
123 decoder->flags = config.flags;
125 /* Set the flags we need for the query decoder we use. */
126 errcode = pt_blk_init_qry_flags(&config.flags, &decoder->flags);
130 errcode = pt_qry_decoder_init(&decoder->query, &config);
134 pt_image_init(&decoder->default_image, NULL);
135 decoder->image = &decoder->default_image;
137 errcode = pt_msec_cache_init(&decoder->scache);
141 pt_blk_reset(decoder);
146 void pt_blk_decoder_fini(struct pt_block_decoder *decoder)
148 if (!decoder)
151 pt_msec_cache_fini(&decoder->scache);
152 pt_image_fini(&decoder->default_image);
153 pt_qry_decoder_fini(&decoder->query);
159 struct pt_block_decoder *decoder;
162 decoder = malloc(sizeof(*decoder));
163 if (!decoder)
166 errcode = pt_blk_decoder_init(decoder, config);
168 free(decoder);
172 return decoder;
175 void pt_blk_free_decoder(struct pt_block_decoder *decoder)
177 if (!decoder)
180 pt_blk_decoder_fini(decoder);
181 free(decoder);
193 static int pt_blk_tick(struct pt_block_decoder *decoder, uint64_t ip)
200 if (!decoder)
204 if (!decoder->enabled)
218 if (decoder->process_event)
221 errcode = pt_qry_time(&decoder->query, &tsc, &lost_mtc, &lost_cyc);
228 ev = &decoder->event;
247 decoder->process_event = 1;
256 static int pt_blk_indirect_branch(struct pt_block_decoder *decoder,
262 if (!decoder)
265 evip = decoder->ip;
267 status = pt_qry_indirect_branch(&decoder->query, ip);
271 if (decoder->flags.variant.block.enable_tick_events) {
272 errcode = pt_blk_tick(decoder, evip);
284 static int pt_blk_cond_branch(struct pt_block_decoder *decoder, int *taken)
288 if (!decoder)
291 status = pt_qry_cond_branch(&decoder->query, taken);
295 if (decoder->flags.variant.block.enable_tick_events) {
296 errcode = pt_blk_tick(decoder, decoder->ip);
304 static int pt_blk_start(struct pt_block_decoder *decoder, int status)
306 if (!decoder)
312 decoder->status = status;
314 decoder->enabled = 1;
324 return pt_blk_proceed_trailing_event(decoder, NULL);
327 static int pt_blk_sync_reset(struct pt_block_decoder *decoder)
329 if (!decoder)
332 pt_blk_reset(decoder);
337 int pt_blk_sync_forward(struct pt_block_decoder *decoder)
341 if (!decoder)
344 errcode = pt_blk_sync_reset(decoder);
348 status = pt_qry_sync_forward(&decoder->query, &decoder->ip);
350 return pt_blk_start(decoder, status);
353 int pt_blk_sync_backward(struct pt_block_decoder *decoder)
357 if (!decoder)
360 errcode = pt_blk_sync_reset(decoder);
364 status = pt_qry_sync_backward(&decoder->query, &decoder->ip);
366 return pt_blk_start(decoder, status);
369 int pt_blk_sync_set(struct pt_block_decoder *decoder, uint64_t offset)
373 if (!decoder)
376 errcode = pt_blk_sync_reset(decoder);
380 status = pt_qry_sync_set(&decoder->query, &decoder->ip, offset);
382 return pt_blk_start(decoder, status);
385 int pt_blk_get_offset(const struct pt_block_decoder *decoder, uint64_t *offset)
387 if (!decoder)
390 return pt_qry_get_offset(&decoder->query, offset);
393 int pt_blk_get_sync_offset(const struct pt_block_decoder *decoder,
396 if (!decoder)
399 return pt_qry_get_sync_offset(&decoder->query, offset);
402 struct pt_image *pt_blk_get_image(struct pt_block_decoder *decoder)
404 if (!decoder)
407 return decoder->image;
410 int pt_blk_set_image(struct pt_block_decoder *decoder, struct pt_image *image)
412 if (!decoder)
416 image = &decoder->default_image;
418 decoder->image = image;
423 pt_blk_get_config(const struct pt_block_decoder *decoder)
425 if (!decoder)
428 return pt_qry_get_config(&decoder->query);
431 int pt_blk_time(struct pt_block_decoder *decoder, uint64_t *time,
434 if (!decoder || !time)
437 return pt_qry_time(&decoder->query, time, lost_mtc, lost_cyc);
440 int pt_blk_core_bus_ratio(struct pt_block_decoder *decoder, uint32_t *cbr)
442 if (!decoder || !cbr)
445 return pt_qry_core_bus_ratio(&decoder->query, cbr);
448 int pt_blk_asid(const struct pt_block_decoder *decoder, struct pt_asid *asid,
451 if (!decoder || !asid)
454 return pt_asid_to_user(asid, &decoder->asid, size);
466 static inline int pt_blk_fetch_event(struct pt_block_decoder *decoder)
470 if (!decoder)
473 if (decoder->process_event)
476 if (!(decoder->status & pts_event_pending))
479 status = pt_qry_event(&decoder->query, &decoder->event,
480 sizeof(decoder->event));
484 decoder->process_event = 1;
485 decoder->status = status;
539 * Does not update @decoder->status. The caller is expected to do that.
543 * Returns -pte_internal if @pip, @decoder, @insn, or @iext are NULL.
546 static int pt_blk_next_ip(uint64_t *pip, struct pt_block_decoder *decoder,
552 if (!pip || !decoder || !insn || !iext)
565 status = pt_blk_cond_branch(decoder, &taken);
581 status = pt_blk_cond_branch(decoder, &taken);
595 errcode = pt_retstack_pop(&decoder->retstack, pip);
628 return pt_blk_indirect_branch(decoder, pip);
638 static int pt_blk_proceed_with_trace(struct pt_block_decoder *decoder,
644 if (!decoder)
647 status = pt_blk_next_ip(&decoder->ip, decoder, insn, iext);
651 /* Preserve the query decoder's response which indicates upcoming
654 decoder->status = status;
699 static inline int pt_blk_log_call(struct pt_block_decoder *decoder,
703 if (!decoder || !insn || !iext)
716 return pt_retstack_push(&decoder->retstack, insn->ip + insn->size);
721 * Tries to decode the instruction at @decoder->ip and, on success, adds it to
735 static int pt_blk_proceed_one_insn(struct pt_block_decoder *decoder,
745 if (!decoder || !block || !pinsn || !piext)
760 insn.mode = decoder->mode;
761 insn.ip = decoder->ip;
763 status = pt_insn_decode(&insn, &iext, decoder->image, &decoder->asid);
785 status = pt_blk_log_call(decoder, &insn, &iext);
813 * Update @decoder->ip to point to the last IP that was reached. If we fail due
821 static int pt_blk_proceed_to_insn(struct pt_block_decoder *decoder,
830 if (!decoder || !insn || !predicate)
834 status = pt_blk_proceed_one_insn(decoder, block, insn, iext);
846 status = pt_insn_next_ip(&decoder->ip, insn, iext);
856 if ((decoder->flags.variant.block.end_on_call &&
858 (decoder->flags.variant.block.end_on_jump &&
875 * Update @decoder->ip to point to the last IP that was reached. If we fail due
883 static int pt_blk_proceed_to_ip(struct pt_block_decoder *decoder,
889 if (!decoder || !insn)
896 if (decoder->ip == ip)
899 status = pt_blk_proceed_one_insn(decoder, block, insn, iext);
904 status = pt_insn_next_ip(&decoder->ip, insn, iext);
917 if ((decoder->flags.variant.block.end_on_call &&
919 (decoder->flags.variant.block.end_on_jump &&
921 return (decoder->ip == ip ? 1 : 0);
934 * Update @decoder->ip to point to the last IP that was reached.
942 static int pt_blk_proceed_to_ip_with_trace(struct pt_block_decoder *decoder,
955 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext, ip);
962 return pt_blk_proceed_with_trace(decoder, &insn, &iext);
1001 static int pt_blk_proceed_skl014(struct pt_block_decoder *decoder,
1008 if (!decoder || !block || !insn || !iext)
1011 addr_filter = &decoder->query.config.addr_filter;
1015 status = pt_blk_proceed_to_insn(decoder, block, insn, iext,
1047 decoder->ip = ip;
1055 if ((decoder->flags.variant.block.end_on_call &&
1057 (decoder->flags.variant.block.end_on_jump &&
1076 static int pt_blk_proceed_to_disabled(struct pt_block_decoder *decoder,
1082 if (!decoder || !block || !ev)
1094 if (decoder->query.config.addr_filter.config.addr_cfg &&
1095 decoder->query.config.errata.skl014)
1096 return pt_blk_proceed_skl014(decoder, block, insn,
1105 return pt_blk_proceed_to_insn(decoder, block, insn, iext,
1108 return pt_blk_proceed_to_ip(decoder, block, insn, iext,
1114 * On a synchronous disable, @decoder->ip still points to the instruction to
1122 static int pt_blk_set_disable_resume_ip(struct pt_block_decoder *decoder,
1125 if (!decoder || !insn)
1131 decoder->ip = insn->ip + insn->size;
1135 decoder->ip = 0ull;
1152 static int pt_blk_proceed_to_async_paging(struct pt_block_decoder *decoder,
1158 if (!decoder || !ev)
1165 status = pt_blk_proceed_to_ip_with_trace(decoder, block,
1171 return (decoder->ip == ev->variant.async_paging.ip ? 1 : 0);
1184 static int pt_blk_proceed_to_async_vmcs(struct pt_block_decoder *decoder,
1190 if (!decoder || !ev)
1197 status = pt_blk_proceed_to_ip_with_trace(decoder, block,
1203 return (decoder->ip == ev->variant.async_vmcs.ip ? 1 : 0);
1216 static int pt_blk_proceed_to_exec_mode(struct pt_block_decoder *decoder,
1222 if (!decoder || !ev)
1229 status = pt_blk_proceed_to_ip_with_trace(decoder, block,
1235 return (decoder->ip == ev->variant.exec_mode.ip ? 1 : 0);
1253 static int pt_blk_proceed_to_ptwrite(struct pt_block_decoder *decoder,
1274 * the last instruction in the current block and @decoder->ip will point
1278 status = pt_blk_proceed_to_insn(decoder, block, insn, iext,
1290 status = pt_blk_proceed_to_ip(decoder, block, insn, iext,
1295 /* We reached the PTWRITE instruction and @decoder->ip points to
1302 status = pt_blk_proceed_one_insn(decoder, block, insn, iext);
1319 static int pt_blk_handle_erratum_skd022(struct pt_block_decoder *decoder,
1326 if (!decoder || !ev)
1329 insn.mode = decoder->mode;
1332 errcode = pt_insn_decode(&insn, &iext, decoder->image, &decoder->asid);
1364 static int pt_blk_postpone_insn(struct pt_block_decoder *decoder,
1368 if (!decoder || !insn || !iext)
1372 if (decoder->process_insn)
1375 decoder->process_insn = 1;
1376 decoder->insn = *insn;
1377 decoder->iext = *iext;
1379 return pt_blk_status(decoder, pts_event_pending);
1382 /* Remove any postponed instruction from @decoder.
1386 static int pt_blk_clear_postponed_insn(struct pt_block_decoder *decoder)
1388 if (!decoder)
1391 decoder->process_insn = 0;
1392 decoder->bound_paging = 0;
1393 decoder->bound_vmcs = 0;
1394 decoder->bound_ptwrite = 0;
1401 * If an instruction has been postponed in @decoder, proceed past it.
1405 static int pt_blk_proceed_postponed_insn(struct pt_block_decoder *decoder)
1409 if (!decoder)
1413 if (!decoder->process_insn)
1417 if (!decoder->enabled)
1418 return pt_blk_clear_postponed_insn(decoder);
1420 status = pt_insn_next_ip(&decoder->ip, &decoder->insn, &decoder->iext);
1425 status = pt_blk_proceed_with_trace(decoder, &decoder->insn,
1426 &decoder->iext);
1431 return pt_blk_clear_postponed_insn(decoder);
1452 static int pt_blk_proceed_event(struct pt_block_decoder *decoder,
1460 if (!decoder || !decoder->process_event || !block)
1463 ev = &decoder->event;
1469 status = pt_blk_proceed_to_disabled(decoder, block, &insn,
1479 status = pt_blk_set_disable_resume_ip(decoder, &insn);
1487 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext,
1492 if (decoder->query.config.errata.skd022) {
1493 status = pt_blk_handle_erratum_skd022(decoder, ev);
1501 return pt_blk_proceed_event(decoder, block);
1508 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext,
1516 if (!decoder->enabled)
1519 status = pt_blk_proceed_to_insn(decoder, block, &insn, &iext,
1527 decoder->bound_paging = 1;
1529 return pt_blk_postpone_insn(decoder, &insn, &iext);
1532 status = pt_blk_proceed_to_async_paging(decoder, block, ev);
1539 if (!decoder->enabled)
1542 status = pt_blk_proceed_to_insn(decoder, block, &insn, &iext,
1550 decoder->bound_vmcs = 1;
1552 return pt_blk_postpone_insn(decoder, &insn, &iext);
1555 status = pt_blk_proceed_to_async_vmcs(decoder, block, ev);
1565 status = pt_blk_proceed_to_exec_mode(decoder, block, ev);
1575 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext,
1586 if (!decoder->enabled || ev->ip_suppressed)
1589 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext,
1597 if (!decoder->enabled || ev->ip_suppressed)
1600 status = pt_blk_proceed_to_ip(decoder, block, &insn, &iext,
1612 if (!decoder->enabled)
1615 status = pt_blk_proceed_to_ptwrite(decoder, block, &insn,
1623 decoder->bound_ptwrite = 1;
1625 return pt_blk_postpone_insn(decoder, &insn, &iext);
1633 return pt_blk_status(decoder, pts_event_pending);
1645 * block. This only updates @decoder's internal state, though.
1649 static int pt_blk_proceed_no_event_uncached(struct pt_block_decoder *decoder,
1656 if (!decoder || !block)
1666 status = pt_blk_proceed_to_insn(decoder, block, &insn, &iext,
1672 return pt_blk_proceed_with_trace(decoder, &insn, &iext);
1757 /* Proceed to the next instruction and fill the block cache for @decoder->ip.
1772 pt_blk_proceed_no_event_fill_cache(struct pt_block_decoder *decoder,
1785 if (!decoder || !steps)
1793 status = pt_blk_proceed_one_insn(decoder, block, &insn, &iext);
1803 status = pt_insn_next_ip(&decoder->ip, &insn, &iext);
1868 return pt_blk_proceed_with_trace(decoder, &insn, &iext);
1872 nip = decoder->ip;
1890 * @decoder->flags.variant.block.end_on_call is set, though.
1942 decoder->flags.variant.block.end_on_jump)
1978 status = pt_blk_proceed_no_event_fill_cache(decoder, block,
2049 * We were not able to decode the instruction at @decoder->ip in @decoder's
2058 static int pt_blk_proceed_truncated(struct pt_block_decoder *decoder,
2065 if (!decoder || !block)
2071 insn.mode = decoder->mode;
2072 insn.ip = decoder->ip;
2074 errcode = pt_insn_decode(&insn, &iext, decoder->image, &decoder->asid);
2089 errcode = pt_blk_log_call(decoder, &insn, &iext);
2098 errcode = pt_insn_next_ip(&decoder->ip, &insn, &iext);
2103 return pt_blk_proceed_with_trace(decoder, &insn, &iext);
2121 * block. This only updates @decoder's internal state, though.
2125 static int pt_blk_proceed_no_event_cached(struct pt_block_decoder *decoder,
2135 if (!decoder || !block)
2138 offset = pt_msec_unmap(msec, decoder->ip);
2145 return pt_blk_proceed_no_event_fill_cache(decoder, block,
2169 nip = decoder->ip + bce.displacement;
2171 return pt_blk_proceed_no_event_uncached(decoder, block);
2192 decoder->ip = nip;
2215 return pt_blk_proceed_no_event_cached(decoder, block, bcache,
2234 * the instruction at @decoder->ip.
2240 status = pt_blk_cond_branch(decoder, &taken);
2244 /* Preserve the query decoder's response which indicates
2247 decoder->status = status;
2249 ip = decoder->ip;
2268 decoder->ip = ip + bce.isize;
2277 /* We need to decode the instruction at @decoder->ip and decide
2288 insn.ip = decoder->ip;
2295 return pt_blk_proceed_truncated(decoder, block);
2302 status = pt_blk_log_call(decoder, &insn, &iext);
2311 status = pt_insn_next_ip(&decoder->ip, &insn, &iext);
2319 return pt_blk_proceed_with_trace(decoder, &insn, &iext);
2328 if ((decoder->flags.variant.block.end_on_call &&
2330 (decoder->flags.variant.block.end_on_jump &&
2339 if (!pt_blk_is_in_section(msec, decoder->ip))
2342 return pt_blk_proceed_no_event_cached(decoder, block, bcache,
2355 ip = decoder->ip;
2379 status = pt_retstack_push(&decoder->retstack, ip);
2383 status = pt_blk_indirect_branch(decoder, &decoder->ip);
2387 /* Preserve the query decoder's response which indicates
2390 decoder->status = status;
2401 status = pt_blk_cond_branch(decoder, &taken);
2409 status = pt_blk_indirect_branch(decoder, &decoder->ip);
2413 /* Preserve the query decoder's response which indicates
2416 decoder->status = status;
2420 /* Preserve the query decoder's response which indicates
2423 decoder->status = status;
2431 return pt_retstack_pop(&decoder->retstack, &decoder->ip);
2450 status = pt_blk_indirect_branch(decoder, &decoder->ip);
2454 /* Preserve the query decoder's response which indicates
2457 decoder->status = status;
2464 static int pt_blk_msec_fill(struct pt_block_decoder *decoder,
2471 if (!decoder || !pmsec)
2474 isid = pt_msec_cache_fill(&decoder->scache, &msec, decoder->image,
2475 &decoder->asid, decoder->ip);
2492 static inline int pt_blk_msec_lookup(struct pt_block_decoder *decoder,
2497 if (!decoder)
2500 isid = pt_msec_cache_read(&decoder->scache, pmsec, decoder->image,
2501 decoder->ip);
2506 return pt_blk_msec_fill(decoder, pmsec);
2521 * block. This only updates @decoder's internal state, though.
2525 static int pt_blk_proceed_no_event(struct pt_block_decoder *decoder,
2533 if (!decoder || !block)
2536 isid = pt_blk_msec_lookup(decoder, &msec);
2544 return pt_blk_proceed_no_event_uncached(decoder, block);
2561 return pt_blk_proceed_no_event_uncached(decoder, block);
2563 return pt_blk_proceed_no_event_cached(decoder, block, bcache, msec);
2571 static int pt_blk_proceed(struct pt_block_decoder *decoder,
2576 status = pt_blk_fetch_event(decoder);
2581 return pt_blk_proceed_event(decoder, block);
2587 if (!decoder->enabled) {
2588 if (decoder->status & pts_eos)
2594 status = pt_blk_proceed_no_event(decoder, block);
2598 return pt_blk_proceed_trailing_event(decoder, block);
2617 static int pt_blk_handle_erratum_bdm64(struct pt_block_decoder *decoder,
2625 if (!decoder || !block || !ev)
2643 status = pt_insn_decode(&insn, &iext, decoder->image, &decoder->asid);
2655 status = pt_insn_range_is_contiguous(decoder->ip, ev->variant.tsx.ip,
2656 decoder->mode, decoder->image,
2657 &decoder->asid, bdm64_max_steps);
2667 decoder->ip = ev->variant.tsx.ip;
2680 static inline int pt_blk_postpone_trailing_tsx(struct pt_block_decoder *decoder,
2686 if (!decoder || !ev)
2692 if (block && decoder->query.config.errata.bdm64) {
2693 status = pt_blk_handle_erratum_bdm64(decoder, block, ev);
2698 if (decoder->ip != ev->variant.tsx.ip)
2704 /* Proceed with events that bind to the current decoder IP.
2718 static int pt_blk_proceed_trailing_event(struct pt_block_decoder *decoder,
2724 if (!decoder)
2727 status = pt_blk_fetch_event(decoder);
2732 status = pt_blk_proceed_postponed_insn(decoder);
2736 return pt_blk_status(decoder, 0);
2739 ev = &decoder->event;
2745 if (!decoder->process_insn)
2750 pt_insn_changes_cr3(&decoder->insn, &decoder->iext))
2751 return pt_blk_status(decoder, pts_event_pending);
2759 status = pt_insn_next_ip(&decoder->ip, &decoder->insn,
2760 &decoder->iext);
2765 status = pt_blk_set_disable_resume_ip(decoder,
2766 &decoder->insn);
2770 return pt_blk_status(decoder, pts_event_pending);
2774 status = pt_blk_clear_postponed_insn(decoder);
2780 decoder->ip == ev->variant.disabled.ip)
2781 return pt_blk_status(decoder, pts_event_pending);
2787 status = pt_blk_proceed_postponed_insn(decoder);
2791 return pt_blk_status(decoder, pts_event_pending);
2795 status = pt_blk_proceed_postponed_insn(decoder);
2799 if (decoder->ip != ev->variant.async_disabled.at)
2802 if (decoder->query.config.errata.skd022) {
2803 status = pt_blk_handle_erratum_skd022(decoder, ev);
2817 return pt_blk_status(decoder, pts_event_pending);
2821 status = pt_blk_proceed_postponed_insn(decoder);
2825 if (decoder->ip != ev->variant.async_branch.from)
2828 return pt_blk_status(decoder, pts_event_pending);
2832 if (!decoder->enabled)
2833 return pt_blk_status(decoder, pts_event_pending);
2841 if (!decoder->process_insn || decoder->bound_paging)
2848 if (!pt_insn_binds_to_pip(&decoder->insn, &decoder->iext))
2854 decoder->bound_paging = 1;
2856 return pt_blk_status(decoder, pts_event_pending);
2860 status = pt_blk_proceed_postponed_insn(decoder);
2865 decoder->ip != ev->variant.async_paging.ip)
2868 return pt_blk_status(decoder, pts_event_pending);
2872 if (!decoder->enabled)
2873 return pt_blk_status(decoder, pts_event_pending);
2881 if (!decoder->process_insn || decoder->bound_vmcs)
2888 if (!pt_insn_binds_to_vmcs(&decoder->insn, &decoder->iext))
2894 decoder->bound_vmcs = 1;
2896 return pt_blk_status(decoder, pts_event_pending);
2900 status = pt_blk_proceed_postponed_insn(decoder);
2905 decoder->ip != ev->variant.async_vmcs.ip)
2908 return pt_blk_status(decoder, pts_event_pending);
2912 status = pt_blk_proceed_postponed_insn(decoder);
2916 return pt_blk_status(decoder, pts_event_pending);
2920 status = pt_blk_proceed_postponed_insn(decoder);
2925 decoder->ip != ev->variant.exec_mode.ip)
2928 return pt_blk_status(decoder, pts_event_pending);
2932 status = pt_blk_proceed_postponed_insn(decoder);
2936 status = pt_blk_postpone_trailing_tsx(decoder, block, ev);
2944 return pt_blk_status(decoder, pts_event_pending);
2948 status = pt_blk_proceed_postponed_insn(decoder);
2952 return pt_blk_status(decoder, pts_event_pending);
2956 status = pt_blk_proceed_postponed_insn(decoder);
2960 if (!ev->ip_suppressed && decoder->enabled &&
2961 decoder->ip != ev->variant.exstop.ip)
2964 return pt_blk_status(decoder, pts_event_pending);
2968 status = pt_blk_proceed_postponed_insn(decoder);
2972 if (!ev->ip_suppressed && decoder->enabled &&
2973 decoder->ip != ev->variant.mwait.ip)
2976 return pt_blk_status(decoder, pts_event_pending);
2981 status = pt_blk_proceed_postponed_insn(decoder);
2985 return pt_blk_status(decoder, pts_event_pending);
2989 if (!decoder->enabled)
2990 return pt_blk_status(decoder, pts_event_pending);
2997 if (!decoder->process_insn || decoder->bound_ptwrite)
3005 !pt_insn_is_ptwrite(&decoder->insn, &decoder->iext))
3011 decoder->bound_ptwrite = 1;
3013 return pt_blk_status(decoder, pts_event_pending);
3019 status = pt_blk_proceed_postponed_insn(decoder);
3023 return pt_blk_status(decoder, pts_event_pending);
3027 status = pt_blk_proceed_postponed_insn(decoder);
3031 return pt_blk_status(decoder, 0);
3034 int pt_blk_next(struct pt_block_decoder *decoder, struct pt_block *ublock,
3040 if (!decoder || !ublock)
3056 pblock->ip = decoder->ip;
3057 pblock->mode = decoder->mode;
3058 if (decoder->speculative)
3062 status = pt_blk_proceed(decoder, pblock);
3075 static int pt_blk_process_enabled(struct pt_block_decoder *decoder,
3078 if (!decoder || !ev)
3090 if (decoder->enabled)
3093 decoder->ip = ev->variant.enabled.ip;
3094 decoder->enabled = 1;
3095 decoder->process_event = 0;
3104 static int pt_blk_process_disabled(struct pt_block_decoder *decoder,
3107 if (!decoder || !ev)
3115 if (!decoder->enabled)
3118 /* We preserve @decoder->ip. This is where we expect tracing to resume
3122 decoder->enabled = 0;
3123 decoder->process_event = 0;
3132 static int pt_blk_process_async_branch(struct pt_block_decoder *decoder,
3135 if (!decoder || !ev)
3143 if (!decoder->enabled)
3149 decoder->ip = ev->variant.async_branch.to;
3150 decoder->process_event = 0;
3159 static int pt_blk_process_paging(struct pt_block_decoder *decoder,
3165 if (!decoder || !ev)
3169 if (decoder->asid.cr3 != cr3) {
3170 errcode = pt_msec_cache_invalidate(&decoder->scache);
3174 decoder->asid.cr3 = cr3;
3177 decoder->process_event = 0;
3186 static int pt_blk_process_vmcs(struct pt_block_decoder *decoder,
3192 if (!decoder || !ev)
3196 if (decoder->asid.vmcs != vmcs) {
3197 errcode = pt_msec_cache_invalidate(&decoder->scache);
3201 decoder->asid.vmcs = vmcs;
3204 decoder->process_event = 0;
3213 static int pt_blk_process_overflow(struct pt_block_decoder *decoder,
3216 if (!decoder || !ev)
3232 decoder->enabled = 0;
3233 decoder->ip = 0ull;
3238 decoder->enabled = 1;
3239 decoder->ip = ev->variant.overflow.ip;
3248 decoder->speculative = 0;
3249 decoder->process_event = 0;
3258 static int pt_blk_process_exec_mode(struct pt_block_decoder *decoder,
3263 if (!decoder || !ev)
3268 if (ev->status_update && decoder->enabled &&
3269 decoder->mode != ptem_unknown && decoder->mode != mode)
3272 decoder->mode = mode;
3273 decoder->process_event = 0;
3282 static int pt_blk_process_tsx(struct pt_block_decoder *decoder,
3285 if (!decoder || !ev)
3288 decoder->speculative = ev->variant.tsx.speculative;
3289 decoder->process_event = 0;
3298 static int pt_blk_process_stop(struct pt_block_decoder *decoder,
3301 if (!decoder || !ev)
3309 if (decoder->enabled)
3312 decoder->process_event = 0;
3317 int pt_blk_event(struct pt_block_decoder *decoder, struct pt_event *uevent,
3323 if (!decoder || !uevent)
3327 if (!decoder->process_event)
3330 ev = &decoder->event;
3337 if (ev->variant.enabled.ip == decoder->ip)
3340 status = pt_blk_process_enabled(decoder, ev);
3347 if (decoder->ip != ev->variant.async_disabled.at)
3353 status = pt_blk_process_disabled(decoder, ev);
3360 if (decoder->ip != ev->variant.async_branch.from)
3363 status = pt_blk_process_async_branch(decoder, ev);
3371 decoder->ip != ev->variant.async_paging.ip)
3376 status = pt_blk_process_paging(decoder, ev);
3384 decoder->ip != ev->variant.async_vmcs.ip)
3389 status = pt_blk_process_vmcs(decoder, ev);
3396 status = pt_blk_process_overflow(decoder, ev);
3404 decoder->ip != ev->variant.exec_mode.ip)
3407 status = pt_blk_process_exec_mode(decoder, ev);
3414 if (!ev->ip_suppressed && decoder->ip != ev->variant.tsx.ip)
3417 status = pt_blk_process_tsx(decoder, ev);
3424 status = pt_blk_process_stop(decoder, ev);
3431 if (!ev->ip_suppressed && decoder->enabled &&
3432 decoder->ip != ev->variant.exstop.ip)
3435 decoder->process_event = 0;
3439 if (!ev->ip_suppressed && decoder->enabled &&
3440 decoder->ip != ev->variant.mwait.ip)
3443 decoder->process_event = 0;
3452 decoder->process_event = 0;
3468 return pt_blk_proceed_trailing_event(decoder, NULL);