tools/testing/selftests/powerpc/ptrace/ptrace-perf-hwbreak.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0+

 #include <asm/unistd.h>
 #include <linux/hw_breakpoint.h>
 #include <linux/ptrace.h>
 #include <memory.h>
 #include <stdlib.h>
 #include <sys/wait.h>

 #include "utils.h"

 /*
  * Child subroutine that performs a load on the address, then traps
  */
 void same_watch_addr_child(unsigned long *addr);

 /* Address of the ld instruction in same_watch_addr_child() */
 extern char same_watch_addr_load[];

 /* Address of the end trap instruction in same_watch_addr_child() */
 extern char same_watch_addr_trap[];

 /*
  * Child subroutine that performs a load on the first address, then a load on
  * the second address (with no instructions separating this from the first
  * load), then traps.
  */
 void perf_then_ptrace_child(unsigned long *first_addr, unsigned long *second_addr);

 /* Address of the first ld instruction in perf_then_ptrace_child() */
 extern char perf_then_ptrace_load1[];

 /* Address of the second ld instruction in perf_then_ptrace_child() */
 extern char perf_then_ptrace_load2[];

 /* Address of the end trap instruction in perf_then_ptrace_child() */
 extern char perf_then_ptrace_trap[];

 static inline long sys_ptrace(long request, pid_t pid, unsigned long addr, unsigned long data)
 {
 	return syscall(__NR_ptrace, request, pid, addr, data);
 }

 static long ptrace_traceme(void)
 {
 	return sys_ptrace(PTRACE_TRACEME, 0, 0, 0);
 }

 static long ptrace_getregs(pid_t pid, struct pt_regs *result)
 {
 	return sys_ptrace(PTRACE_GETREGS, pid, 0, (unsigned long)result);
 }

 static long ptrace_setregs(pid_t pid, struct pt_regs *result)
 {
 	return sys_ptrace(PTRACE_SETREGS, pid, 0, (unsigned long)result);
 }

 static long ptrace_cont(pid_t pid, long signal)
 {
 	return sys_ptrace(PTRACE_CONT, pid, 0, signal);
 }

 static long ptrace_singlestep(pid_t pid, long signal)
 {
 	return sys_ptrace(PTRACE_SINGLESTEP, pid, 0, signal);
 }

 static long ppc_ptrace_gethwdbginfo(pid_t pid, struct ppc_debug_info *dbginfo)
 {
 	return sys_ptrace(PPC_PTRACE_GETHWDBGINFO, pid, 0, (unsigned long)dbginfo);
 }

 static long ppc_ptrace_sethwdbg(pid_t pid, struct ppc_hw_breakpoint *bp_info)
 {
 	return sys_ptrace(PPC_PTRACE_SETHWDEBUG, pid, 0, (unsigned long)bp_info);
 }

 static long ppc_ptrace_delhwdbg(pid_t pid, int bp_id)
 {
 	return sys_ptrace(PPC_PTRACE_DELHWDEBUG, pid, 0L, bp_id);
 }

 static long ptrace_getreg_pc(pid_t pid, void **pc)
 {
 	struct pt_regs regs;
 	long err;

 	err = ptrace_getregs(pid, &regs);
 	if (err)
 		return err;

 	*pc = (void *)regs.nip;

 	return 0;
 }

 static long ptrace_setreg_pc(pid_t pid, void *pc)
 {
 	struct pt_regs regs;
 	long err;

 	err = ptrace_getregs(pid, &regs);
 	if (err)
 		return err;

 	regs.nip = (unsigned long)pc;

 	err = ptrace_setregs(pid, &regs);
 	if (err)
 		return err;

 	return 0;
 }

 static int perf_event_open(struct perf_event_attr *attr, pid_t pid, int cpu,
 			   int group_fd, unsigned long flags)
 {
 	return syscall(__NR_perf_event_open, attr, pid, cpu, group_fd, flags);
 }

 static void perf_user_event_attr_set(struct perf_event_attr *attr, void *addr, u64 len)
 {
 	memset(attr, 0, sizeof(struct perf_event_attr));

 	attr->type		= PERF_TYPE_BREAKPOINT;
 	attr->size		= sizeof(struct perf_event_attr);
 	attr->bp_type		= HW_BREAKPOINT_R;
 	attr->bp_addr		= (u64)addr;
 	attr->bp_len		= len;
 	attr->exclude_kernel	= 1;
 	attr->exclude_hv	= 1;
 }

 static int perf_watchpoint_open(pid_t child_pid, void *addr, u64 len)
 {
 	struct perf_event_attr attr;

 	perf_user_event_attr_set(&attr, addr, len);
 	return perf_event_open(&attr, child_pid, -1, -1, 0);
 }

 static int perf_read_counter(int perf_fd, u64 *count)
 {
 	/*
 	 * A perf counter is retrieved by the read() syscall. It contains
 	 * the current count as 8 bytes that are interpreted as a u64
 	 */
 	ssize_t len = read(perf_fd, count, sizeof(*count));

 	if (len != sizeof(*count))
 		return -1;

 	return 0;
 }

 static void ppc_ptrace_init_breakpoint(struct ppc_hw_breakpoint *info,
 				       int type, void *addr, int len)
 {
 	info->version = 1;
 	info->trigger_type = type;
 	info->condition_mode = PPC_BREAKPOINT_CONDITION_NONE;
 	info->addr = (u64)addr;
 	info->addr2 = (u64)addr + len;
 	info->condition_value = 0;
 	if (!len)
 		info->addr_mode = PPC_BREAKPOINT_MODE_EXACT;
 	else
 		info->addr_mode = PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE;
 }

 /*
  * Checks if we can place at least 2 watchpoints on the child process
  */
 static int check_watchpoints(pid_t pid)
 {
 	struct ppc_debug_info dbginfo;

 	FAIL_IF_MSG(ppc_ptrace_gethwdbginfo(pid, &dbginfo), "PPC_PTRACE_GETHWDBGINFO failed");
 	SKIP_IF_MSG(dbginfo.num_data_bps <= 1, "Not enough data watchpoints (need at least 2)");

 	return 0;
 }

 /*
  * Wrapper around a plain fork() call that sets up the child for
  * ptrace-ing. Both the parent and child return from this, though
  * the child is stopped until ptrace_cont(pid) is run by the parent.
  */
 static int ptrace_fork_child(pid_t *pid)
 {
 	int status;

 	*pid = fork();

 	if (*pid < 0)
 		FAIL_IF_MSG(1, "Failed to fork child");

 	if (!*pid) {
 		FAIL_IF_EXIT_MSG(ptrace_traceme(), "PTRACE_TRACEME failed");
 		FAIL_IF_EXIT_MSG(raise(SIGSTOP), "Child failed to raise SIGSTOP");
 	} else {
 		/* Synchronise on child SIGSTOP */
 		FAIL_IF_MSG(waitpid(*pid, &status, 0) == -1, "Failed to wait for child");
 		FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
 	}

 	return 0;
 }

 /*
  * Tests the interaction between ptrace and perf watching the same data.
  *
  * We expect ptrace to take 'priority', as it is has before-execute
  * semantics.
  *
  * The perf counter should not be incremented yet because perf has after-execute
  * semantics. E.g., if ptrace changes the child PC, we don't even execute the
  * instruction at all.
  *
  * When the child is stopped for ptrace, we test both continue and single step.
  * Both should increment the perf counter. We also test changing the PC somewhere
  * different and stepping, which should not increment the perf counter.
  */
 int same_watch_addr_test(void)
 {
 	struct ppc_hw_breakpoint bp_info;	/* ptrace breakpoint info */
 	int bp_id;	/* Breakpoint handle of ptrace watchpoint */
 	int perf_fd;	/* File descriptor of perf performance counter */
 	u64 perf_count;	/* Most recently fetched perf performance counter value */
 	pid_t pid;	/* PID of child process */
 	void *pc;	/* Most recently fetched child PC value */
 	int status;	/* Stop status of child after waitpid */
 	unsigned long value;	/* Dummy value to be read/written to by child */
 	int err;

 	err = ptrace_fork_child(&pid);
 	if (err)
 		return err;

 	if (!pid) {
 		same_watch_addr_child(&value);
 		exit(1);
 	}

 	err = check_watchpoints(pid);
 	if (err)
 		return err;

 	/* Place a perf watchpoint counter on value */
 	perf_fd = perf_watchpoint_open(pid, &value, sizeof(value));
 	FAIL_IF_MSG(perf_fd < 0, "Failed to open perf performance counter");

 	/* Place a ptrace watchpoint on value */
 	ppc_ptrace_init_breakpoint(&bp_info, PPC_BREAKPOINT_TRIGGER_READ, &value, sizeof(value));
 	bp_id = ppc_ptrace_sethwdbg(pid, &bp_info);
 	FAIL_IF_MSG(bp_id < 0, "Failed to set ptrace watchpoint");

 	/* Let the child run. It should stop on the ptrace watchpoint */
 	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

 	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
 	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
 	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
 	FAIL_IF_MSG(pc != same_watch_addr_load, "Child did not stop on load instruction");

 	/*
 	 * We stopped before executing the load, so perf should not have
 	 * recorded any events yet
 	 */
 	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
 	FAIL_IF_MSG(perf_count != 0, "perf recorded unexpected event");

 	/* Single stepping over the load should increment the perf counter */
 	FAIL_IF_MSG(ptrace_singlestep(pid, 0), "Failed to single step child");

 	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
 	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
 	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
 	FAIL_IF_MSG(pc != same_watch_addr_load + 4, "Failed to single step load instruction");
 	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
 	FAIL_IF_MSG(perf_count != 1, "perf counter did not increment");

 	/*
 	 * Set up a ptrace watchpoint on the value again and trigger it.
 	 * The perf counter should not have incremented because we do not
 	 * execute the load yet.
 	 */
 	FAIL_IF_MSG(ppc_ptrace_delhwdbg(pid, bp_id), "Failed to remove old ptrace watchpoint");
 	bp_id = ppc_ptrace_sethwdbg(pid, &bp_info);
 	FAIL_IF_MSG(bp_id < 0, "Failed to set ptrace watchpoint");
 	FAIL_IF_MSG(ptrace_setreg_pc(pid, same_watch_addr_load), "Failed to set child PC");
 	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

 	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
 	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
 	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
 	FAIL_IF_MSG(pc != same_watch_addr_load, "Child did not stop on load trap");
 	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
 	FAIL_IF_MSG(perf_count != 1, "perf counter should not have changed");

 	/* Continuing over the load should increment the perf counter */
 	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

 	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
 	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
 	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
 	FAIL_IF_MSG(pc != same_watch_addr_trap, "Child did not stop on end trap");
 	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
 	FAIL_IF_MSG(perf_count != 2, "perf counter did not increment");

 	/*
 	 * If we set the child PC back to the load instruction, then continue,
 	 * we should reach the end trap (because ptrace is one-shot) and have
 	 * another perf event.
 	 */
 	FAIL_IF_MSG(ptrace_setreg_pc(pid, same_watch_addr_load), "Failed to set child PC");
 	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

 	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
 	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
 	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
 	FAIL_IF_MSG(pc != same_watch_addr_trap, "Child did not stop on end trap");
 	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
 	FAIL_IF_MSG(perf_count != 3, "perf counter did not increment");

 	/*
 	 * If we set the child PC back to the load instruction, set a ptrace
 	 * watchpoint on the load, then continue, we should immediately get
 	 * the ptrace trap without incrementing the perf counter
 	 */
 	FAIL_IF_MSG(ppc_ptrace_delhwdbg(pid, bp_id), "Failed to remove old ptrace watchpoint");
 	bp_id = ppc_ptrace_sethwdbg(pid, &bp_info);
 	FAIL_IF_MSG(bp_id < 0, "Failed to set ptrace watchpoint");
 	FAIL_IF_MSG(ptrace_setreg_pc(pid, same_watch_addr_load), "Failed to set child PC");
 	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

 	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
 	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
 	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
 	FAIL_IF_MSG(pc != same_watch_addr_load, "Child did not stop on load instruction");
 	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
 	FAIL_IF_MSG(perf_count != 3, "perf counter should not have changed");

 	/*
 	 * If we change the PC while stopped on the load instruction, we should
 	 * not increment the perf counter (because ptrace is before-execute,
 	 * perf is after-execute).
 	 */
 	FAIL_IF_MSG(ptrace_setreg_pc(pid, same_watch_addr_load + 4), "Failed to set child PC");
 	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

 	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
 	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
 	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
 	FAIL_IF_MSG(pc != same_watch_addr_trap, "Child did not stop on end trap");
 	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
 	FAIL_IF_MSG(perf_count != 3, "perf counter should not have changed");

 	/* Clean up child */
 	FAIL_IF_MSG(kill(pid, SIGKILL) != 0, "Failed to kill child");

 	return 0;
 }

 /*
  * Tests the interaction between ptrace and perf when:
  * 1. perf watches a value
  * 2. ptrace watches a different value
  * 3. The perf value is read, then the ptrace value is read immediately after
  *
  * A breakpoint implementation may accidentally misattribute/skip one of
  * the ptrace or perf handlers, as interrupt based work is done after perf
  * and before ptrace.
  *
  * We expect the perf counter to increment before the ptrace watchpoint
  * triggers.
  */
 int perf_then_ptrace_test(void)
 {
 	struct ppc_hw_breakpoint bp_info;	/* ptrace breakpoint info */
 	int bp_id;	/* Breakpoint handle of ptrace watchpoint */
 	int perf_fd;	/* File descriptor of perf performance counter */
 	u64 perf_count;	/* Most recently fetched perf performance counter value */
 	pid_t pid;	/* PID of child process */
 	void *pc;	/* Most recently fetched child PC value */
 	int status;	/* Stop status of child after waitpid */
 	unsigned long perf_value;	/* Dummy value to be watched by perf */
 	unsigned long ptrace_value;	/* Dummy value to be watched by ptrace */
 	int err;

 	err = ptrace_fork_child(&pid);
 	if (err)
 		return err;

 	/*
 	 * If we are the child, run a subroutine that reads the perf value,
 	 * then reads the ptrace value with consecutive load instructions
 	 */
 	if (!pid) {
 		perf_then_ptrace_child(&perf_value, &ptrace_value);
 		exit(0);
 	}

 	err = check_watchpoints(pid);
 	if (err)
 		return err;

 	/* Place a perf watchpoint counter */
 	perf_fd = perf_watchpoint_open(pid, &perf_value, sizeof(perf_value));
 	FAIL_IF_MSG(perf_fd < 0, "Failed to open perf performance counter");

 	/* Place a ptrace watchpoint */
 	ppc_ptrace_init_breakpoint(&bp_info, PPC_BREAKPOINT_TRIGGER_READ,
 				   &ptrace_value, sizeof(ptrace_value));
 	bp_id = ppc_ptrace_sethwdbg(pid, &bp_info);
 	FAIL_IF_MSG(bp_id < 0, "Failed to set ptrace watchpoint");

 	/* Let the child run. It should stop on the ptrace watchpoint */
 	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

 	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
 	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
 	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
 	FAIL_IF_MSG(pc != perf_then_ptrace_load2, "Child did not stop on ptrace load");

 	/* perf should have recorded the first load */
 	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
 	FAIL_IF_MSG(perf_count != 1, "perf counter did not increment");

 	/* Clean up child */
 	FAIL_IF_MSG(kill(pid, SIGKILL) != 0, "Failed to kill child");

 	return 0;
 }

 int main(int argc, char *argv[])
 {
 	int err = 0;

 	err |= test_harness(same_watch_addr_test, "same_watch_addr");
 	err |= test_harness(perf_then_ptrace_test, "perf_then_ptrace");

 	return err;
 }
	// SPDX-License-Identifier: GPL-2.0+

	#include <asm/unistd.h>
	#include <linux/hw_breakpoint.h>
	#include <linux/ptrace.h>
	#include <memory.h>
	#include <stdlib.h>
	#include <sys/wait.h>

	#include "utils.h"

	/*
	* Child subroutine that performs a load on the address, then traps
	*/
	void same_watch_addr_child(unsigned long *addr);

	/* Address of the ld instruction in same_watch_addr_child() */
	extern char same_watch_addr_load[];

	/* Address of the end trap instruction in same_watch_addr_child() */
	extern char same_watch_addr_trap[];

	/*
	* Child subroutine that performs a load on the first address, then a load on
	* the second address (with no instructions separating this from the first
	* load), then traps.
	*/
	void perf_then_ptrace_child(unsigned long first_addr, unsigned long second_addr);

	/* Address of the first ld instruction in perf_then_ptrace_child() */
	extern char perf_then_ptrace_load1[];

	/* Address of the second ld instruction in perf_then_ptrace_child() */
	extern char perf_then_ptrace_load2[];

	/* Address of the end trap instruction in perf_then_ptrace_child() */
	extern char perf_then_ptrace_trap[];

	static inline long sys_ptrace(long request, pid_t pid, unsigned long addr, unsigned long data)
	{
	return syscall(__NR_ptrace, request, pid, addr, data);
	}

	static long ptrace_traceme(void)
	{
	return sys_ptrace(PTRACE_TRACEME, 0, 0, 0);
	}

	static long ptrace_getregs(pid_t pid, struct pt_regs *result)
	{
	return sys_ptrace(PTRACE_GETREGS, pid, 0, (unsigned long)result);
	}

	static long ptrace_setregs(pid_t pid, struct pt_regs *result)
	{
	return sys_ptrace(PTRACE_SETREGS, pid, 0, (unsigned long)result);
	}

	static long ptrace_cont(pid_t pid, long signal)
	{
	return sys_ptrace(PTRACE_CONT, pid, 0, signal);
	}

	static long ptrace_singlestep(pid_t pid, long signal)
	{
	return sys_ptrace(PTRACE_SINGLESTEP, pid, 0, signal);
	}

	static long ppc_ptrace_gethwdbginfo(pid_t pid, struct ppc_debug_info *dbginfo)
	{
	return sys_ptrace(PPC_PTRACE_GETHWDBGINFO, pid, 0, (unsigned long)dbginfo);
	}

	static long ppc_ptrace_sethwdbg(pid_t pid, struct ppc_hw_breakpoint *bp_info)
	{
	return sys_ptrace(PPC_PTRACE_SETHWDEBUG, pid, 0, (unsigned long)bp_info);
	}

	static long ppc_ptrace_delhwdbg(pid_t pid, int bp_id)
	{
	return sys_ptrace(PPC_PTRACE_DELHWDEBUG, pid, 0L, bp_id);
	}

	static long ptrace_getreg_pc(pid_t pid, void **pc)
	{
	struct pt_regs regs;
	long err;

	err = ptrace_getregs(pid, &regs);
	if (err)
	return err;

	pc = (void )regs.nip;

	return 0;
	}

	static long ptrace_setreg_pc(pid_t pid, void *pc)
	{
	struct pt_regs regs;
	long err;

	err = ptrace_getregs(pid, &regs);
	if (err)
	return err;

	regs.nip = (unsigned long)pc;

	err = ptrace_setregs(pid, &regs);
	if (err)
	return err;

	return 0;
	}

	static int perf_event_open(struct perf_event_attr *attr, pid_t pid, int cpu,
	int group_fd, unsigned long flags)
	{
	return syscall(__NR_perf_event_open, attr, pid, cpu, group_fd, flags);
	}

	static void perf_user_event_attr_set(struct perf_event_attr attr, void addr, u64 len)
	{
	memset(attr, 0, sizeof(struct perf_event_attr));

	attr->type = PERF_TYPE_BREAKPOINT;
	attr->size = sizeof(struct perf_event_attr);
	attr->bp_type = HW_BREAKPOINT_R;
	attr->bp_addr = (u64)addr;
	attr->bp_len = len;
	attr->exclude_kernel = 1;
	attr->exclude_hv = 1;
	}

	static int perf_watchpoint_open(pid_t child_pid, void *addr, u64 len)
	{
	struct perf_event_attr attr;

	perf_user_event_attr_set(&attr, addr, len);
	return perf_event_open(&attr, child_pid, -1, -1, 0);
	}

	static int perf_read_counter(int perf_fd, u64 *count)
	{
	/*
	* A perf counter is retrieved by the read() syscall. It contains
	* the current count as 8 bytes that are interpreted as a u64
	*/
	ssize_t len = read(perf_fd, count, sizeof(*count));

	if (len != sizeof(*count))
	return -1;

	return 0;
	}

	static void ppc_ptrace_init_breakpoint(struct ppc_hw_breakpoint *info,
	int type, void *addr, int len)
	{
	info->version = 1;
	info->trigger_type = type;
	info->condition_mode = PPC_BREAKPOINT_CONDITION_NONE;
	info->addr = (u64)addr;
	info->addr2 = (u64)addr + len;
	info->condition_value = 0;
	if (!len)
	info->addr_mode = PPC_BREAKPOINT_MODE_EXACT;
	else
	info->addr_mode = PPC_BREAKPOINT_MODE_RANGE_INCLUSIVE;
	}

	/*
	* Checks if we can place at least 2 watchpoints on the child process
	*/
	static int check_watchpoints(pid_t pid)
	{
	struct ppc_debug_info dbginfo;

	FAIL_IF_MSG(ppc_ptrace_gethwdbginfo(pid, &dbginfo), "PPC_PTRACE_GETHWDBGINFO failed");
	SKIP_IF_MSG(dbginfo.num_data_bps <= 1, "Not enough data watchpoints (need at least 2)");

	return 0;
	}

	/*
	* Wrapper around a plain fork() call that sets up the child for
	* ptrace-ing. Both the parent and child return from this, though
	* the child is stopped until ptrace_cont(pid) is run by the parent.
	*/
	static int ptrace_fork_child(pid_t *pid)
	{
	int status;

	*pid = fork();

	if (*pid < 0)
	FAIL_IF_MSG(1, "Failed to fork child");

	if (!*pid) {
	FAIL_IF_EXIT_MSG(ptrace_traceme(), "PTRACE_TRACEME failed");
	FAIL_IF_EXIT_MSG(raise(SIGSTOP), "Child failed to raise SIGSTOP");
	} else {
	/* Synchronise on child SIGSTOP */
	FAIL_IF_MSG(waitpid(*pid, &status, 0) == -1, "Failed to wait for child");
	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
	}

	return 0;
	}

	/*
	* Tests the interaction between ptrace and perf watching the same data.
	*
	* We expect ptrace to take 'priority', as it is has before-execute
	* semantics.
	*
	* The perf counter should not be incremented yet because perf has after-execute
	* semantics. E.g., if ptrace changes the child PC, we don't even execute the
	* instruction at all.
	*
	* When the child is stopped for ptrace, we test both continue and single step.
	* Both should increment the perf counter. We also test changing the PC somewhere
	* different and stepping, which should not increment the perf counter.
	*/
	int same_watch_addr_test(void)
	{
	struct ppc_hw_breakpoint bp_info; /* ptrace breakpoint info */
	int bp_id; /* Breakpoint handle of ptrace watchpoint */
	int perf_fd; /* File descriptor of perf performance counter */
	u64 perf_count; /* Most recently fetched perf performance counter value */
	pid_t pid; /* PID of child process */
	void pc; / Most recently fetched child PC value */
	int status; /* Stop status of child after waitpid */
	unsigned long value; /* Dummy value to be read/written to by child */
	int err;

	err = ptrace_fork_child(&pid);
	if (err)
	return err;

	if (!pid) {
	same_watch_addr_child(&value);
	exit(1);
	}

	err = check_watchpoints(pid);
	if (err)
	return err;

	/* Place a perf watchpoint counter on value */
	perf_fd = perf_watchpoint_open(pid, &value, sizeof(value));
	FAIL_IF_MSG(perf_fd < 0, "Failed to open perf performance counter");

	/* Place a ptrace watchpoint on value */
	ppc_ptrace_init_breakpoint(&bp_info, PPC_BREAKPOINT_TRIGGER_READ, &value, sizeof(value));
	bp_id = ppc_ptrace_sethwdbg(pid, &bp_info);
	FAIL_IF_MSG(bp_id < 0, "Failed to set ptrace watchpoint");

	/* Let the child run. It should stop on the ptrace watchpoint */
	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
	FAIL_IF_MSG(pc != same_watch_addr_load, "Child did not stop on load instruction");

	/*
	* We stopped before executing the load, so perf should not have
	* recorded any events yet
	*/
	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
	FAIL_IF_MSG(perf_count != 0, "perf recorded unexpected event");

	/* Single stepping over the load should increment the perf counter */
	FAIL_IF_MSG(ptrace_singlestep(pid, 0), "Failed to single step child");

	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
	FAIL_IF_MSG(pc != same_watch_addr_load + 4, "Failed to single step load instruction");
	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
	FAIL_IF_MSG(perf_count != 1, "perf counter did not increment");

	/*
	* Set up a ptrace watchpoint on the value again and trigger it.
	* The perf counter should not have incremented because we do not
	* execute the load yet.
	*/
	FAIL_IF_MSG(ppc_ptrace_delhwdbg(pid, bp_id), "Failed to remove old ptrace watchpoint");
	bp_id = ppc_ptrace_sethwdbg(pid, &bp_info);
	FAIL_IF_MSG(bp_id < 0, "Failed to set ptrace watchpoint");
	FAIL_IF_MSG(ptrace_setreg_pc(pid, same_watch_addr_load), "Failed to set child PC");
	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
	FAIL_IF_MSG(pc != same_watch_addr_load, "Child did not stop on load trap");
	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
	FAIL_IF_MSG(perf_count != 1, "perf counter should not have changed");

	/* Continuing over the load should increment the perf counter */
	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
	FAIL_IF_MSG(pc != same_watch_addr_trap, "Child did not stop on end trap");
	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
	FAIL_IF_MSG(perf_count != 2, "perf counter did not increment");

	/*
	* If we set the child PC back to the load instruction, then continue,
	* we should reach the end trap (because ptrace is one-shot) and have
	* another perf event.
	*/
	FAIL_IF_MSG(ptrace_setreg_pc(pid, same_watch_addr_load), "Failed to set child PC");
	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
	FAIL_IF_MSG(pc != same_watch_addr_trap, "Child did not stop on end trap");
	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
	FAIL_IF_MSG(perf_count != 3, "perf counter did not increment");

	/*
	* If we set the child PC back to the load instruction, set a ptrace
	* watchpoint on the load, then continue, we should immediately get
	* the ptrace trap without incrementing the perf counter
	*/
	FAIL_IF_MSG(ppc_ptrace_delhwdbg(pid, bp_id), "Failed to remove old ptrace watchpoint");
	bp_id = ppc_ptrace_sethwdbg(pid, &bp_info);
	FAIL_IF_MSG(bp_id < 0, "Failed to set ptrace watchpoint");
	FAIL_IF_MSG(ptrace_setreg_pc(pid, same_watch_addr_load), "Failed to set child PC");
	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
	FAIL_IF_MSG(pc != same_watch_addr_load, "Child did not stop on load instruction");
	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
	FAIL_IF_MSG(perf_count != 3, "perf counter should not have changed");

	/*
	* If we change the PC while stopped on the load instruction, we should
	* not increment the perf counter (because ptrace is before-execute,
	* perf is after-execute).
	*/
	FAIL_IF_MSG(ptrace_setreg_pc(pid, same_watch_addr_load + 4), "Failed to set child PC");
	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
	FAIL_IF_MSG(pc != same_watch_addr_trap, "Child did not stop on end trap");
	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
	FAIL_IF_MSG(perf_count != 3, "perf counter should not have changed");

	/* Clean up child */
	FAIL_IF_MSG(kill(pid, SIGKILL) != 0, "Failed to kill child");

	return 0;
	}

	/*
	* Tests the interaction between ptrace and perf when:
	* 1. perf watches a value
	* 2. ptrace watches a different value
	* 3. The perf value is read, then the ptrace value is read immediately after
	*
	* A breakpoint implementation may accidentally misattribute/skip one of
	* the ptrace or perf handlers, as interrupt based work is done after perf
	* and before ptrace.
	*
	* We expect the perf counter to increment before the ptrace watchpoint
	* triggers.
	*/
	int perf_then_ptrace_test(void)
	{
	struct ppc_hw_breakpoint bp_info; /* ptrace breakpoint info */
	int bp_id; /* Breakpoint handle of ptrace watchpoint */
	int perf_fd; /* File descriptor of perf performance counter */
	u64 perf_count; /* Most recently fetched perf performance counter value */
	pid_t pid; /* PID of child process */
	void pc; / Most recently fetched child PC value */
	int status; /* Stop status of child after waitpid */
	unsigned long perf_value; /* Dummy value to be watched by perf */
	unsigned long ptrace_value; /* Dummy value to be watched by ptrace */
	int err;

	err = ptrace_fork_child(&pid);
	if (err)
	return err;

	/*
	* If we are the child, run a subroutine that reads the perf value,
	* then reads the ptrace value with consecutive load instructions
	*/
	if (!pid) {
	perf_then_ptrace_child(&perf_value, &ptrace_value);
	exit(0);
	}

	err = check_watchpoints(pid);
	if (err)
	return err;

	/* Place a perf watchpoint counter */
	perf_fd = perf_watchpoint_open(pid, &perf_value, sizeof(perf_value));
	FAIL_IF_MSG(perf_fd < 0, "Failed to open perf performance counter");

	/* Place a ptrace watchpoint */
	ppc_ptrace_init_breakpoint(&bp_info, PPC_BREAKPOINT_TRIGGER_READ,
	&ptrace_value, sizeof(ptrace_value));
	bp_id = ppc_ptrace_sethwdbg(pid, &bp_info);
	FAIL_IF_MSG(bp_id < 0, "Failed to set ptrace watchpoint");

	/* Let the child run. It should stop on the ptrace watchpoint */
	FAIL_IF_MSG(ptrace_cont(pid, 0), "Failed to continue child");

	FAIL_IF_MSG(waitpid(pid, &status, 0) == -1, "Failed to wait for child");
	FAIL_IF_MSG(!WIFSTOPPED(status), "Child is not stopped");
	FAIL_IF_MSG(ptrace_getreg_pc(pid, &pc), "Failed to get child PC");
	FAIL_IF_MSG(pc != perf_then_ptrace_load2, "Child did not stop on ptrace load");

	/* perf should have recorded the first load */
	FAIL_IF_MSG(perf_read_counter(perf_fd, &perf_count), "Failed to read perf counter");
	FAIL_IF_MSG(perf_count != 1, "perf counter did not increment");

	/* Clean up child */
	FAIL_IF_MSG(kill(pid, SIGKILL) != 0, "Failed to kill child");

	return 0;
	}

	int main(int argc, char *argv[])
	{
	int err = 0;

	err \|= test_harness(same_watch_addr_test, "same_watch_addr");
	err \|= test_harness(perf_then_ptrace_test, "perf_then_ptrace");

	return err;
	}