Lines Matching refs:decoder
46 static void pt_insn_reset(struct pt_insn_decoder *decoder)
48 if (!decoder)
51 decoder->mode = ptem_unknown;
52 decoder->ip = 0ull;
53 decoder->status = 0;
54 decoder->enabled = 0;
55 decoder->process_event = 0;
56 decoder->speculative = 0;
57 decoder->process_insn = 0;
58 decoder->bound_paging = 0;
59 decoder->bound_vmcs = 0;
60 decoder->bound_ptwrite = 0;
62 pt_retstack_init(&decoder->retstack);
63 pt_asid_init(&decoder->asid);
66 static int pt_insn_status(const struct pt_insn_decoder *decoder, int flags)
70 if (!decoder)
73 status = decoder->status;
80 if (!decoder->enabled)
87 if ((status & pts_eos) && !decoder->process_event)
93 /* Initialize the query decoder flags based on our flags. */
106 int pt_insn_decoder_init(struct pt_insn_decoder *decoder,
112 if (!decoder)
119 /* The user supplied decoder flags. */
120 decoder->flags = config.flags;
122 /* Set the flags we need for the query decoder we use. */
123 errcode = pt_insn_init_qry_flags(&config.flags, &decoder->flags);
127 errcode = pt_qry_decoder_init(&decoder->query, &config);
131 pt_image_init(&decoder->default_image, NULL);
132 decoder->image = &decoder->default_image;
134 errcode = pt_msec_cache_init(&decoder->scache);
138 pt_insn_reset(decoder);
143 void pt_insn_decoder_fini(struct pt_insn_decoder *decoder)
145 if (!decoder)
148 pt_msec_cache_fini(&decoder->scache);
149 pt_image_fini(&decoder->default_image);
150 pt_qry_decoder_fini(&decoder->query);
155 struct pt_insn_decoder *decoder;
158 decoder = malloc(sizeof(*decoder));
159 if (!decoder)
162 errcode = pt_insn_decoder_init(decoder, config);
164 free(decoder);
168 return decoder;
171 void pt_insn_free_decoder(struct pt_insn_decoder *decoder)
173 if (!decoder)
176 pt_insn_decoder_fini(decoder);
177 free(decoder);
189 static int pt_insn_tick(struct pt_insn_decoder *decoder, uint64_t ip)
196 if (!decoder)
200 if (!decoder->enabled)
214 if (decoder->process_event)
217 errcode = pt_qry_time(&decoder->query, &tsc, &lost_mtc, &lost_cyc);
224 ev = &decoder->event;
243 decoder->process_event = 1;
252 static int pt_insn_indirect_branch(struct pt_insn_decoder *decoder,
258 if (!decoder)
261 evip = decoder->ip;
263 status = pt_qry_indirect_branch(&decoder->query, ip);
267 if (decoder->flags.variant.insn.enable_tick_events) {
268 errcode = pt_insn_tick(decoder, evip);
280 static int pt_insn_cond_branch(struct pt_insn_decoder *decoder, int *taken)
284 if (!decoder)
287 status = pt_qry_cond_branch(&decoder->query, taken);
291 if (decoder->flags.variant.insn.enable_tick_events) {
292 errcode = pt_insn_tick(decoder, decoder->ip);
300 static int pt_insn_start(struct pt_insn_decoder *decoder, int status)
302 if (!decoder)
308 decoder->status = status;
311 decoder->enabled = 1;
323 return pt_insn_check_ip_event(decoder, NULL, NULL);
326 int pt_insn_sync_forward(struct pt_insn_decoder *decoder)
330 if (!decoder)
333 pt_insn_reset(decoder);
335 status = pt_qry_sync_forward(&decoder->query, &decoder->ip);
337 return pt_insn_start(decoder, status);
340 int pt_insn_sync_backward(struct pt_insn_decoder *decoder)
344 if (!decoder)
347 pt_insn_reset(decoder);
349 status = pt_qry_sync_backward(&decoder->query, &decoder->ip);
351 return pt_insn_start(decoder, status);
354 int pt_insn_sync_set(struct pt_insn_decoder *decoder, uint64_t offset)
358 if (!decoder)
361 pt_insn_reset(decoder);
363 status = pt_qry_sync_set(&decoder->query, &decoder->ip, offset);
365 return pt_insn_start(decoder, status);
368 int pt_insn_get_offset(const struct pt_insn_decoder *decoder, uint64_t *offset)
370 if (!decoder)
373 return pt_qry_get_offset(&decoder->query, offset);
376 int pt_insn_get_sync_offset(const struct pt_insn_decoder *decoder,
379 if (!decoder)
382 return pt_qry_get_sync_offset(&decoder->query, offset);
385 struct pt_image *pt_insn_get_image(struct pt_insn_decoder *decoder)
387 if (!decoder)
390 return decoder->image;
393 int pt_insn_set_image(struct pt_insn_decoder *decoder,
396 if (!decoder)
400 image = &decoder->default_image;
402 decoder->image = image;
407 pt_insn_get_config(const struct pt_insn_decoder *decoder)
409 if (!decoder)
412 return pt_qry_get_config(&decoder->query);
415 int pt_insn_time(struct pt_insn_decoder *decoder, uint64_t *time,
418 if (!decoder || !time)
421 return pt_qry_time(&decoder->query, time, lost_mtc, lost_cyc);
424 int pt_insn_core_bus_ratio(struct pt_insn_decoder *decoder, uint32_t *cbr)
426 if (!decoder || !cbr)
429 return pt_qry_core_bus_ratio(&decoder->query, cbr);
432 int pt_insn_asid(const struct pt_insn_decoder *decoder, struct pt_asid *asid,
435 if (!decoder || !asid)
438 return pt_asid_to_user(asid, &decoder->asid, size);
441 static inline int event_pending(struct pt_insn_decoder *decoder)
445 if (!decoder)
448 if (decoder->process_event)
451 status = decoder->status;
455 status = pt_qry_event(&decoder->query, &decoder->event,
456 sizeof(decoder->event));
460 decoder->process_event = 1;
461 decoder->status = status;
465 static int check_erratum_skd022(struct pt_insn_decoder *decoder)
471 if (!decoder)
474 insn.mode = decoder->mode;
475 insn.ip = decoder->ip;
477 errcode = pt_insn_decode(&insn, &iext, decoder->image, &decoder->asid);
491 static inline int handle_erratum_skd022(struct pt_insn_decoder *decoder)
497 if (!decoder)
500 errcode = check_erratum_skd022(decoder);
507 ev = &decoder->event;
517 static int pt_insn_proceed(struct pt_insn_decoder *decoder,
521 if (!decoder || !insn || !iext)
525 decoder->ip += insn->size;
541 status = pt_insn_cond_branch(decoder, &taken);
545 decoder->status = status;
560 pt_retstack_push(&decoder->retstack, decoder->ip);
568 status = pt_insn_cond_branch(decoder, &taken);
570 decoder->status = status;
578 return pt_retstack_pop(&decoder->retstack,
579 &decoder->ip);
601 decoder->ip += iext->variant.branch.displacement;
605 status = pt_insn_indirect_branch(decoder, &decoder->ip);
610 decoder->status = status;
731 static int pt_insn_postpone(struct pt_insn_decoder *decoder,
735 if (!decoder || !insn || !iext)
738 if (!decoder->process_insn) {
739 decoder->process_insn = 1;
740 decoder->insn = *insn;
741 decoder->iext = *iext;
744 return pt_insn_status(decoder, pts_event_pending);
747 /* Remove any postponed instruction from @decoder.
751 static int pt_insn_clear_postponed(struct pt_insn_decoder *decoder)
753 if (!decoder)
756 decoder->process_insn = 0;
757 decoder->bound_paging = 0;
758 decoder->bound_vmcs = 0;
759 decoder->bound_ptwrite = 0;
768 static int pt_insn_proceed_postponed(struct pt_insn_decoder *decoder)
772 if (!decoder)
775 if (!decoder->process_insn)
779 if (!decoder->enabled)
780 return pt_insn_clear_postponed(decoder);
782 status = pt_insn_proceed(decoder, &decoder->insn, &decoder->iext);
786 return pt_insn_clear_postponed(decoder);
804 static int pt_insn_check_insn_event(struct pt_insn_decoder *decoder,
811 if (!decoder)
814 status = event_pending(decoder);
818 ev = &decoder->event;
841 &decoder->query.config);
849 status = pt_insn_next_ip(&decoder->ip, insn, iext);
852 decoder->ip = 0ull;
868 decoder->ip = insn->ip + insn->size;
880 if (decoder->bound_paging)
889 decoder->bound_paging = 1;
891 return pt_insn_postpone(decoder, insn, iext);
895 if (decoder->bound_vmcs)
904 decoder->bound_vmcs = 1;
906 return pt_insn_postpone(decoder, insn, iext);
910 if (decoder->bound_ptwrite)
920 ev->variant.ptwrite.ip = decoder->ip;
930 if (decoder->ip != ev->variant.ptwrite.ip)
937 decoder->bound_ptwrite = 1;
939 return pt_insn_postpone(decoder, insn, iext);
942 return pt_insn_status(decoder, pts_event_pending);
961 static int handle_erratum_bdm64(struct pt_insn_decoder *decoder,
968 if (!decoder || !ev || !insn || !iext)
984 status = pt_insn_range_is_contiguous(decoder->ip, ev->variant.tsx.ip,
985 decoder->mode, decoder->image,
986 &decoder->asid, bdm64_max_steps);
996 decoder->ip = ev->variant.tsx.ip;
1009 static inline int pt_insn_postpone_tsx(struct pt_insn_decoder *decoder,
1016 if (!decoder || !ev)
1022 if (insn && iext && decoder->query.config.errata.bdm64) {
1023 status = handle_erratum_bdm64(decoder, ev, insn, iext);
1028 if (decoder->ip != ev->variant.tsx.ip)
1036 * Check whether an event is pending that binds to @decoder->ip, and, if that is
1042 static int pt_insn_check_ip_event(struct pt_insn_decoder *decoder,
1049 if (!decoder)
1052 status = event_pending(decoder);
1057 return pt_insn_status(decoder, 0);
1060 ev = &decoder->event;
1066 return pt_insn_status(decoder, pts_event_pending);
1069 if (ev->variant.async_disabled.at != decoder->ip)
1072 if (decoder->query.config.errata.skd022) {
1075 errcode = handle_erratum_skd022(decoder);
1088 return pt_insn_status(decoder, pts_event_pending);
1091 status = pt_insn_postpone_tsx(decoder, insn, iext, ev);
1099 return pt_insn_status(decoder, pts_event_pending);
1102 if (ev->variant.async_branch.from != decoder->ip)
1105 return pt_insn_status(decoder, pts_event_pending);
1108 return pt_insn_status(decoder, pts_event_pending);
1112 ev->variant.exec_mode.ip != decoder->ip)
1115 return pt_insn_status(decoder, pts_event_pending);
1118 if (decoder->enabled)
1121 return pt_insn_status(decoder, pts_event_pending);
1125 ev->variant.async_paging.ip != decoder->ip)
1128 return pt_insn_status(decoder, pts_event_pending);
1131 if (decoder->enabled)
1134 return pt_insn_status(decoder, pts_event_pending);
1138 ev->variant.async_vmcs.ip != decoder->ip)
1141 return pt_insn_status(decoder, pts_event_pending);
1144 return pt_insn_status(decoder, pts_event_pending);
1147 if (!ev->ip_suppressed && decoder->enabled &&
1148 decoder->ip != ev->variant.exstop.ip)
1151 return pt_insn_status(decoder, pts_event_pending);
1154 if (!ev->ip_suppressed && decoder->enabled &&
1155 decoder->ip != ev->variant.mwait.ip)
1158 return pt_insn_status(decoder, pts_event_pending);
1162 return pt_insn_status(decoder, pts_event_pending);
1175 if (decoder->enabled)
1178 return pt_insn_status(decoder, pts_event_pending);
1183 return pt_insn_status(decoder, pts_event_pending);
1186 return pt_insn_status(decoder, 0);
1210 static int pt_insn_decode_cached(struct pt_insn_decoder *decoder,
1216 if (!decoder || !insn || !iext)
1221 * later on, fall back to decoding @insn from @decoder->image.
1228 return pt_insn_decode(insn, iext, decoder->image,
1229 &decoder->asid);
1236 return pt_insn_decode(insn, iext, decoder->image,
1237 &decoder->asid);
1250 return pt_insn_decode(insn, iext, decoder->image,
1251 &decoder->asid);
1257 static int pt_insn_msec_lookup(struct pt_insn_decoder *decoder,
1265 if (!decoder || !pmsec)
1268 scache = &decoder->scache;
1269 image = decoder->image;
1270 ip = decoder->ip;
1278 &decoder->asid, ip);
1284 int pt_insn_next(struct pt_insn_decoder *decoder, struct pt_insn *uinsn,
1292 if (!uinsn || !decoder)
1300 if (!decoder->enabled) {
1301 if (decoder->status & pts_eos)
1317 if (decoder->speculative)
1319 pinsn->ip = decoder->ip;
1320 pinsn->mode = decoder->mode;
1322 isid = pt_insn_msec_lookup(decoder, &msec);
1335 status = pt_insn_decode_cached(decoder, msec, pinsn, &iext);
1355 status = pt_insn_check_insn_event(decoder, pinsn, &iext);
1365 status = pt_insn_proceed(decoder, pinsn, &iext);
1374 return pt_insn_check_ip_event(decoder, pinsn, &iext);
1377 static int pt_insn_process_enabled(struct pt_insn_decoder *decoder)
1381 if (!decoder)
1384 ev = &decoder->event;
1395 if (decoder->enabled)
1398 decoder->ip = ev->variant.enabled.ip;
1399 decoder->enabled = 1;
1404 static int pt_insn_process_disabled(struct pt_insn_decoder *decoder)
1408 if (!decoder)
1411 ev = &decoder->event;
1418 if (!decoder->enabled)
1421 /* We preserve @decoder->ip. This is where we expect tracing to resume
1425 decoder->enabled = 0;
1430 static int pt_insn_process_async_branch(struct pt_insn_decoder *decoder)
1434 if (!decoder)
1437 ev = &decoder->event;
1444 if (!decoder->enabled)
1447 decoder->ip = ev->variant.async_branch.to;
1452 static int pt_insn_process_paging(struct pt_insn_decoder *decoder)
1457 if (!decoder)
1460 cr3 = decoder->event.variant.paging.cr3;
1461 if (decoder->asid.cr3 != cr3) {
1462 errcode = pt_msec_cache_invalidate(&decoder->scache);
1466 decoder->asid.cr3 = cr3;
1472 static int pt_insn_process_overflow(struct pt_insn_decoder *decoder)
1476 if (!decoder)
1479 ev = &decoder->event;
1496 decoder->enabled = 0;
1497 decoder->ip = 0ull;
1502 decoder->ip = ev->variant.overflow.ip;
1503 decoder->enabled = 1;
1512 decoder->speculative = 0;
1517 static int pt_insn_process_exec_mode(struct pt_insn_decoder *decoder)
1522 if (!decoder)
1525 ev = &decoder->event;
1529 if (ev->status_update && decoder->enabled &&
1530 decoder->mode != ptem_unknown && decoder->mode != mode)
1533 decoder->mode = mode;
1538 static int pt_insn_process_tsx(struct pt_insn_decoder *decoder)
1540 if (!decoder)
1543 decoder->speculative = decoder->event.variant.tsx.speculative;
1548 static int pt_insn_process_stop(struct pt_insn_decoder *decoder)
1552 if (!decoder)
1555 ev = &decoder->event;
1562 if (decoder->enabled)
1568 static int pt_insn_process_vmcs(struct pt_insn_decoder *decoder)
1573 if (!decoder)
1576 vmcs = decoder->event.variant.vmcs.base;
1577 if (decoder->asid.vmcs != vmcs) {
1578 errcode = pt_msec_cache_invalidate(&decoder->scache);
1582 decoder->asid.vmcs = vmcs;
1588 int pt_insn_event(struct pt_insn_decoder *decoder, struct pt_event *uevent,
1594 if (!decoder || !uevent)
1598 if (!decoder->process_event)
1601 ev = &decoder->event;
1616 if (decoder->ip == ev->variant.enabled.ip)
1619 status = pt_insn_process_enabled(decoder);
1627 decoder->ip != ev->variant.async_disabled.at)
1632 status = pt_insn_process_disabled(decoder);
1639 if (decoder->ip != ev->variant.async_branch.from)
1642 status = pt_insn_process_async_branch(decoder);
1650 decoder->ip != ev->variant.async_paging.ip)
1655 status = pt_insn_process_paging(decoder);
1663 decoder->ip != ev->variant.async_vmcs.ip)
1668 status = pt_insn_process_vmcs(decoder);
1675 status = pt_insn_process_overflow(decoder);
1682 status = pt_insn_process_exec_mode(decoder);
1689 status = pt_insn_process_tsx(decoder);
1696 status = pt_insn_process_stop(decoder);
1703 if (!ev->ip_suppressed && decoder->enabled &&
1704 decoder->ip != ev->variant.exstop.ip)
1710 if (!ev->ip_suppressed && decoder->enabled &&
1711 decoder->ip != ev->variant.mwait.ip)
1737 decoder->process_event = 0;
1745 if (decoder->process_insn) {
1746 status = pt_insn_check_insn_event(decoder, &decoder->insn,
1747 &decoder->iext);
1758 status = pt_insn_proceed_postponed(decoder);
1764 return pt_insn_check_ip_event(decoder, NULL, NULL);