tools/perf/tests/shell/inject_aslr.sh - linux - Git at Google

 #!/bin/bash
 # SPDX-License-Identifier: GPL-2.0
 # perf inject --aslr test

 set -e
 set -o pipefail

 shelldir=$(dirname "$0")
 # shellcheck source=lib/perf_has_symbol.sh
 . "${shelldir}"/lib/perf_has_symbol.sh

 sym="noploop"

 skip_test_missing_symbol ${sym}

 # Create global temp directory
 temp_dir=$(mktemp -d /tmp/perf-test-aslr.XXXXXXXXXX)

 prog="perf test -w noploop"
 [ "$(uname -m)" = "s390x" ] && prog="$prog 3"
 err=0
 kprog="dd if=/dev/urandom of=/dev/null bs=1M count=50"

 cleanup() {
   local exit_code=${1:-$?}
   trap - EXIT TERM INT
   if [ "${exit_code}" -ne 0 ] || [ "${err}" -ne 0 ]; then
     echo "Test failed! Preserving temp directory: ${temp_dir}"
     return
   fi
   # Check if temp_dir is set and looks sane before removing
   if [[ "${temp_dir}" =~ ^/tmp/perf-test-aslr\. ]]; then
     rm -rf "${temp_dir}"
   fi
 }

 trap_cleanup() {
   local exit_code=$?
   echo "Unexpected signal in ${FUNCNAME[1]}"
   cleanup ${exit_code}
   exit ${exit_code}
 }
 trap trap_cleanup EXIT TERM INT

 get_noploop_addr() {
   local file=$1
   perf script -i "$file" | awk '
     BEGIN { found=0 }
     {
       for (i=1; i<=NF; i++) {
         if ($i ~ /noploop\+/) {
           if (!found) {
             print $(i-1)
             found=1
           }
         }
       }
     }'
 }

 test_basic_aslr() {
   echo "Test basic ASLR remapping"
   local data
   data=$(mktemp "${temp_dir}/perf.data.basic.XXXXXX")
   local data2
   data2=$(mktemp "${temp_dir}/perf.data2.basic.XXXXXX")

   perf record -e task-clock:u -o "${data}" ${prog}
   perf inject -v --aslr -i "${data}" -o "${data2}"

   orig_addr=$(get_noploop_addr "${data}")
   new_addr=$(get_noploop_addr "${data2}")

   echo "Basic ASLR: orig_addr=$orig_addr, new_addr=$new_addr"

   if [ -z "$orig_addr" ]; then
     echo "Basic ASLR test [Failed - no noploop samples in original file]"
     err=1
   elif [ -z "$new_addr" ]; then
     echo "Basic ASLR test [Failed - could not find remapped address]"
     err=1
   elif [ "$orig_addr" = "$new_addr" ]; then
     echo "Basic ASLR test [Failed - addresses are not remapped]"
     err=1
   else
     echo "Basic ASLR test [Success]"
   fi
 }

 test_pipe_aslr() {
   echo "Test pipe mode ASLR remapping"
   local data
   data=$(mktemp "${temp_dir}/perf.data.pipe.XXXXXX")
   local data2
   data2=$(mktemp "${temp_dir}/perf.data2.pipe.XXXXXX")

   # Use tee to save the original pipe data for comparison
   perf record -e task-clock:u -o - ${prog} | tee "${data}" | perf inject --aslr -o "${data2}"

   orig_addr=$(get_noploop_addr "${data}")
   new_addr=$(get_noploop_addr "${data2}")

   echo "Pipe ASLR: orig_addr=$orig_addr, new_addr=$new_addr"

   if [ -z "$orig_addr" ]; then
     echo "Pipe ASLR test [Failed - no noploop samples in original file]"
     err=1
   elif [ -z "$new_addr" ]; then
     echo "Pipe ASLR test [Failed - could not find remapped address]"
     err=1
   elif [ "$orig_addr" = "$new_addr" ]; then
     echo "Pipe ASLR test [Failed - addresses are not remapped]"
     err=1
   else
     echo "Pipe ASLR test [Success]"
   fi
 }

 test_callchain_aslr() {
   echo "Test Callchain ASLR remapping"
   local data
   data=$(mktemp "${temp_dir}/perf.data.callchain.XXXXXX")
   local data2
   data2=$(mktemp "${temp_dir}/perf.data2.callchain.XXXXXX")

   perf record -g -e task-clock:u -o "${data}" ${prog}
   perf inject --aslr -i "${data}" -o "${data2}"

   orig_addr=$(get_noploop_addr "${data}")
   new_addr=$(get_noploop_addr "${data2}")

   echo "Callchain ASLR: orig_addr=$orig_addr, new_addr=$new_addr"

   if [ -z "$orig_addr" ]; then
     echo "Callchain ASLR test [Failed - no noploop samples in original file]"
     err=1
   elif [ -z "$new_addr" ]; then
     echo "Callchain ASLR test [Failed - could not find remapped address]"
     err=1
   elif [ "$orig_addr" = "$new_addr" ]; then
     echo "Callchain ASLR test [Failed - addresses are not remapped]"
     err=1
   else
     # Extract callchain addresses (indented lines starting with hex addresses)
     orig_callchain=$(perf script -i "${data}" | awk '/^[[:space:]]+[0-9a-f]+/ {print $1}')
     new_callchain=$(perf script -i "${data2}" | awk '/^[[:space:]]+[0-9a-f]+/ {print $1}')

     if [ -z "$orig_callchain" ]; then
       echo "Callchain ASLR test [Failed - no callchain samples in original file]"
       err=1
     elif [ -z "$new_callchain" ]; then
       echo "Callchain ASLR test [Failed - callchain data was dropped]"
       err=1
     elif [ "$orig_callchain" = "$new_callchain" ]; then
       echo "Callchain ASLR test [Failed - callchain addresses were not remapped]"
       err=1
     else
       echo "Callchain ASLR test [Success]"
     fi
   fi
 }

 test_report_aslr() {
   echo "Test perf report consistency"
   local data
   data=$(mktemp "${temp_dir}/perf.data.report.XXXXXX")
   local data2
   data2=$(mktemp "${temp_dir}/perf.data2.report.XXXXXX")
   local data_clean
   data_clean=$(mktemp "${temp_dir}/perf.data.clean.XXXXXX")

   perf record -e task-clock:u -o "${data}" ${prog}
   # Use -b to inject build-ids and force ordered events processing in both
   perf inject -b -i "${data}" -o "${data_clean}"
   perf inject -v -b --aslr -i "${data}" -o "${data2}"

   local report1="${temp_dir}/report1_basic"
   local report2="${temp_dir}/report2_basic"
   local report1_clean="${temp_dir}/report1_basic.clean"
   local report2_clean="${temp_dir}/report2_basic.clean"
   local diff_file="${temp_dir}/diff_basic"

   perf report -i "${data_clean}" --stdio > "${report1}"
   perf report -i "${data2}" --stdio > "${report2}"

   # Strip headers and compare lines with percentages
   grep '%' "${report1}" | grep -v '^#' | \
     grep -v -E '0x[0-9a-f]{8,}|0000000000000000' | sort > "${report1_clean}" || true
   grep '%' "${report2}" | grep -v '^#' | \
     grep -v -E '0x[0-9a-f]{8,}|0000000000000000' | sort > "${report2_clean}" || true

   diff -u -w "${report1_clean}" "${report2_clean}" > "${diff_file}" || true

   if [ ! -s "${report1_clean}" ]; then
     echo "Report ASLR test [Failed - no samples captured]"
     err=1
   elif [ -s "${diff_file}" ]; then
     echo "Report ASLR test [Failed - reports differ]"
     echo "Showing first 20 lines of diff:"
     head -n 20 "${diff_file}"
     err=1
   else
     echo "Report ASLR test [Success]"
   fi
 }

 test_pipe_report_aslr() {
   echo "Test pipe mode perf report consistency"
   local data
   data=$(mktemp "${temp_dir}/perf.data.pipe_report.XXXXXX")
   local data2
   data2=$(mktemp "${temp_dir}/perf.data2.pipe_report.XXXXXX")
   local data_clean
   data_clean=$(mktemp "${temp_dir}/perf.data.clean.XXXXXX")

   # Use tee to save the original pipe data, then process it with inject -b
   perf record -e task-clock:u -o - ${prog} | \
     tee "${data}" | \
     perf inject -b --aslr -o "${data2}"
   perf inject -b -i "${data}" -o "${data_clean}"

   local report1="${temp_dir}/report1_pipe"
   local report2="${temp_dir}/report2_pipe"
   local report1_clean="${temp_dir}/report1_pipe.clean"
   local report2_clean="${temp_dir}/report2_pipe.clean"
   local diff_file="${temp_dir}/diff_pipe"

   perf report -i "${data_clean}" --stdio > "${report1}"
   perf report -i "${data2}" --stdio > "${report2}"

   # Strip headers and compare lines with percentages
   grep '%' "${report1}" | grep -v '^#' | \
     grep -v -E '0x[0-9a-f]{8,}|0000000000000000' | sort > "${report1_clean}" || true
   grep '%' "${report2}" | grep -v '^#' | \
     grep -v -E '0x[0-9a-f]{8,}|0000000000000000' | sort > "${report2_clean}" || true

   diff -u -w "${report1_clean}" "${report2_clean}" > "${diff_file}" || true

   if [ ! -s "${report1_clean}" ]; then
     echo "Pipe Report ASLR test [Failed - no samples captured]"
     err=1
   elif [ -s "${diff_file}" ]; then
     echo "Pipe Report ASLR test [Failed - reports differ]"
     echo "Showing first 20 lines of diff:"
     head -n 20 "${diff_file}"
     err=1
   else
     echo "Pipe Report ASLR test [Success]"
   fi
 }

 test_pipe_out_report_aslr() {
   echo "Test pipe output mode perf report consistency"
   local data
   data=$(mktemp "${temp_dir}/perf.data.pipe_out_report.XXXXXX")
   local data_clean
   data_clean=$(mktemp "${temp_dir}/perf.data.clean.XXXXXX")

   perf record -e task-clock:u -o "${data}" ${prog}
   perf inject -b -i "${data}" -o "${data_clean}"

   local report1="${temp_dir}/report1_pipe_out"
   local report2="${temp_dir}/report2_pipe_out"
   local report1_clean="${temp_dir}/report1_pipe_out.clean"
   local report2_clean="${temp_dir}/report2_pipe_out.clean"
   local diff_file="${temp_dir}/diff_pipe_out"

   perf report -i "${data_clean}" --stdio > "${report1}"
   perf inject -b --aslr -i "${data}" -o - | perf report -i - --stdio > "${report2}"

   # Strip headers and compare lines with percentages
   grep '%' "${report1}" | grep -v '^#' | \
     grep -v -E '0x[0-9a-f]{8,}|0000000000000000' | sort > "${report1_clean}" || true
   grep '%' "${report2}" | grep -v '^#' | \
     grep -v -E '0x[0-9a-f]{8,}|0000000000000000' | sort > "${report2_clean}" || true

   diff -u -w "${report1_clean}" "${report2_clean}" > "${diff_file}" || true

   if [ ! -s "${report1_clean}" ]; then
     echo "Pipe Output Report ASLR test [Failed - no samples captured]"
     err=1
   elif [ -s "${diff_file}" ]; then
     echo "Pipe Output Report ASLR test [Failed - reports differ]"
     echo "Showing first 20 lines of diff:"
     head -n 20 "${diff_file}"
     err=1
   else
     echo "Pipe Output Report ASLR test [Success]"
   fi
 }

 test_dropped_samples() {
   echo "Test dropped samples (phys-data)"
   local data
   data=$(mktemp "${temp_dir}/perf.data.dropped.XXXXXX")
   local data2
   data2=$(mktemp "${temp_dir}/perf.data2.dropped.XXXXXX")

   # Check if --phys-data is supported by recording a short run
   if ! perf record -e task-clock:u --phys-data -o "${data}" -- sleep 0.1 > /dev/null 2>&1; then
     echo "Skipping dropped samples test as --phys-data is not supported"
     return
   fi

   perf record -e task-clock:u --phys-data -o "${data}" ${prog}
   perf inject --aslr -i "${data}" -o "${data2}"

   # Verify that the original file actually contained samples!
   orig_samples=$(perf script -i "${data}" | wc -l)
   if [ "$orig_samples" -eq 0 ]; then
     echo "Dropped samples test [Failed - no samples in original file]"
     err=1
   else
     # Verify that samples are dropped.
     samples_count=$(perf script -i "${data2}" | wc -l)

     if [ "$samples_count" -gt 0 ]; then
       echo "Dropped samples test [Failed - samples were not dropped]"
       err=1
     else
       echo "Dropped samples test [Success]"
     fi
   fi
 }

 test_kernel_aslr() {
   echo "Test kernel ASLR remapping"
   local kdata
   kdata=$(mktemp "${temp_dir}/perf.data.kernel.XXXXXX")
   local kdata2
   kdata2=$(mktemp "${temp_dir}/perf.data2.kernel.XXXXXX")
   local log_file
   log_file=$(mktemp "${temp_dir}/kernel_record.log.XXXXXX")

   # Try to record kernel samples
   if ! perf record -e task-clock:k -o "${kdata}" ${kprog} > "${log_file}" 2>&1; then
     echo "Skipping kernel ASLR test as recording failed (maybe no permissions)"
     return
   fi

   # Check for warning about kernel map restriction
   if grep -q "Couldn't record kernel reference relocation symbol" "${log_file}"; then
     echo "Skipping kernel ASLR test as kernel map could not be recorded (permissions restricted)"
     return
   fi

   perf inject -v --aslr -i "${kdata}" -o "${kdata2}"

   # Check if kernel addresses are remapped.
   # Find the field that ends with :k: (the event name) and take the next field!
   orig_addr=$(perf script -i "${kdata}" | awk '
     BEGIN { found=0 }
     {
       for (i=1; i<NF; i++) {
         if ($i ~ /:[k]+:?$/) {
           if (!found) {
             print $(i+1)
             found=1
           }
         }
       }
     }')
   new_addr=$(perf script -i "${kdata2}" | awk '
     BEGIN { found=0 }
     {
       for (i=1; i<NF; i++) {
         if ($i ~ /:[k]+:?$/) {
           if (!found) {
             print $(i+1)
             found=1
           }
         }
       }
     }')

   echo "Kernel ASLR: orig_addr=$orig_addr, new_addr=$new_addr"

   if [ -z "$orig_addr" ]; then
     echo "Kernel ASLR test [Failed - no kernel samples in original file]"
     err=1
   elif [ -z "$new_addr" ]; then
     echo "Kernel ASLR test [Failed - could not find remapped address]"
     err=1
   elif [ "$orig_addr" = "$new_addr" ]; then
     echo "Kernel ASLR test [Failed - addresses are not remapped]"
     err=1
   else
     echo "Kernel ASLR test [Success]"
   fi
 }

 test_kernel_report_aslr() {
   echo "Test kernel perf report consistency"
   local kdata
   kdata=$(mktemp "${temp_dir}/perf.data.kernel_report.XXXXXX")
   local kdata2
   kdata2=$(mktemp "${temp_dir}/perf.data2.kernel_report.XXXXXX")
   local data_clean
   data_clean=$(mktemp "${temp_dir}/perf.data.clean.XXXXXX")
   local log_file
   log_file=$(mktemp "${temp_dir}/kernel_report_record.log.XXXXXX")

   # Try to record kernel samples
   if ! perf record -e task-clock:k -o "${kdata}" ${kprog} > "${log_file}" 2>&1; then
     echo "Skipping kernel report test as recording failed (maybe no permissions)"
     return
   fi

   # Check for warning about kernel map restriction
   if grep -q "Couldn't record kernel reference relocation symbol" "${log_file}"; then
     echo "Skipping kernel report test as kernel map could not be recorded (permissions restricted)"
     return
   fi

   # Use -b to inject build-ids and force ordered events processing in both
   perf inject -b -i "${kdata}" -o "${data_clean}"
   perf inject -v -b --aslr -i "${kdata}" -o "${kdata2}"

   local report1="${temp_dir}/report_kernel1"
   local report2="${temp_dir}/report_kernel2"
   local report1_clean="${temp_dir}/report_kernel1.clean"
   local report2_clean="${temp_dir}/report_kernel2.clean"

   perf report -i "${data_clean}" --stdio > "${report1}"
   perf report -i "${kdata2}" --stdio > "${report2}"

   # Strip headers and compare lines with percentages
   grep '%' "${report1}" | grep -v '^#' > "${report1_clean}" || true
   grep '%' "${report2}" | grep -v '^#' > "${report2_clean}" || true

   # Normalize kernel DSOs and addresses in clean reports
   # This allows kernel modules to be either a module or kernel.kallsyms
   local report1_norm="${temp_dir}/report_kernel1.norm"
   local report2_norm="${temp_dir}/report_kernel2.norm"
   local diff_file="${temp_dir}/diff_kernel"

   grep -v -E '0x[0-9a-f]{8,}|0000000000000000' "${report1_clean}" | \
     awk '{gsub(/\[[a-zA-Z0-9_.-]{2,}\](\.[a-zA-Z0-9_]+)?/, "[kernel]", $0); print}' | \
     sort > "${report1_norm}" || true
   grep -v -E '0x[0-9a-f]{8,}|0000000000000000' "${report2_clean}" | \
     awk '{gsub(/\[[a-zA-Z0-9_.-]{2,}\](\.[a-zA-Z0-9_]+)?/, "[kernel]", $0); print}' | \
     sort > "${report2_norm}" || true

   diff -u -w "${report1_norm}" "${report2_norm}" > "${diff_file}" || true

   if [ ! -s "${report1_norm}" ]; then
     echo "Kernel Report ASLR test [Failed - no samples captured]"
     err=1
   elif [ -s "${diff_file}" ]; then
     echo "Kernel Report ASLR test [Failed - reports differ]"
     echo "Showing first 20 lines of diff:"
     head -n 20 "${diff_file}"
     err=1
   else
     echo "Kernel Report ASLR test [Success]"
   fi
 }

 test_regs_stripping() {
   echo "Test user register stripping"
   local rdata="${temp_dir}/perf.data.regs"
   local rdata2="${temp_dir}/perf.data.regs.injected"
   local rdata_clean="${temp_dir}/perf.data.regs.clean"

   if ! perf record -e cycles:u --user-regs -o "${rdata}" ${prog} > /dev/null 2>&1; then
     echo "Skipping user registers test as recording failed (unsupported flag/platform)"
     return
   fi

   perf inject -b -i "${rdata}" -o "${rdata_clean}"
   perf inject -v -b --aslr -i "${rdata}" -o "${rdata2}"

   local report1="${temp_dir}/report_regs1"
   local report2="${temp_dir}/report_regs2"
   local report1_clean="${temp_dir}/report_regs1.clean"
   local report2_clean="${temp_dir}/report_regs2.clean"
   local diff_file="${temp_dir}/diff_regs"

   perf report -i "${rdata_clean}" --stdio > "${report1}" 2>/dev/null || true
   perf report -i "${rdata2}" --stdio > "${report2}" 2>/dev/null || true

   grep '%' "${report1}" | grep -v '^#' | \
     grep -v -E '0x[0-9a-f]{8,}|0000000000000000' | \
     sort > "${report1_clean}" || true
   grep '%' "${report2}" | grep -v '^#' | \
     grep -v -E '0x[0-9a-f]{8,}|0000000000000000' | \
     sort > "${report2_clean}" || true

   diff -u -w "${report1_clean}" "${report2_clean}" > "${diff_file}" || true

   if [ ! -s "${report1_clean}" ]; then
     echo "User registers stripping test [Failed - profile trace starved/empty]"
     err=1
     return
   elif [ -s "${diff_file}" ]; then
     echo "User registers stripping test [Failed - report parsing differs]"
     echo "Showing first 20 lines of diff:"
     head -n 20 "${diff_file}"
     err=1
     return
   fi

   local script_dump="${temp_dir}/script_regs_dump"
   perf script -D -i "${rdata2}" > "${script_dump}" 2>/dev/null || true
   if grep -q "user regs:" "${script_dump}"; then
     echo "User registers stripping test [Failed - register dumps still present]"
     err=1
   else
     echo "User registers stripping test [Success]"
   fi
 }

 test_basic_aslr
 test_pipe_aslr
 test_callchain_aslr
 test_report_aslr
 test_pipe_report_aslr
 test_pipe_out_report_aslr
 test_dropped_samples
 case "$(uname -m)" in
   aarch64*|arm*)
     echo "Skipping kernel ASLR tests on ARM"
     ;;
   *)
     test_kernel_aslr
     test_kernel_report_aslr
     ;;
 esac

 test_regs_stripping

 cleanup ${err}
 exit $err
	#!/bin/bash
	# SPDX-License-Identifier: GPL-2.0
	# perf inject --aslr test

	set -e
	set -o pipefail

	shelldir=$(dirname "$0")
	# shellcheck source=lib/perf_has_symbol.sh
	. "${shelldir}"/lib/perf_has_symbol.sh

	sym="noploop"

	skip_test_missing_symbol ${sym}

	# Create global temp directory
	temp_dir=$(mktemp -d /tmp/perf-test-aslr.XXXXXXXXXX)

	prog="perf test -w noploop"
	[ "$(uname -m)" = "s390x" ] && prog="$prog 3"
	err=0
	kprog="dd if=/dev/urandom of=/dev/null bs=1M count=50"

	cleanup() {
	local exit_code=${1:-$?}
	trap - EXIT TERM INT
	if [ "${exit_code}" -ne 0 ] \|\| [ "${err}" -ne 0 ]; then
	echo "Test failed! Preserving temp directory: ${temp_dir}"
	return
	fi
	# Check if temp_dir is set and looks sane before removing
	if [[ "${temp_dir}" =~ ^/tmp/perf-test-aslr\. ]]; then
	rm -rf "${temp_dir}"
	fi
	}

	trap_cleanup() {
	local exit_code=$?
	echo "Unexpected signal in ${FUNCNAME[1]}"
	cleanup ${exit_code}
	exit ${exit_code}
	}
	trap trap_cleanup EXIT TERM INT

	get_noploop_addr() {
	local file=$1
	perf script -i "$file" \| awk '
	BEGIN { found=0 }
	{
	for (i=1; i<=NF; i++) {
	if ($i ~ /noploop\+/) {
	if (!found) {
	print $(i-1)
	found=1
	}
	}
	}
	}'
	}

	test_basic_aslr() {
	echo "Test basic ASLR remapping"
	local data
	data=$(mktemp "${temp_dir}/perf.data.basic.XXXXXX")
	local data2
	data2=$(mktemp "${temp_dir}/perf.data2.basic.XXXXXX")

	perf record -e task-clock:u -o "${data}" ${prog}
	perf inject -v --aslr -i "${data}" -o "${data2}"

	orig_addr=$(get_noploop_addr "${data}")
	new_addr=$(get_noploop_addr "${data2}")

	echo "Basic ASLR: orig_addr=$orig_addr, new_addr=$new_addr"

	if [ -z "$orig_addr" ]; then
	echo "Basic ASLR test [Failed - no noploop samples in original file]"
	err=1
	elif [ -z "$new_addr" ]; then
	echo "Basic ASLR test [Failed - could not find remapped address]"
	err=1
	elif [ "$orig_addr" = "$new_addr" ]; then
	echo "Basic ASLR test [Failed - addresses are not remapped]"
	err=1
	else
	echo "Basic ASLR test [Success]"
	fi
	}

	test_pipe_aslr() {
	echo "Test pipe mode ASLR remapping"
	local data
	data=$(mktemp "${temp_dir}/perf.data.pipe.XXXXXX")
	local data2
	data2=$(mktemp "${temp_dir}/perf.data2.pipe.XXXXXX")

	# Use tee to save the original pipe data for comparison
	perf record -e task-clock:u -o - ${prog} \| tee "${data}" \| perf inject --aslr -o "${data2}"

	orig_addr=$(get_noploop_addr "${data}")
	new_addr=$(get_noploop_addr "${data2}")

	echo "Pipe ASLR: orig_addr=$orig_addr, new_addr=$new_addr"

	if [ -z "$orig_addr" ]; then
	echo "Pipe ASLR test [Failed - no noploop samples in original file]"
	err=1
	elif [ -z "$new_addr" ]; then
	echo "Pipe ASLR test [Failed - could not find remapped address]"
	err=1
	elif [ "$orig_addr" = "$new_addr" ]; then
	echo "Pipe ASLR test [Failed - addresses are not remapped]"
	err=1
	else
	echo "Pipe ASLR test [Success]"
	fi
	}

	test_callchain_aslr() {
	echo "Test Callchain ASLR remapping"
	local data
	data=$(mktemp "${temp_dir}/perf.data.callchain.XXXXXX")
	local data2
	data2=$(mktemp "${temp_dir}/perf.data2.callchain.XXXXXX")

	perf record -g -e task-clock:u -o "${data}" ${prog}
	perf inject --aslr -i "${data}" -o "${data2}"

	orig_addr=$(get_noploop_addr "${data}")
	new_addr=$(get_noploop_addr "${data2}")

	echo "Callchain ASLR: orig_addr=$orig_addr, new_addr=$new_addr"

	if [ -z "$orig_addr" ]; then
	echo "Callchain ASLR test [Failed - no noploop samples in original file]"
	err=1
	elif [ -z "$new_addr" ]; then
	echo "Callchain ASLR test [Failed - could not find remapped address]"
	err=1
	elif [ "$orig_addr" = "$new_addr" ]; then
	echo "Callchain ASLR test [Failed - addresses are not remapped]"
	err=1
	else
	# Extract callchain addresses (indented lines starting with hex addresses)
	orig_callchain=$(perf script -i "${data}" \| awk '/^[[:space:]]+[0-9a-f]+/ {print $1}')
	new_callchain=$(perf script -i "${data2}" \| awk '/^[[:space:]]+[0-9a-f]+/ {print $1}')

	if [ -z "$orig_callchain" ]; then
	echo "Callchain ASLR test [Failed - no callchain samples in original file]"
	err=1
	elif [ -z "$new_callchain" ]; then
	echo "Callchain ASLR test [Failed - callchain data was dropped]"
	err=1
	elif [ "$orig_callchain" = "$new_callchain" ]; then
	echo "Callchain ASLR test [Failed - callchain addresses were not remapped]"
	err=1
	else
	echo "Callchain ASLR test [Success]"
	fi
	fi
	}

	test_report_aslr() {
	echo "Test perf report consistency"
	local data
	data=$(mktemp "${temp_dir}/perf.data.report.XXXXXX")
	local data2
	data2=$(mktemp "${temp_dir}/perf.data2.report.XXXXXX")
	local data_clean
	data_clean=$(mktemp "${temp_dir}/perf.data.clean.XXXXXX")

	perf record -e task-clock:u -o "${data}" ${prog}
	# Use -b to inject build-ids and force ordered events processing in both
	perf inject -b -i "${data}" -o "${data_clean}"
	perf inject -v -b --aslr -i "${data}" -o "${data2}"

	local report1="${temp_dir}/report1_basic"
	local report2="${temp_dir}/report2_basic"
	local report1_clean="${temp_dir}/report1_basic.clean"
	local report2_clean="${temp_dir}/report2_basic.clean"
	local diff_file="${temp_dir}/diff_basic"

	perf report -i "${data_clean}" --stdio > "${report1}"
	perf report -i "${data2}" --stdio > "${report2}"

	# Strip headers and compare lines with percentages
	grep '%' "${report1}" \| grep -v '^#' \| \
	grep -v -E '0x[0-9a-f]{8,}\|0000000000000000' \| sort > "${report1_clean}" \|\| true
	grep '%' "${report2}" \| grep -v '^#' \| \
	grep -v -E '0x[0-9a-f]{8,}\|0000000000000000' \| sort > "${report2_clean}" \|\| true

	diff -u -w "${report1_clean}" "${report2_clean}" > "${diff_file}" \|\| true

	if [ ! -s "${report1_clean}" ]; then
	echo "Report ASLR test [Failed - no samples captured]"
	err=1
	elif [ -s "${diff_file}" ]; then
	echo "Report ASLR test [Failed - reports differ]"
	echo "Showing first 20 lines of diff:"
	head -n 20 "${diff_file}"
	err=1
	else
	echo "Report ASLR test [Success]"
	fi
	}

	test_pipe_report_aslr() {
	echo "Test pipe mode perf report consistency"
	local data
	data=$(mktemp "${temp_dir}/perf.data.pipe_report.XXXXXX")
	local data2
	data2=$(mktemp "${temp_dir}/perf.data2.pipe_report.XXXXXX")
	local data_clean
	data_clean=$(mktemp "${temp_dir}/perf.data.clean.XXXXXX")

	# Use tee to save the original pipe data, then process it with inject -b
	perf record -e task-clock:u -o - ${prog} \| \
	tee "${data}" \| \
	perf inject -b --aslr -o "${data2}"
	perf inject -b -i "${data}" -o "${data_clean}"

	local report1="${temp_dir}/report1_pipe"
	local report2="${temp_dir}/report2_pipe"
	local report1_clean="${temp_dir}/report1_pipe.clean"
	local report2_clean="${temp_dir}/report2_pipe.clean"
	local diff_file="${temp_dir}/diff_pipe"

	perf report -i "${data_clean}" --stdio > "${report1}"
	perf report -i "${data2}" --stdio > "${report2}"

	# Strip headers and compare lines with percentages
	grep '%' "${report1}" \| grep -v '^#' \| \
	grep -v -E '0x[0-9a-f]{8,}\|0000000000000000' \| sort > "${report1_clean}" \|\| true
	grep '%' "${report2}" \| grep -v '^#' \| \
	grep -v -E '0x[0-9a-f]{8,}\|0000000000000000' \| sort > "${report2_clean}" \|\| true

	diff -u -w "${report1_clean}" "${report2_clean}" > "${diff_file}" \|\| true

	if [ ! -s "${report1_clean}" ]; then
	echo "Pipe Report ASLR test [Failed - no samples captured]"
	err=1
	elif [ -s "${diff_file}" ]; then
	echo "Pipe Report ASLR test [Failed - reports differ]"
	echo "Showing first 20 lines of diff:"
	head -n 20 "${diff_file}"
	err=1
	else
	echo "Pipe Report ASLR test [Success]"
	fi
	}

	test_pipe_out_report_aslr() {
	echo "Test pipe output mode perf report consistency"
	local data
	data=$(mktemp "${temp_dir}/perf.data.pipe_out_report.XXXXXX")
	local data_clean
	data_clean=$(mktemp "${temp_dir}/perf.data.clean.XXXXXX")

	perf record -e task-clock:u -o "${data}" ${prog}
	perf inject -b -i "${data}" -o "${data_clean}"

	local report1="${temp_dir}/report1_pipe_out"
	local report2="${temp_dir}/report2_pipe_out"
	local report1_clean="${temp_dir}/report1_pipe_out.clean"
	local report2_clean="${temp_dir}/report2_pipe_out.clean"
	local diff_file="${temp_dir}/diff_pipe_out"

	perf report -i "${data_clean}" --stdio > "${report1}"
	perf inject -b --aslr -i "${data}" -o - \| perf report -i - --stdio > "${report2}"

	# Strip headers and compare lines with percentages
	grep '%' "${report1}" \| grep -v '^#' \| \
	grep -v -E '0x[0-9a-f]{8,}\|0000000000000000' \| sort > "${report1_clean}" \|\| true
	grep '%' "${report2}" \| grep -v '^#' \| \
	grep -v -E '0x[0-9a-f]{8,}\|0000000000000000' \| sort > "${report2_clean}" \|\| true

	diff -u -w "${report1_clean}" "${report2_clean}" > "${diff_file}" \|\| true

	if [ ! -s "${report1_clean}" ]; then
	echo "Pipe Output Report ASLR test [Failed - no samples captured]"
	err=1
	elif [ -s "${diff_file}" ]; then
	echo "Pipe Output Report ASLR test [Failed - reports differ]"
	echo "Showing first 20 lines of diff:"
	head -n 20 "${diff_file}"
	err=1
	else
	echo "Pipe Output Report ASLR test [Success]"
	fi
	}

	test_dropped_samples() {
	echo "Test dropped samples (phys-data)"
	local data
	data=$(mktemp "${temp_dir}/perf.data.dropped.XXXXXX")
	local data2
	data2=$(mktemp "${temp_dir}/perf.data2.dropped.XXXXXX")

	# Check if --phys-data is supported by recording a short run
	if ! perf record -e task-clock:u --phys-data -o "${data}" -- sleep 0.1 > /dev/null 2>&1; then
	echo "Skipping dropped samples test as --phys-data is not supported"
	return
	fi

	perf record -e task-clock:u --phys-data -o "${data}" ${prog}
	perf inject --aslr -i "${data}" -o "${data2}"

	# Verify that the original file actually contained samples!
	orig_samples=$(perf script -i "${data}" \| wc -l)
	if [ "$orig_samples" -eq 0 ]; then
	echo "Dropped samples test [Failed - no samples in original file]"
	err=1
	else
	# Verify that samples are dropped.
	samples_count=$(perf script -i "${data2}" \| wc -l)

	if [ "$samples_count" -gt 0 ]; then
	echo "Dropped samples test [Failed - samples were not dropped]"
	err=1
	else
	echo "Dropped samples test [Success]"
	fi
	fi
	}

	test_kernel_aslr() {
	echo "Test kernel ASLR remapping"
	local kdata
	kdata=$(mktemp "${temp_dir}/perf.data.kernel.XXXXXX")
	local kdata2
	kdata2=$(mktemp "${temp_dir}/perf.data2.kernel.XXXXXX")
	local log_file
	log_file=$(mktemp "${temp_dir}/kernel_record.log.XXXXXX")

	# Try to record kernel samples
	if ! perf record -e task-clock:k -o "${kdata}" ${kprog} > "${log_file}" 2>&1; then
	echo "Skipping kernel ASLR test as recording failed (maybe no permissions)"
	return
	fi

	# Check for warning about kernel map restriction
	if grep -q "Couldn't record kernel reference relocation symbol" "${log_file}"; then
	echo "Skipping kernel ASLR test as kernel map could not be recorded (permissions restricted)"
	return
	fi

	perf inject -v --aslr -i "${kdata}" -o "${kdata2}"

	# Check if kernel addresses are remapped.
	# Find the field that ends with :k: (the event name) and take the next field!
	orig_addr=$(perf script -i "${kdata}" \| awk '
	BEGIN { found=0 }
	{
	for (i=1; i<NF; i++) {
	if ($i ~ /:[k]+:?$/) {
	if (!found) {
	print $(i+1)
	found=1
	}
	}
	}
	}')
	new_addr=$(perf script -i "${kdata2}" \| awk '
	BEGIN { found=0 }
	{
	for (i=1; i<NF; i++) {
	if ($i ~ /:[k]+:?$/) {
	if (!found) {
	print $(i+1)
	found=1
	}
	}
	}
	}')

	echo "Kernel ASLR: orig_addr=$orig_addr, new_addr=$new_addr"

	if [ -z "$orig_addr" ]; then
	echo "Kernel ASLR test [Failed - no kernel samples in original file]"
	err=1
	elif [ -z "$new_addr" ]; then
	echo "Kernel ASLR test [Failed - could not find remapped address]"
	err=1
	elif [ "$orig_addr" = "$new_addr" ]; then
	echo "Kernel ASLR test [Failed - addresses are not remapped]"
	err=1
	else
	echo "Kernel ASLR test [Success]"
	fi
	}

	test_kernel_report_aslr() {
	echo "Test kernel perf report consistency"
	local kdata
	kdata=$(mktemp "${temp_dir}/perf.data.kernel_report.XXXXXX")
	local kdata2
	kdata2=$(mktemp "${temp_dir}/perf.data2.kernel_report.XXXXXX")
	local data_clean
	data_clean=$(mktemp "${temp_dir}/perf.data.clean.XXXXXX")
	local log_file
	log_file=$(mktemp "${temp_dir}/kernel_report_record.log.XXXXXX")

	# Try to record kernel samples
	if ! perf record -e task-clock:k -o "${kdata}" ${kprog} > "${log_file}" 2>&1; then
	echo "Skipping kernel report test as recording failed (maybe no permissions)"
	return
	fi

	# Check for warning about kernel map restriction
	if grep -q "Couldn't record kernel reference relocation symbol" "${log_file}"; then
	echo "Skipping kernel report test as kernel map could not be recorded (permissions restricted)"
	return
	fi

	# Use -b to inject build-ids and force ordered events processing in both
	perf inject -b -i "${kdata}" -o "${data_clean}"
	perf inject -v -b --aslr -i "${kdata}" -o "${kdata2}"

	local report1="${temp_dir}/report_kernel1"
	local report2="${temp_dir}/report_kernel2"
	local report1_clean="${temp_dir}/report_kernel1.clean"
	local report2_clean="${temp_dir}/report_kernel2.clean"

	perf report -i "${data_clean}" --stdio > "${report1}"
	perf report -i "${kdata2}" --stdio > "${report2}"

	# Strip headers and compare lines with percentages
	grep '%' "${report1}" \| grep -v '^#' > "${report1_clean}" \|\| true
	grep '%' "${report2}" \| grep -v '^#' > "${report2_clean}" \|\| true

	# Normalize kernel DSOs and addresses in clean reports
	# This allows kernel modules to be either a module or kernel.kallsyms
	local report1_norm="${temp_dir}/report_kernel1.norm"
	local report2_norm="${temp_dir}/report_kernel2.norm"
	local diff_file="${temp_dir}/diff_kernel"

	grep -v -E '0x[0-9a-f]{8,}\|0000000000000000' "${report1_clean}" \| \
	awk '{gsub(/\[[a-zA-Z0-9_.-]{2,}\](\.[a-zA-Z0-9_]+)?/, "[kernel]", $0); print}' \| \
	sort > "${report1_norm}" \|\| true
	grep -v -E '0x[0-9a-f]{8,}\|0000000000000000' "${report2_clean}" \| \
	awk '{gsub(/\[[a-zA-Z0-9_.-]{2,}\](\.[a-zA-Z0-9_]+)?/, "[kernel]", $0); print}' \| \
	sort > "${report2_norm}" \|\| true

	diff -u -w "${report1_norm}" "${report2_norm}" > "${diff_file}" \|\| true

	if [ ! -s "${report1_norm}" ]; then
	echo "Kernel Report ASLR test [Failed - no samples captured]"
	err=1
	elif [ -s "${diff_file}" ]; then
	echo "Kernel Report ASLR test [Failed - reports differ]"
	echo "Showing first 20 lines of diff:"
	head -n 20 "${diff_file}"
	err=1
	else
	echo "Kernel Report ASLR test [Success]"
	fi
	}

	test_regs_stripping() {
	echo "Test user register stripping"
	local rdata="${temp_dir}/perf.data.regs"
	local rdata2="${temp_dir}/perf.data.regs.injected"
	local rdata_clean="${temp_dir}/perf.data.regs.clean"

	if ! perf record -e cycles:u --user-regs -o "${rdata}" ${prog} > /dev/null 2>&1; then
	echo "Skipping user registers test as recording failed (unsupported flag/platform)"
	return
	fi

	perf inject -b -i "${rdata}" -o "${rdata_clean}"
	perf inject -v -b --aslr -i "${rdata}" -o "${rdata2}"

	local report1="${temp_dir}/report_regs1"
	local report2="${temp_dir}/report_regs2"
	local report1_clean="${temp_dir}/report_regs1.clean"
	local report2_clean="${temp_dir}/report_regs2.clean"
	local diff_file="${temp_dir}/diff_regs"

	perf report -i "${rdata_clean}" --stdio > "${report1}" 2>/dev/null \|\| true
	perf report -i "${rdata2}" --stdio > "${report2}" 2>/dev/null \|\| true

	grep '%' "${report1}" \| grep -v '^#' \| \
	grep -v -E '0x[0-9a-f]{8,}\|0000000000000000' \| \
	sort > "${report1_clean}" \|\| true
	grep '%' "${report2}" \| grep -v '^#' \| \
	grep -v -E '0x[0-9a-f]{8,}\|0000000000000000' \| \
	sort > "${report2_clean}" \|\| true

	diff -u -w "${report1_clean}" "${report2_clean}" > "${diff_file}" \|\| true

	if [ ! -s "${report1_clean}" ]; then
	echo "User registers stripping test [Failed - profile trace starved/empty]"
	err=1
	return
	elif [ -s "${diff_file}" ]; then
	echo "User registers stripping test [Failed - report parsing differs]"
	echo "Showing first 20 lines of diff:"
	head -n 20 "${diff_file}"
	err=1
	return
	fi

	local script_dump="${temp_dir}/script_regs_dump"
	perf script -D -i "${rdata2}" > "${script_dump}" 2>/dev/null \|\| true
	if grep -q "user regs:" "${script_dump}"; then
	echo "User registers stripping test [Failed - register dumps still present]"
	err=1
	else
	echo "User registers stripping test [Success]"
	fi
	}

	test_basic_aslr
	test_pipe_aslr
	test_callchain_aslr
	test_report_aslr
	test_pipe_report_aslr
	test_pipe_out_report_aslr
	test_dropped_samples
	case "$(uname -m)" in
	aarch64\|arm)
	echo "Skipping kernel ASLR tests on ARM"
	;;
	*)
	test_kernel_aslr
	test_kernel_report_aslr
	;;
	esac

	test_regs_stripping

	cleanup ${err}
	exit $err