Commit c65c64cc authored by Ravi Bangoria's avatar Ravi Bangoria Committed by Michael Ellerman
Browse files

powerpc/selftests/perf-hwbreak: Add testcases for 2nd DAWR 



Extend perf-hwbreak.c selftest to test multiple DAWRs. Also add
testcase for testing 512 byte boundary removal.

Sample o/p:
  # ./perf-hwbreak
  ...
  TESTED: Process specific, Two events, diff addr
  TESTED: Process specific, Two events, same addr
  TESTED: Process specific, Two events, diff addr, one is RO, other is WO
  TESTED: Process specific, Two events, same addr, one is RO, other is WO
  TESTED: Systemwide, Two events, diff addr
  TESTED: Systemwide, Two events, same addr
  TESTED: Systemwide, Two events, diff addr, one is RO, other is WO
  TESTED: Systemwide, Two events, same addr, one is RO, other is WO
  TESTED: Process specific, 512 bytes, unaligned
  success: perf_hwbreak

Signed-off-by: default avatarRavi Bangoria <ravi.bangoria@linux.ibm.com>
Signed-off-by: default avatarMichael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/20210412112218.128183-4-ravi.bangoria@linux.ibm.com
parent c9cb0afb

tools/testing/selftests/powerpc/ptrace/perf-hwbreak.c

+551 −1
Original line number Diff line number Diff line
@@ -21,8 +21,13 @@ 
#include <assert.h>

#include <stdio.h>

#include <stdlib.h>

#include <signal.h>

#include <string.h>

#include <sys/ioctl.h>

#include <sys/wait.h>

#include <sys/ptrace.h>

#include <sys/sysinfo.h>

#include <asm/ptrace.h>

#include <elf.h>

#include <pthread.h>

#include <sys/syscall.h>
@@ -38,6 +43,12 @@ 


#define DAWR_LENGTH_MAX ((0x3f + 1) * 8)



int nprocs;



static volatile int a = 10;

static volatile int b = 10;

static volatile char c[512 + 8] __attribute__((aligned(512)));



static void perf_event_attr_set(struct perf_event_attr *attr,

				__u32 type, __u64 addr, __u64 len,

				bool exclude_user)
@@ -72,6 +83,76 @@ static int perf_process_event_open(__u32 type, __u64 addr, __u64 len) 
	return syscall(__NR_perf_event_open, &attr, getpid(), -1, -1, 0);

}



static int perf_cpu_event_open(long cpu, __u32 type, __u64 addr, __u64 len)

{

	struct perf_event_attr attr;



	perf_event_attr_set(&attr, type, addr, len, 0);

	return syscall(__NR_perf_event_open, &attr, -1, cpu, -1, 0);

}



static void close_fds(int *fd, int n)

{

	int i;



	for (i = 0; i < n; i++)

		close(fd[i]);

}



static unsigned long read_fds(int *fd, int n)

{

	int i;

	unsigned long c = 0;

	unsigned long count = 0;

	size_t res;



	for (i = 0; i < n; i++) {

		res = read(fd[i], &c, sizeof(c));

		assert(res == sizeof(unsigned long long));

		count += c;

	}

	return count;

}



static void reset_fds(int *fd, int n)

{

	int i;



	for (i = 0; i < n; i++)

		ioctl(fd[i], PERF_EVENT_IOC_RESET);

}



static void enable_fds(int *fd, int n)

{

	int i;



	for (i = 0; i < n; i++)

		ioctl(fd[i], PERF_EVENT_IOC_ENABLE);

}



static void disable_fds(int *fd, int n)

{

	int i;



	for (i = 0; i < n; i++)

		ioctl(fd[i], PERF_EVENT_IOC_DISABLE);

}



static int perf_systemwide_event_open(int *fd, __u32 type, __u64 addr, __u64 len)

{

	int i = 0;



	/* Assume online processors are 0 to nprocs for simplisity */

	for (i = 0; i < nprocs; i++) {

		fd[i] = perf_cpu_event_open(i, type, addr, len);

		if (fd[i] < 0) {

			close_fds(fd, i);

			return fd[i];

		}

	}

	return 0;

}



static inline bool breakpoint_test(int len)

{

	int fd;
@@ -266,11 +347,467 @@ static int runtest_dar_outside(void) 
	return fail;

}



static void multi_dawr_workload(void)

{

	a += 10;

	b += 10;

	c[512 + 1] += 'a';

}



static int test_process_multi_diff_addr(void)

{

	unsigned long long breaks1 = 0, breaks2 = 0;

	int fd1, fd2;

	char *desc = "Process specific, Two events, diff addr";

	size_t res;



	fd1 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));

	if (fd1 < 0) {

		perror("perf_process_event_open");

		exit(EXIT_FAILURE);

	}



	fd2 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&b, (__u64)sizeof(b));

	if (fd2 < 0) {

		close(fd1);

		perror("perf_process_event_open");

		exit(EXIT_FAILURE);

	}



	ioctl(fd1, PERF_EVENT_IOC_RESET);

	ioctl(fd2, PERF_EVENT_IOC_RESET);

	ioctl(fd1, PERF_EVENT_IOC_ENABLE);

	ioctl(fd2, PERF_EVENT_IOC_ENABLE);

	multi_dawr_workload();

	ioctl(fd1, PERF_EVENT_IOC_DISABLE);

	ioctl(fd2, PERF_EVENT_IOC_DISABLE);



	res = read(fd1, &breaks1, sizeof(breaks1));

	assert(res == sizeof(unsigned long long));

	res = read(fd2, &breaks2, sizeof(breaks2));

	assert(res == sizeof(unsigned long long));



	close(fd1);

	close(fd2);



	if (breaks1 != 2 || breaks2 != 2) {

		printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2);

		return 1;

	}



	printf("TESTED: %s\n", desc);

	return 0;

}



static int test_process_multi_same_addr(void)

{

	unsigned long long breaks1 = 0, breaks2 = 0;

	int fd1, fd2;

	char *desc = "Process specific, Two events, same addr";

	size_t res;



	fd1 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));

	if (fd1 < 0) {

		perror("perf_process_event_open");

		exit(EXIT_FAILURE);

	}



	fd2 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));

	if (fd2 < 0) {

		close(fd1);

		perror("perf_process_event_open");

		exit(EXIT_FAILURE);

	}



	ioctl(fd1, PERF_EVENT_IOC_RESET);

	ioctl(fd2, PERF_EVENT_IOC_RESET);

	ioctl(fd1, PERF_EVENT_IOC_ENABLE);

	ioctl(fd2, PERF_EVENT_IOC_ENABLE);

	multi_dawr_workload();

	ioctl(fd1, PERF_EVENT_IOC_DISABLE);

	ioctl(fd2, PERF_EVENT_IOC_DISABLE);



	res = read(fd1, &breaks1, sizeof(breaks1));

	assert(res == sizeof(unsigned long long));

	res = read(fd2, &breaks2, sizeof(breaks2));

	assert(res == sizeof(unsigned long long));



	close(fd1);

	close(fd2);



	if (breaks1 != 2 || breaks2 != 2) {

		printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2);

		return 1;

	}



	printf("TESTED: %s\n", desc);

	return 0;

}



static int test_process_multi_diff_addr_ro_wo(void)

{

	unsigned long long breaks1 = 0, breaks2 = 0;

	int fd1, fd2;

	char *desc = "Process specific, Two events, diff addr, one is RO, other is WO";

	size_t res;



	fd1 = perf_process_event_open(HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a));

	if (fd1 < 0) {

		perror("perf_process_event_open");

		exit(EXIT_FAILURE);

	}



	fd2 = perf_process_event_open(HW_BREAKPOINT_R, (__u64)&b, (__u64)sizeof(b));

	if (fd2 < 0) {

		close(fd1);

		perror("perf_process_event_open");

		exit(EXIT_FAILURE);

	}



	ioctl(fd1, PERF_EVENT_IOC_RESET);

	ioctl(fd2, PERF_EVENT_IOC_RESET);

	ioctl(fd1, PERF_EVENT_IOC_ENABLE);

	ioctl(fd2, PERF_EVENT_IOC_ENABLE);

	multi_dawr_workload();

	ioctl(fd1, PERF_EVENT_IOC_DISABLE);

	ioctl(fd2, PERF_EVENT_IOC_DISABLE);



	res = read(fd1, &breaks1, sizeof(breaks1));

	assert(res == sizeof(unsigned long long));

	res = read(fd2, &breaks2, sizeof(breaks2));

	assert(res == sizeof(unsigned long long));



	close(fd1);

	close(fd2);



	if (breaks1 != 1 || breaks2 != 1) {

		printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2);

		return 1;

	}



	printf("TESTED: %s\n", desc);

	return 0;

}



static int test_process_multi_same_addr_ro_wo(void)

{

	unsigned long long breaks1 = 0, breaks2 = 0;

	int fd1, fd2;

	char *desc = "Process specific, Two events, same addr, one is RO, other is WO";

	size_t res;



	fd1 = perf_process_event_open(HW_BREAKPOINT_R, (__u64)&a, (__u64)sizeof(a));

	if (fd1 < 0) {

		perror("perf_process_event_open");

		exit(EXIT_FAILURE);

	}



	fd2 = perf_process_event_open(HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a));

	if (fd2 < 0) {

		close(fd1);

		perror("perf_process_event_open");

		exit(EXIT_FAILURE);

	}



	ioctl(fd1, PERF_EVENT_IOC_RESET);

	ioctl(fd2, PERF_EVENT_IOC_RESET);

	ioctl(fd1, PERF_EVENT_IOC_ENABLE);

	ioctl(fd2, PERF_EVENT_IOC_ENABLE);

	multi_dawr_workload();

	ioctl(fd1, PERF_EVENT_IOC_DISABLE);

	ioctl(fd2, PERF_EVENT_IOC_DISABLE);



	res = read(fd1, &breaks1, sizeof(breaks1));

	assert(res == sizeof(unsigned long long));

	res = read(fd2, &breaks2, sizeof(breaks2));

	assert(res == sizeof(unsigned long long));



	close(fd1);

	close(fd2);



	if (breaks1 != 1 || breaks2 != 1) {

		printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2);

		return 1;

	}



	printf("TESTED: %s\n", desc);

	return 0;

}



static int test_syswide_multi_diff_addr(void)

{

	unsigned long long breaks1 = 0, breaks2 = 0;

	int *fd1 = malloc(nprocs * sizeof(int));

	int *fd2 = malloc(nprocs * sizeof(int));

	char *desc = "Systemwide, Two events, diff addr";

	int ret;



	ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));

	if (ret) {

		perror("perf_systemwide_event_open");

		exit(EXIT_FAILURE);

	}



	ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_RW, (__u64)&b, (__u64)sizeof(b));

	if (ret) {

		close_fds(fd1, nprocs);

		perror("perf_systemwide_event_open");

		exit(EXIT_FAILURE);

	}



	reset_fds(fd1, nprocs);

	reset_fds(fd2, nprocs);

	enable_fds(fd1, nprocs);

	enable_fds(fd2, nprocs);

	multi_dawr_workload();

	disable_fds(fd1, nprocs);

	disable_fds(fd2, nprocs);



	breaks1 = read_fds(fd1, nprocs);

	breaks2 = read_fds(fd2, nprocs);



	close_fds(fd1, nprocs);

	close_fds(fd2, nprocs);



	free(fd1);

	free(fd2);



	if (breaks1 != 2 || breaks2 != 2) {

		printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2);

		return 1;

	}



	printf("TESTED: %s\n", desc);

	return 0;

}



static int test_syswide_multi_same_addr(void)

{

	unsigned long long breaks1 = 0, breaks2 = 0;

	int *fd1 = malloc(nprocs * sizeof(int));

	int *fd2 = malloc(nprocs * sizeof(int));

	char *desc = "Systemwide, Two events, same addr";

	int ret;



	ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));

	if (ret) {

		perror("perf_systemwide_event_open");

		exit(EXIT_FAILURE);

	}



	ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));

	if (ret) {

		close_fds(fd1, nprocs);

		perror("perf_systemwide_event_open");

		exit(EXIT_FAILURE);

	}



	reset_fds(fd1, nprocs);

	reset_fds(fd2, nprocs);

	enable_fds(fd1, nprocs);

	enable_fds(fd2, nprocs);

	multi_dawr_workload();

	disable_fds(fd1, nprocs);

	disable_fds(fd2, nprocs);



	breaks1 = read_fds(fd1, nprocs);

	breaks2 = read_fds(fd2, nprocs);



	close_fds(fd1, nprocs);

	close_fds(fd2, nprocs);



	free(fd1);

	free(fd2);



	if (breaks1 != 2 || breaks2 != 2) {

		printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2);

		return 1;

	}



	printf("TESTED: %s\n", desc);

	return 0;

}



static int test_syswide_multi_diff_addr_ro_wo(void)

{

	unsigned long long breaks1 = 0, breaks2 = 0;

	int *fd1 = malloc(nprocs * sizeof(int));

	int *fd2 = malloc(nprocs * sizeof(int));

	char *desc = "Systemwide, Two events, diff addr, one is RO, other is WO";

	int ret;



	ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a));

	if (ret) {

		perror("perf_systemwide_event_open");

		exit(EXIT_FAILURE);

	}



	ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_R, (__u64)&b, (__u64)sizeof(b));

	if (ret) {

		close_fds(fd1, nprocs);

		perror("perf_systemwide_event_open");

		exit(EXIT_FAILURE);

	}



	reset_fds(fd1, nprocs);

	reset_fds(fd2, nprocs);

	enable_fds(fd1, nprocs);

	enable_fds(fd2, nprocs);

	multi_dawr_workload();

	disable_fds(fd1, nprocs);

	disable_fds(fd2, nprocs);



	breaks1 = read_fds(fd1, nprocs);

	breaks2 = read_fds(fd2, nprocs);



	close_fds(fd1, nprocs);

	close_fds(fd2, nprocs);



	free(fd1);

	free(fd2);



	if (breaks1 != 1 || breaks2 != 1) {

		printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2);

		return 1;

	}



	printf("TESTED: %s\n", desc);

	return 0;

}



static int test_syswide_multi_same_addr_ro_wo(void)

{

	unsigned long long breaks1 = 0, breaks2 = 0;

	int *fd1 = malloc(nprocs * sizeof(int));

	int *fd2 = malloc(nprocs * sizeof(int));

	char *desc = "Systemwide, Two events, same addr, one is RO, other is WO";

	int ret;



	ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a));

	if (ret) {

		perror("perf_systemwide_event_open");

		exit(EXIT_FAILURE);

	}



	ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_R, (__u64)&a, (__u64)sizeof(a));

	if (ret) {

		close_fds(fd1, nprocs);

		perror("perf_systemwide_event_open");

		exit(EXIT_FAILURE);

	}



	reset_fds(fd1, nprocs);

	reset_fds(fd2, nprocs);

	enable_fds(fd1, nprocs);

	enable_fds(fd2, nprocs);

	multi_dawr_workload();

	disable_fds(fd1, nprocs);

	disable_fds(fd2, nprocs);



	breaks1 = read_fds(fd1, nprocs);

	breaks2 = read_fds(fd2, nprocs);



	close_fds(fd1, nprocs);

	close_fds(fd2, nprocs);



	free(fd1);

	free(fd2);



	if (breaks1 != 1 || breaks2 != 1) {

		printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2);

		return 1;

	}



	printf("TESTED: %s\n", desc);

	return 0;

}



static int runtest_multi_dawr(void)

{

	int ret = 0;



	ret |= test_process_multi_diff_addr();

	ret |= test_process_multi_same_addr();

	ret |= test_process_multi_diff_addr_ro_wo();

	ret |= test_process_multi_same_addr_ro_wo();

	ret |= test_syswide_multi_diff_addr();

	ret |= test_syswide_multi_same_addr();

	ret |= test_syswide_multi_diff_addr_ro_wo();

	ret |= test_syswide_multi_same_addr_ro_wo();



	return ret;

}



static int runtest_unaligned_512bytes(void)

{

	unsigned long long breaks = 0;

	int fd;

	char *desc = "Process specific, 512 bytes, unaligned";

	__u64 addr = (__u64)&c + 8;

	size_t res;



	fd = perf_process_event_open(HW_BREAKPOINT_RW, addr, 512);

	if (fd < 0) {

		perror("perf_process_event_open");

		exit(EXIT_FAILURE);

	}



	ioctl(fd, PERF_EVENT_IOC_RESET);

	ioctl(fd, PERF_EVENT_IOC_ENABLE);

	multi_dawr_workload();

	ioctl(fd, PERF_EVENT_IOC_DISABLE);



	res = read(fd, &breaks, sizeof(breaks));

	assert(res == sizeof(unsigned long long));



	close(fd);



	if (breaks != 2) {

		printf("FAILED: %s: %lld != 2\n", desc, breaks);

		return 1;

	}



	printf("TESTED: %s\n", desc);

	return 0;

}



/* There is no perf api to find number of available watchpoints. Use ptrace. */

static int get_nr_wps(bool *arch_31)

{

	struct ppc_debug_info dbginfo;

	int child_pid;



	child_pid = fork();

	if (!child_pid) {

		int ret = ptrace(PTRACE_TRACEME, 0, NULL, 0);

		if (ret) {

			perror("PTRACE_TRACEME failed\n");

			exit(EXIT_FAILURE);

		}

		kill(getpid(), SIGUSR1);



		sleep(1);

		exit(EXIT_SUCCESS);

	}



	wait(NULL);

	if (ptrace(PPC_PTRACE_GETHWDBGINFO, child_pid, NULL, &dbginfo)) {

		perror("Can't get breakpoint info");

		exit(EXIT_FAILURE);

	}



	*arch_31 = !!(dbginfo.features & PPC_DEBUG_FEATURE_DATA_BP_ARCH_31);

	return dbginfo.num_data_bps;

}



static int runtest(void)

{

	int rwflag;

	int exclude_user;

	int ret;

	bool dawr = dawr_supported();

	bool arch_31 = false;

	int nr_wps = get_nr_wps(&arch_31);



	/*

	 * perf defines rwflag as two bits read and write and at least
@@ -283,7 +820,7 @@ static int runtest(void) 
				return ret;



			/* if we have the dawr, we can do an array test */

			if (!dawr_supported())

			if (!dawr)

				continue;

			ret = runtestsingle(rwflag, exclude_user, 1);

			if (ret)
@@ -292,6 +829,19 @@ static int runtest(void) 
	}



	ret = runtest_dar_outside();

	if (ret)

		return ret;



	if (dawr && nr_wps > 1) {

		nprocs = get_nprocs();

		ret = runtest_multi_dawr();

		if (ret)

			return ret;

	}



	if (dawr && arch_31)

		ret = runtest_unaligned_512bytes();



	return ret;

}