/*

 * Copyright (c) 2016-2017, Intel Corporation

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 *  * Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 *  * Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 *  * Neither the name of Intel Corporation nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

#include "pt_block_decoder.h"

#include "pt_block_cache.h"

#include "pt_section.h"

#include "pt_image.h"

#include "pt_insn.h"

#include "pt_ild.h"

#include "pt_config.h"

#include "intel-pt.h"

#include <string.h>

#include <stdlib.h>

static int pt_blk_proceed_no_event(struct pt_block_decoder *,

				   struct pt_block *);

/* Release a cached section.

 *

 * If @scache does not contain a section, this does noting.

 *

 * Returns zero on success, a negative error code otherwise.

 * Returns -pte_internal, if @scache is NULL.

 */

static int pt_blk_scache_invalidate(struct pt_cached_section *scache)

{

	struct pt_section *section;

	int errcode;

	if (!scache)

		return -pte_internal;

	section = scache->section;

	if (!section)

		return 0;

	errcode = pt_section_unmap(section);

	if (errcode < 0)

		return errcode;

	scache->section = NULL;

	return pt_section_put(section);

}

/* Cache @section loaded at @laddr identified by @isid in @scache.

 *

 * The caller transfers its use- and map-count to @scache.

 *

 * Returns zero on success, a negative error code otherwise.

 * Returns -pte_internal if @scache or @section is NULL.

 * Returns -pte_internal if another section is already cached.

 */

static int pt_blk_cache_section(struct pt_cached_section *scache,

				struct pt_section *section, uint64_t laddr,

				int isid)

{

	if (!scache || !section)

		return -pte_internal;

	if (scache->section)

		return -pte_internal;

	scache->section = section;

	scache->laddr = laddr;

	scache->isid = isid;

	return 0;

}

/* Get @scache's cached section.

 *

 * Check whether @scache contains a section that an image lookup of @ip in @asid

 * would return.  On success, provides the cached section in @psection and its

 * load address in @pladdr.

 *

 * Returns the section's identifier on success, a negative error code otherwise.

 * Returns -pte_internal if @scache, @psection, or @pladdr is NULL.

 * Returns -pte_nomap if @scache does not have a section cached.

 * Returns -pte_nomap if @scache's cached section does not contain @ip.

 */

static int pt_blk_cached_section(struct pt_cached_section *scache,

				 struct pt_section **psection, uint64_t *pladdr,

				 struct pt_image *image, struct pt_asid *asid,

				 uint64_t ip)

{

	struct pt_section *section;

	uint64_t laddr;

	int isid, errcode;

	if (!scache || !psection || !pladdr)

		return -pte_internal;

	section = scache->section;

	laddr = scache->laddr;

	isid = scache->isid;

	if (!section)

		return -pte_nomap;

	errcode = pt_image_validate(image, asid, ip, section, laddr, isid);

	if (errcode < 0)

		return errcode;

	*psection = section;

	*pladdr = laddr;

	return isid;

}

static void pt_blk_reset(struct pt_block_decoder *decoder)

{

	if (!decoder)

		return;

	decoder->mode = ptem_unknown;

	decoder->ip = 0ull;

	decoder->status = 0;

	decoder->enabled = 0;

	decoder->process_event = 0;

	decoder->speculative = 0;

	pt_retstack_init(&decoder->retstack);

	pt_asid_init(&decoder->asid);

}

/* Initialize the query decoder flags based on our flags. */

static int pt_blk_init_qry_flags(struct pt_conf_flags *qflags,

				 const struct pt_conf_flags *flags)

{

	if (!qflags || !flags)

		return -pte_internal;

	memset(qflags, 0, sizeof(*qflags));

	return 0;

}

int pt_blk_decoder_init(struct pt_block_decoder *decoder,

			const struct pt_config *uconfig)

{

	struct pt_config config;

	int errcode;

	if (!decoder)

		return -pte_internal;

	errcode = pt_config_from_user(&config, uconfig);

	if (errcode < 0)

		return errcode;

	/* The user supplied decoder flags. */

	decoder->flags = config.flags;

	/* Set the flags we need for the query decoder we use. */

	errcode = pt_blk_init_qry_flags(&config.flags, &decoder->flags);

	if (errcode < 0)

		return errcode;

	errcode = pt_qry_decoder_init(&decoder->query, &config);

	if (errcode < 0)

		return errcode;

	pt_image_init(&decoder->default_image, NULL);

	decoder->image = &decoder->default_image;

	memset(&decoder->scache, 0, sizeof(decoder->scache));

	pt_blk_reset(decoder);

	return 0;

}

void pt_blk_decoder_fini(struct pt_block_decoder *decoder)

{

	if (!decoder)

		return;

	/* Release the cached section so we don't leak it. */

	(void) pt_blk_scache_invalidate(&decoder->scache);

	pt_image_fini(&decoder->default_image);

	pt_qry_decoder_fini(&decoder->query);

}

struct pt_block_decoder *

pt_blk_alloc_decoder(const struct pt_config *config)

{

	struct pt_block_decoder *decoder;

	int errcode;

	decoder = malloc(sizeof(*decoder));

	if (!decoder)

		return NULL;

	errcode = pt_blk_decoder_init(decoder, config);

	if (errcode < 0) {

		free(decoder);

		return NULL;

	}

	return decoder;

}

void pt_blk_free_decoder(struct pt_block_decoder *decoder)

{

	if (!decoder)

		return;

	pt_blk_decoder_fini(decoder);

	free(decoder);

}

static int pt_blk_start(struct pt_block_decoder *decoder, int status)

{

	if (!decoder)

		return -pte_internal;

	if (status < 0)

		return status;

	decoder->status = status;

	if (!(status & pts_ip_suppressed))

		decoder->enabled = 1;

	return 0;

}

static int pt_blk_sync_reset(struct pt_block_decoder *decoder)

{

	if (!decoder)

		return -pte_internal;

	pt_blk_reset(decoder);

	return 0;

}

int pt_blk_sync_forward(struct pt_block_decoder *decoder)

{

	int errcode, status;

	if (!decoder)

		return -pte_invalid;

	errcode = pt_blk_sync_reset(decoder);

	if (errcode < 0)

		return errcode;

	status = pt_qry_sync_forward(&decoder->query, &decoder->ip);

	return pt_blk_start(decoder, status);

}

int pt_blk_sync_backward(struct pt_block_decoder *decoder)

{

	int errcode, status;

	if (!decoder)

		return -pte_invalid;

	errcode = pt_blk_sync_reset(decoder);

	if (errcode < 0)

		return errcode;

	status = pt_qry_sync_backward(&decoder->query, &decoder->ip);

	return pt_blk_start(decoder, status);

}

int pt_blk_sync_set(struct pt_block_decoder *decoder, uint64_t offset)

{

	int errcode, status;

	if (!decoder)

		return -pte_invalid;

	errcode = pt_blk_sync_reset(decoder);

	if (errcode < 0)

		return errcode;

	status = pt_qry_sync_set(&decoder->query, &decoder->ip, offset);

	return pt_blk_start(decoder, status);

}

int pt_blk_get_offset(struct pt_block_decoder *decoder, uint64_t *offset)

{

	if (!decoder)

		return -pte_invalid;

	return pt_qry_get_offset(&decoder->query, offset);

}

int pt_blk_get_sync_offset(struct pt_block_decoder *decoder, uint64_t *offset)

{

	if (!decoder)

		return -pte_invalid;

	return pt_qry_get_sync_offset(&decoder->query, offset);

}

struct pt_image *pt_blk_get_image(struct pt_block_decoder *decoder)

{

	if (!decoder)

		return NULL;

	return decoder->image;

}

int pt_blk_set_image(struct pt_block_decoder *decoder, struct pt_image *image)

{

	if (!decoder)

		return -pte_invalid;

	if (!image)

		image = &decoder->default_image;

	decoder->image = image;

	return 0;

}

const struct pt_config *

pt_blk_get_config(const struct pt_block_decoder *decoder)

{

	if (!decoder)

		return NULL;

	return pt_qry_get_config(&decoder->query);

}

int pt_blk_time(struct pt_block_decoder *decoder, uint64_t *time,

		uint32_t *lost_mtc, uint32_t *lost_cyc)

{

	if (!decoder || !time)

		return -pte_invalid;

	return pt_qry_time(&decoder->query, time, lost_mtc, lost_cyc);

}

int pt_blk_core_bus_ratio(struct pt_block_decoder *decoder, uint32_t *cbr)

{

	if (!decoder || !cbr)

		return -pte_invalid;

	return pt_qry_core_bus_ratio(&decoder->query, cbr);

}

/* Fetch the next pending event.

 *

 * Checks for pending events.  If an event is pending, fetches it (if not

 * already in process).

 *

 * Returns zero if no event is pending.

 * Returns a positive integer if an event is pending or in process.

 * Returns a negative error code otherwise.

 */

static inline int pt_blk_fetch_event(struct pt_block_decoder *decoder)

{

	int status;

	if (!decoder)

		return -pte_internal;

	if (decoder->process_event)

		return 1;

	if (!(decoder->status & pts_event_pending))

		return 0;

	status = pt_qry_event(&decoder->query, &decoder->event,

			      sizeof(decoder->event));

	if (status < 0)

		return status;

	decoder->process_event = 1;

	decoder->status = status;

	return 1;

}

static inline int pt_blk_block_is_empty(const struct pt_block *block)

{

	if (!block)

		return 1;

	return !block->ninsn;

}

static inline int block_to_user(struct pt_block *ublock, size_t size,

				const struct pt_block *block)

{

	if (!ublock || !block)

		return -pte_internal;

	if (ublock == block)

		return 0;

	/* Zero out any unknown bytes. */

	if (sizeof(*block) < size) {

		memset(ublock + sizeof(*block), 0, size - sizeof(*block));

		size = sizeof(*block);

	}

	memcpy(ublock, block, size);

	return 0;

}

static int pt_insn_false(const struct pt_insn *insn,

			 const struct pt_insn_ext *iext)

{

	(void) insn;

	(void) iext;

	return 0;

}

/* Determine the next IP using trace.

 *

 * Tries to determine the IP of the next instruction using trace and provides it

 * in @pip.

 *

 * Not requiring trace to determine the IP is treated as an internal error.

 *

 * Does not update the return compression stack for indirect calls.  This is

 * expected to have been done, already, when trying to determine the next IP

 * without using trace.

 *

 * Does not update @decoder->status.  The caller is expected to do that.

 *

 * Returns a non-negative pt_status_flag bit-vector on success, a negative error

 * code otherwise.

 * Returns -pte_internal if @pip, @decoder, @insn, or @iext are NULL.

 * Returns -pte_internal if no trace is required.

 */

static int pt_blk_next_ip(uint64_t *pip, struct pt_block_decoder *decoder,

			  const struct pt_insn *insn,

			  const struct pt_insn_ext *iext)

{

	int status;

	if (!pip || !decoder || !insn || !iext)

		return -pte_internal;

	/* We handle non-taken conditional branches, and compressed returns

	 * directly in the switch.

	 *

	 * All kinds of branches are handled below the switch.

	 */

	switch (insn->iclass) {

	case ptic_cond_jump: {

		uint64_t ip;

		int taken;

		status = pt_qry_cond_branch(&decoder->query, &taken);

		if (status < 0)

			return status;

		ip = insn->ip + insn->size;

		if (taken)

			ip += iext->variant.branch.displacement;

		*pip = ip;

		return status;

	}

	case ptic_return: {

		int taken, errcode;

		/* Check for a compressed return. */

		status = pt_qry_cond_branch(&decoder->query, &taken);

		if (status < 0) {

			if (status != -pte_bad_query)

				return status;

			break;

		}

		/* A compressed return is indicated by a taken conditional

		 * branch.

		 */

		if (!taken)

			return -pte_bad_retcomp;

		errcode = pt_retstack_pop(&decoder->retstack, pip);

		if (errcode < 0)

			return errcode;

		return status;

	}

	case ptic_jump:

	case ptic_call:

		/* A direct jump or call wouldn't require trace. */

		if (iext->variant.branch.is_direct)

			return -pte_internal;

		break;

	case ptic_far_call:

	case ptic_far_return:

	case ptic_far_jump:

		break;

	case ptic_other:

		return -pte_internal;

	case ptic_error:

		return -pte_bad_insn;

	}

	/* Process an indirect branch.

	 *

	 * This covers indirect jumps and calls, non-compressed returns, and all

	 * flavors of far transfers.

	 */

	return pt_qry_indirect_branch(&decoder->query, pip);

}

/* Process an enabled event.

 *

 * Determines whether the enabled event can be processed in this iteration or

 * has to be postponed.

 *

 * Returns a positive integer if the event has been processed.

 * Returns zero if the event shall be postponed.

 * Returns a negative error code otherwise.

 */

static int pt_blk_process_enabled(struct pt_block_decoder *decoder,

				  struct pt_block *block,

				  const struct pt_event *ev)

{

	if (!decoder || !block || !ev)

		return -pte_internal;

	/* This event can't be a status update. */

	if (ev->status_update)

		return -pte_bad_context;

	/* We must have an IP in order to start decoding. */

	if (ev->ip_suppressed)

		return -pte_noip;

	/* We must currently be disabled. */

	if (decoder->enabled)

		return -pte_bad_context;

	/* Delay processing of the event if the block is alredy in progress. */

	if (!pt_blk_block_is_empty(block))

		return 0;

	/* Check if we resumed from a preceding disable or if we enabled at a

	 * different position.

	 */

	if (ev->variant.enabled.ip == decoder->ip && !block->enabled)

		block->resumed = 1;

	else {

		block->enabled = 1;

		block->resumed = 0;

	}

	/* Clear an indication of a preceding disable. */

	block->disabled = 0;

	block->ip = decoder->ip = ev->variant.enabled.ip;

	decoder->enabled = 1;

	decoder->process_event = 0;

	return 1;

}

/* Apply a disabled event.

 *

 * This is used for proceed events and for trailing events.

 *

 * Returns zero on success, a negative error code otherwise.

 */

static int pt_blk_apply_disabled(struct pt_block_decoder *decoder,

				 struct pt_block *block,

				 const struct pt_event *ev)

{

	if (!decoder || !block || !ev)

		return -pte_internal;

	/* This event can't be a status update. */

	if (ev->status_update)

		return -pte_bad_context;

	/* We must currently be enabled. */

	if (!decoder->enabled)

		return -pte_bad_context;

	/* We preserve @decoder->ip.  This is where we expect tracing to resume

	 * and we'll indicate that on the subsequent enabled event if tracing

	 * actually does resume from there.

	 */

	decoder->enabled = 0;

	decoder->process_event = 0;

	block->disabled = 1;

	return 0;

}

/* Process a disabled event.

 *

 * We reached the location of a disabled event.  This ends a non-empty block.

 *

 * We may see disabled events for empty blocks when we have a series of enables

 * and disabled on the same IP without any trace in between.  We ignore the

 * disabled event in this case and proceed.

 *

 * Returns a positive integer if the event has been processed.

 * Returns zero if the event shall be postponed.

 * Returns a negative error code otherwise.

 */

static int pt_blk_process_disabled(struct pt_block_decoder *decoder,

				   struct pt_block *block,

				   const struct pt_event *ev)

{

	int errcode;

	if (!block)

		return -pte_internal;

	errcode = pt_blk_apply_disabled(decoder, block, ev);

	if (errcode < 0)

		return errcode;

	/* The event completes a non-empty block. */

	if (!pt_blk_block_is_empty(block))

		return 0;

	/* Ignore the disable if the block is empty. */

	block->disabled = 0;

	return 1;

}

/* Apply an asynchronous branch event.

 *

 * This is used for proceed events and for trailing events.

 *

 * Returns zero on success, a negative error code otherwise.

 */

static int pt_blk_apply_async_branch(struct pt_block_decoder *decoder,

				     struct pt_block *block,

				     const struct pt_event *ev)

{

	if (!decoder || !block || !ev)

		return -pte_internal;

	/* This event can't be a status update. */

	if (ev->status_update)

		return -pte_bad_context;

	/* We must currently be enabled. */

	if (!decoder->enabled)

		return -pte_bad_context;

	/* Indicate the async branch as an interrupt.  This ends the block. */

	block->interrupted = 1;

	/* Jump to the branch destination.  We will continue from there in the

	 * next iteration.

	 */

	decoder->ip = ev->variant.async_branch.to;

	decoder->process_event = 0;

	return 0;

}

/* Process an asynchronous branch event.

 *

 * We reached the source location of an asynchronous branch.  This ends a

 * non-empty block.

 *

 * We may come across an asynchronous branch for an empty block, e.g. when

 * tracing just started.  We ignore the event in that case and proceed.  It will

 * look like tracing started at the asynchronous branch destination instead of

 * at its source.

 *

 * Returns a positive integer if the event has been processed.

 * Returns zero if the event shall be postponed.

 * Returns a negative error code otherwise.

 */

static int pt_blk_process_async_branch(struct pt_block_decoder *decoder,

				       struct pt_block *block,

				       const struct pt_event *ev)

{

	int errcode;

	if (!block)

		return -pte_internal;

	errcode = pt_blk_apply_async_branch(decoder, block, ev);

	if (errcode < 0)

		return errcode;

	if (!pt_blk_block_is_empty(block))

		return 0;

	/* We may still change the start IP for an empty block.  Do not indicate

	 * the interrupt in this case.

	 */

	block->interrupted = 0;

	block->ip = decoder->ip;

	return 1;

}

/* Apply a paging event.

 *

 * This is used for proceed events and for trailing events.

 *

 * Returns zero on success, a negative error code otherwise.

 */

static int pt_blk_apply_paging(struct pt_block_decoder *decoder,

			       struct pt_block *block,

			       const struct pt_event *ev)

{

	(void) block;

	if (!decoder || !ev)

		return -pte_internal;

	decoder->asid.cr3 = ev->variant.paging.cr3;

	decoder->process_event = 0;

	return 0;

}

/* Apply a vmcs event.

 *

 * This is used for proceed events and for trailing events.

 *

 * Returns zero on success, a negative error code otherwise.

 */

static int pt_blk_apply_vmcs(struct pt_block_decoder *decoder,

			     struct pt_block *block,

			     const struct pt_event *ev)

{

	(void) block;

	if (!decoder || !ev)

		return -pte_internal;

	decoder->asid.vmcs = ev->variant.vmcs.base;

	decoder->process_event = 0;

	return 0;

}

/* Process an overflow event.

 *

 * An overflow ends a non-empty block.  The overflow itself is indicated in the

 * next block.  Indicate the overflow and resume in this case.

 *

 * Returns a positive integer if the event has been processed.

 * Returns zero if the event shall be postponed.

 * Returns a negative error code otherwise.

 */

static int pt_blk_process_overflow(struct pt_block_decoder *decoder,

				   struct pt_block *block,

				   const struct pt_event *ev)

{

	if (!decoder || !block || !ev)

		return -pte_internal;

	/* This event can't be a status update. */

	if (ev->status_update)

		return -pte_bad_context;

	/* The overflow ends a non-empty block.  We will process the event in

	 * the next iteration.

	 */

	if (!pt_blk_block_is_empty(block))

		return 0;

	/* If the IP is suppressed, the overflow resolved while tracing was

	 * disabled.  Otherwise it resolved while tracing was enabled.

	 */

	if (ev->ip_suppressed) {

		/* Tracing is disabled.  It doesn't make sense to preserve the

		 * previous IP.  This will just be misleading.  Even if tracing

		 * had been disabled before, as well, we might have missed the

		 * re-enable in the overflow.

		 */

		decoder->enabled = 0;

		decoder->ip = 0ull;

		/* Indicate the overflow.  Since tracing is disabled, the block

		 * will remain empty until tracing gets re-enabled again.

		 *

		 * When the block is eventually returned it will have the resync

		 * and the enabled bit set to indicate the the overflow resolved

		 * before tracing was enabled.

		 */

		block->resynced = 1;

	} else {

		/* Tracing is enabled and we're at the IP at which the overflow

		 * resolved.

		 */

		decoder->enabled = 1;

		decoder->ip = ev->variant.overflow.ip;

		/* Indicate the overflow and set the start IP.  The block is

		 * empty so we may still change it.

		 *

		 * We do not indicate a tracing enable if tracing had been

		 * disabled before to distinguish this from the above case.

		 */

		block->resynced = 1;

		block->ip = decoder->ip;

	}

	/* We don't know the TSX state.  Let's assume we execute normally.

	 *

	 * We also don't know the execution mode.  Let's keep what we have

	 * in case we don't get an update before we have to decode the next

	 * instruction.

	 */

	decoder->speculative = 0;

	decoder->process_event = 0;

	return 1;

}

/* Apply an exec mode event.

 *

 * This is used for proceed events and for trailing events.

 *

 * Returns zero on success, a negative error code otherwise.

 */

static int pt_blk_apply_exec_mode(struct pt_block_decoder *decoder,

				  struct pt_block *block,

				  const struct pt_event *ev)

{

	enum pt_exec_mode mode;

	if (!decoder || !block || !ev)

		return -pte_internal;

	/* Use status update events to diagnose inconsistencies. */

	mode = ev->variant.exec_mode.mode;

	if (ev->status_update && decoder->enabled &&

	    decoder->mode != ptem_unknown && decoder->mode != mode)

		return -pte_bad_status_update;