/*

 * 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_insn.h"

#include "pt_ild.h"

#include "pt_image.h"

#include "intel-pt.h"

int pt_insn_changes_cpl(const struct pt_insn *insn,

			const struct pt_insn_ext *iext)

{

	(void) insn;

	if (!iext)

		return 0;

	switch (iext->iclass) {

	default:

		return 0;

	case PTI_INST_INT:

	case PTI_INST_INT3:

	case PTI_INST_INT1:

	case PTI_INST_INTO:

	case PTI_INST_IRET:

	case PTI_INST_SYSCALL:

	case PTI_INST_SYSENTER:

	case PTI_INST_SYSEXIT:

	case PTI_INST_SYSRET:

		return 1;

	}

}

int pt_insn_changes_cr3(const struct pt_insn *insn,

			const struct pt_insn_ext *iext)

{

	(void) insn;

	if (!iext)

		return 0;

	switch (iext->iclass) {

	default:

		return 0;

	case PTI_INST_MOV_CR3:

		return 1;

	}

}

int pt_insn_is_branch(const struct pt_insn *insn,

		      const struct pt_insn_ext *iext)

{

	(void) iext;

	if (!insn)

		return 0;

	switch (insn->iclass) {

	default:

		return 0;

	case ptic_call:

	case ptic_return:

	case ptic_jump:

	case ptic_cond_jump:

	case ptic_far_call:

	case ptic_far_return:

	case ptic_far_jump:

		return 1;

	}

}

int pt_insn_is_far_branch(const struct pt_insn *insn,

			  const struct pt_insn_ext *iext)

{

	(void) iext;

	if (!insn)

		return 0;

	switch (insn->iclass) {

	default:

		return 0;

	case ptic_far_call:

	case ptic_far_return:

	case ptic_far_jump:

		return 1;

	}

}

int pt_insn_binds_to_pip(const struct pt_insn *insn,

			 const struct pt_insn_ext *iext)

{

	if (!iext)

		return 0;

	switch (iext->iclass) {

	default:

		return pt_insn_is_far_branch(insn, iext);

	case PTI_INST_MOV_CR3:

	case PTI_INST_VMLAUNCH:

	case PTI_INST_VMRESUME:

		return 1;

	}

}

int pt_insn_binds_to_vmcs(const struct pt_insn *insn,

			  const struct pt_insn_ext *iext)

{

	if (!iext)

		return 0;

	switch (iext->iclass) {

	default:

		return pt_insn_is_far_branch(insn, iext);

	case PTI_INST_VMPTRLD:

	case PTI_INST_VMLAUNCH:

	case PTI_INST_VMRESUME:

		return 1;

	}

}

int pt_insn_next_ip(uint64_t *pip, const struct pt_insn *insn,

		    const struct pt_insn_ext *iext)

{

	uint64_t ip;

	if (!insn || !iext)

		return -pte_internal;

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

	switch (insn->iclass) {

	case ptic_other:

		break;

	case ptic_call:

	case ptic_jump:

		if (iext->variant.branch.is_direct) {

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

			break;

		}

		/* Fall through. */

	default:

		return -pte_bad_query;

	case ptic_error:

		return -pte_bad_insn;

	}

	if (pip)

		*pip = ip;

	return 0;

}

/* Retry decoding an instruction after a preceding decode error.

 *

 * Instruction length decode typically fails due to 'not enough

 * bytes'.

 *

 * This may be caused by partial updates of text sections

 * represented via new image sections overlapping the original

 * text section's image section.  We stop reading memory at the

 * end of the section so we do not read the full instruction if

 * parts of it have been overwritten by the update.

 *

 * Try to read the remaining bytes and decode the instruction again.  If we

 * succeed, set @insn->truncated to indicate that the instruction is truncated

 * in @insn->isid.

 *

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

 * Returns -pte_bad_insn if the instruction could not be decoded.

 */

static int pt_insn_decode_retry(struct pt_insn *insn, struct pt_insn_ext *iext,

				struct pt_image *image,

				const struct pt_asid *asid)

{

	int size, errcode, isid;

	uint8_t isize, remaining;

	if (!insn)

		return -pte_internal;

	isize = insn->size;

	remaining = sizeof(insn->raw) - isize;

	/* We failed for real if we already read the maximum number of bytes for

	 * an instruction.

	 */

	if (!remaining)

		return -pte_bad_insn;

	/* Read the remaining bytes from the image. */

	size = pt_image_read(image, &isid, &insn->raw[isize], remaining, asid,

			     insn->ip + isize);

	if (size <= 0) {

		/* We should have gotten an error if we were not able to read at

		 * least one byte.  Check this to guarantee termination.

		 */

		if (!size)

			return -pte_internal;

		return size;

	}

	/* Add the newly read bytes to the instruction's size. */

	insn->size += (uint8_t) size;

	/* Store the new size to avoid infinite recursion in case instruction

	 * decode fails after length decode, which would set @insn->size to the

	 * actual length.

	 */

	size = insn->size;

	/* Try to decode the instruction again.

	 *

	 * If we fail again, we recursively retry again until we either fail to

	 * read more bytes or reach the maximum number of bytes for an

	 * instruction.

	 */

	errcode = pt_ild_decode(insn, iext);

	if (errcode < 0) {

		if (errcode != -pte_bad_insn)

			return errcode;

		/* If instruction length decode already determined the size,

		 * there's no point in reading more bytes.

		 */

		if (insn->size != (uint8_t) size)

			return errcode;

		return pt_insn_decode_retry(insn, iext, image, asid);

	}

	/* We succeeded this time, so the instruction crosses image section

	 * boundaries.

	 *

	 * This poses the question which isid to use for the instruction.

	 *

	 * To reconstruct exactly this instruction at a later time, we'd need to

	 * store all isids involved together with the number of bytes read for

	 * each isid.  Since @insn already provides the exact bytes for this

	 * instruction, we assume that the isid will be used solely for source

	 * correlation.  In this case, it should refer to the first byte of the

	 * instruction - as it already does.

	 */

	insn->truncated = 1;

	return errcode;

}

int pt_insn_decode(struct pt_insn *insn, struct pt_insn_ext *iext,

		   struct pt_image *image, const struct pt_asid *asid)

{

	int size, errcode;

	if (!insn)

		return -pte_internal;

	/* Read the memory at the current IP in the current address space. */

	size = pt_image_read(image, &insn->isid, insn->raw, sizeof(insn->raw),

			     asid, insn->ip);

	if (size < 0)

		return size;

	/* We initialize @insn->size to the maximal possible size.  It will be

	 * set to the actual size during instruction decode.

	 */

	insn->size = (uint8_t) size;

	errcode = pt_ild_decode(insn, iext);

	if (errcode < 0) {

		if (errcode != -pte_bad_insn)

			return errcode;

		/* If instruction length decode already determined the size,

		 * there's no point in reading more bytes.

		 */

		if (insn->size != (uint8_t) size)

			return errcode;

		return pt_insn_decode_retry(insn, iext, image, asid);

	}

	return errcode;

}

int pt_insn_range_is_contiguous(uint64_t begin, uint64_t end,

				enum pt_exec_mode mode, struct pt_image *image,

				const struct pt_asid *asid, size_t steps)

{

	struct pt_insn_ext iext;

	struct pt_insn insn;

	memset(&insn, 0, sizeof(insn));

	insn.mode = mode;

	insn.ip = begin;

	while (insn.ip != end) {

		int errcode;

		if (!steps--)

			return 0;

		errcode = pt_insn_decode(&insn, &iext, image, asid);

		if (errcode < 0)

			return errcode;

		errcode = pt_insn_next_ip(&insn.ip, &insn, &iext;;

		if (errcode < 0)

			return errcode;

	}

	return 1;

}