Commit 973db240 authored by Adrian Hunter's avatar Adrian Hunter Committed by Arnaldo Carvalho de Melo
Browse files

perf test: test_intel_pt.sh: Add jitdump test 



Add a test for decoding self-modifying code using a jitdump file.

The test creates a workload that uses self-modifying code and generates its
own jitdump file.  The result is processed with perf inject --jit and
checked for decoding errors.

Note the test will fail without patch "perf inject: Fix GEN_ELF_TEXT_OFFSET
for jit" applied.

Signed-off-by: default avatarAdrian Hunter <adrian.hunter@intel.com>
Tested-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
Cc: Ian Rogers <irogers@google.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Link: https://lore.kernel.org/r/20221014170905.64069-6-adrian.hunter@intel.com


Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 40053a4b

tools/perf/tests/shell/test_intel_pt.sh

+162 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ outfile="${temp_dir}/test-out.txt" 
errfile="${temp_dir}/test-err.txt"

workload="${temp_dir}/workload"

awkscript="${temp_dir}/awkscript"

jitdump_workload="${temp_dir}/jitdump_workload"



cleanup()

{
@@ -50,6 +51,13 @@ perf_record_no_decode() 
	perf record -B -N --no-bpf-event "$@"

}



# perf record for testing should not need BPF events

perf_record_no_bpf()

{

	# Options for no BPF events

	perf record --no-bpf-event "$@"

}



have_workload=false

cat << _end_of_file_ | /usr/bin/cc -o "${workload}" -xc - -pthread && have_workload=true

#include <time.h>
@@ -269,6 +277,159 @@ test_per_thread() 
	return 0

}



test_jitdump()

{

	echo "--- Test tracing self-modifying code that uses jitdump ---"



	script_path=$(realpath "$0")

	script_dir=$(dirname "$script_path")

	jitdump_incl_dir="${script_dir}/../../util"

	jitdump_h="${jitdump_incl_dir}/jitdump.h"



	if [ ! -e "${jitdump_h}" ] ; then

		echo "SKIP: Include file jitdump.h not found"

		return 2

	fi



	if [ -z "${have_jitdump_workload}" ] ; then

		have_jitdump_workload=false

		# Create a workload that uses self-modifying code and generates its own jitdump file

		cat <<- "_end_of_file_" | /usr/bin/cc -o "${jitdump_workload}" -I "${jitdump_incl_dir}" -xc - -pthread && have_jitdump_workload=true

		#define _GNU_SOURCE

		#include <sys/mman.h>

		#include <sys/types.h>

		#include <stddef.h>

		#include <stdio.h>

		#include <stdint.h>

		#include <unistd.h>

		#include <string.h>



		#include "jitdump.h"



		#define CHK_BYTE 0x5a



		static inline uint64_t rdtsc(void)

		{

			unsigned int low, high;



			asm volatile("rdtsc" : "=a" (low), "=d" (high));



			return low | ((uint64_t)high) << 32;

		}



		static FILE *open_jitdump(void)

		{

			struct jitheader header = {

				.magic      = JITHEADER_MAGIC,

				.version    = JITHEADER_VERSION,

				.total_size = sizeof(header),

				.pid        = getpid(),

				.timestamp  = rdtsc(),

				.flags      = JITDUMP_FLAGS_ARCH_TIMESTAMP,

			};

			char filename[256];

			FILE *f;

			void *m;



			snprintf(filename, sizeof(filename), "jit-%d.dump", getpid());

			f = fopen(filename, "w+");

			if (!f)

				goto err;

			/* Create an MMAP event for the jitdump file. That is how perf tool finds it. */

			m = mmap(0, 4096, PROT_READ | PROT_EXEC, MAP_PRIVATE, fileno(f), 0);

			if (m == MAP_FAILED)

				goto err_close;

			munmap(m, 4096);

			if (fwrite(&header,sizeof(header),1,f) != 1)

				goto err_close;

			return f;



		err_close:

			fclose(f);

		err:

			return NULL;

		}



		static int write_jitdump(FILE *f, void *addr, const uint8_t *dat, size_t sz, uint64_t *idx)

		{

			struct jr_code_load rec = {

				.p.id          = JIT_CODE_LOAD,

				.p.total_size  = sizeof(rec) + sz,

				.p.timestamp   = rdtsc(),

				.pid	       = getpid(),

				.tid	       = gettid(),

				.vma           = (unsigned long)addr,

				.code_addr     = (unsigned long)addr,

				.code_size     = sz,

				.code_index    = ++*idx,

			};



			if (fwrite(&rec,sizeof(rec),1,f) != 1 ||

			fwrite(dat, sz, 1, f) != 1)

				return -1;

			return 0;

		}



		static void close_jitdump(FILE *f)

		{

			fclose(f);

		}



		int main()

		{

			/* Get a memory page to store executable code */

			void *addr = mmap(0, 4096, PROT_WRITE | PROT_EXEC, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);

			/* Code to execute: mov CHK_BYTE, %eax ; ret */

			uint8_t dat[] = {0xb8, CHK_BYTE, 0x00, 0x00, 0x00, 0xc3};

			FILE *f = open_jitdump();

			uint64_t idx = 0;

			int ret = 1;



			if (!f)

				return 1;

			/* Copy executable code to executable memory page */

			memcpy(addr, dat, sizeof(dat));

			/* Record it in the jitdump file */

			if (write_jitdump(f, addr, dat, sizeof(dat), &idx))

				goto out_close;

			/* Call it */

			ret = ((int (*)(void))addr)() - CHK_BYTE;

		out_close:

			close_jitdump(f);

			return ret;

		}

		_end_of_file_

	fi



	if ! $have_jitdump_workload ; then

		echo "SKIP: No jitdump workload"

		return 2

	fi



	# Change to temp_dir so jitdump collateral files go there

	cd "${temp_dir}"

	perf_record_no_bpf -o "${tmpfile}" -e intel_pt//u "${jitdump_workload}"

	perf inject -i "${tmpfile}" -o "${perfdatafile}" --jit

	decode_br_cnt=$(perf script -i "${perfdatafile}" --itrace=b | wc -l)

	# Note that overflow and lost errors are suppressed for the error count

	decode_err_cnt=$(perf script -i "${perfdatafile}" --itrace=e-o-l | grep -ci error)

	cd -

	# Should be thousands of branches

	if [ "${decode_br_cnt}" -lt 1000 ] ; then

		echo "Decode failed, only ${decode_br_cnt} branches"

		return 1

	fi

	# Should be no errors

	if [ "${decode_err_cnt}" -ne 0 ] ; then

		echo "Decode failed, ${decode_err_cnt} errors"

		perf script -i "${perfdatafile}" --itrace=e-o-l

		return 1

	fi



	echo OK

	return 0

}



count_result()

{

	if [ "$1" -eq 2 ] ; then
@@ -286,6 +447,7 @@ ret=0 
test_system_wide_side_band		|| ret=$? ; count_result $ret ; ret=0

test_per_thread "" ""			|| ret=$? ; count_result $ret ; ret=0

test_per_thread "k" "(incl. kernel) "	|| ret=$? ; count_result $ret ; ret=0

test_jitdump				|| ret=$? ; count_result $ret ; ret=0



cleanup