[mirror_ubuntu-bionic-kernel.git] / tools / perf / tests / bp_signal.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Inspired by breakpoint overflow test done by
 * Vince Weaver <vincent.weaver@maine.edu> for perf_event_tests
 * (git://github.com/deater/perf_event_tests)
 */

/*
 * Powerpc needs __SANE_USERSPACE_TYPES__ before <linux/types.h> to select
 * 'int-ll64.h' and avoid compile warnings when printing __u64 with %llu.
 */
#define __SANE_USERSPACE_TYPES__

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>
#include <time.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/mman.h>
#include <linux/compiler.h>
#include <linux/hw_breakpoint.h>

#include "tests.h"
#include "debug.h"
#include "perf.h"
#include "cloexec.h"

static int fd1;
static int fd2;
static int fd3;
static int overflows;
static int overflows_2;

volatile long the_var;


/*
 * Use ASM to ensure watchpoint and breakpoint can be triggered
 * at one instruction.
 */
#if defined (__x86_64__)
extern void __test_function(volatile long *ptr);
asm (
	".globl __test_function\n"
	"__test_function:\n"
	"incq (%rdi)\n"
	"ret\n");
#elif defined (__aarch64__)
extern void __test_function(volatile long *ptr);
asm (
	".globl __test_function\n"
	"__test_function:\n"
	"str x30, [x0]\n"
	"ret\n");

#else
static void __test_function(volatile long *ptr)
{
	*ptr = 0x1234;
}
#endif

static noinline int test_function(void)
{
	__test_function(&the_var);
	the_var++;
	return time(NULL);
}

static void sig_handler_2(int signum __maybe_unused,
			  siginfo_t *oh __maybe_unused,
			  void *uc __maybe_unused)
{
	overflows_2++;
	if (overflows_2 > 10) {
		ioctl(fd1, PERF_EVENT_IOC_DISABLE, 0);
		ioctl(fd2, PERF_EVENT_IOC_DISABLE, 0);
		ioctl(fd3, PERF_EVENT_IOC_DISABLE, 0);
	}
}

static void sig_handler(int signum __maybe_unused,
			siginfo_t *oh __maybe_unused,
			void *uc __maybe_unused)
{
	overflows++;

	if (overflows > 10) {
		/*
		 * This should be executed only once during
		 * this test, if we are here for the 10th
		 * time, consider this the recursive issue.
		 *
		 * We can get out of here by disable events,
		 * so no new SIGIO is delivered.
		 */
		ioctl(fd1, PERF_EVENT_IOC_DISABLE, 0);
		ioctl(fd2, PERF_EVENT_IOC_DISABLE, 0);
		ioctl(fd3, PERF_EVENT_IOC_DISABLE, 0);
	}
}

static int __event(bool is_x, void *addr, int sig)
{
	struct perf_event_attr pe;
	int fd;

	memset(&pe, 0, sizeof(struct perf_event_attr));
	pe.type = PERF_TYPE_BREAKPOINT;
	pe.size = sizeof(struct perf_event_attr);

	pe.config = 0;
	pe.bp_type = is_x ? HW_BREAKPOINT_X : HW_BREAKPOINT_W;
	pe.bp_addr = (unsigned long) addr;
	pe.bp_len = sizeof(long);

	pe.sample_period = 1;
	pe.sample_type = PERF_SAMPLE_IP;
	pe.wakeup_events = 1;

	pe.disabled = 1;
	pe.exclude_kernel = 1;
	pe.exclude_hv = 1;

	fd = sys_perf_event_open(&pe, 0, -1, -1,
				 perf_event_open_cloexec_flag());
	if (fd < 0) {
		pr_debug("failed opening event %llx\n", pe.config);
		return TEST_FAIL;
	}

	fcntl(fd, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC);
	fcntl(fd, F_SETSIG, sig);
	fcntl(fd, F_SETOWN, getpid());

	ioctl(fd, PERF_EVENT_IOC_RESET, 0);

	return fd;
}

static int bp_event(void *addr, int sig)
{
	return __event(true, addr, sig);
}

static int wp_event(void *addr, int sig)
{
	return __event(false, addr, sig);
}

static long long bp_count(int fd)
{
	long long count;
	int ret;

	ret = read(fd, &count, sizeof(long long));
	if (ret != sizeof(long long)) {
		pr_debug("failed to read: %d\n", ret);
		return TEST_FAIL;
	}

	return count;
}

int test__bp_signal(struct test *test __maybe_unused, int subtest __maybe_unused)
{
	struct sigaction sa;
	long long count1, count2, count3;

	/* setup SIGIO signal handler */
	memset(&sa, 0, sizeof(struct sigaction));
	sa.sa_sigaction = (void *) sig_handler;
	sa.sa_flags = SA_SIGINFO;

	if (sigaction(SIGIO, &sa, NULL) < 0) {
		pr_debug("failed setting up signal handler\n");
		return TEST_FAIL;
	}

	sa.sa_sigaction = (void *) sig_handler_2;
	if (sigaction(SIGUSR1, &sa, NULL) < 0) {
		pr_debug("failed setting up signal handler 2\n");
		return TEST_FAIL;
	}

	/*
	 * We create following events:
	 *
	 * fd1 - breakpoint event on __test_function with SIGIO
	 *       signal configured. We should get signal
	 *       notification each time the breakpoint is hit
	 *
	 * fd2 - breakpoint event on sig_handler with SIGUSR1
	 *       configured. We should get SIGUSR1 each time when
	 *       breakpoint is hit
	 *
	 * fd3 - watchpoint event on __test_function with SIGIO
	 *       configured.
	 *
	 * Following processing should happen:
	 *   Exec:               Action:                       Result:
	 *   incq (%rdi)       - fd1 event breakpoint hit   -> count1 == 1
	 *                     - SIGIO is delivered
	 *   sig_handler       - fd2 event breakpoint hit   -> count2 == 1
	 *                     - SIGUSR1 is delivered
	 *   sig_handler_2                                  -> overflows_2 == 1  (nested signal)
	 *   sys_rt_sigreturn  - return from sig_handler_2
	 *   overflows++                                    -> overflows = 1
	 *   sys_rt_sigreturn  - return from sig_handler
	 *   incq (%rdi)       - fd3 event watchpoint hit   -> count3 == 1       (wp and bp in one insn)
	 *                     - SIGIO is delivered
	 *   sig_handler       - fd2 event breakpoint hit   -> count2 == 2
	 *                     - SIGUSR1 is delivered
	 *   sig_handler_2                                  -> overflows_2 == 2  (nested signal)
	 *   sys_rt_sigreturn  - return from sig_handler_2
	 *   overflows++                                    -> overflows = 2
	 *   sys_rt_sigreturn  - return from sig_handler
	 *   the_var++         - fd3 event watchpoint hit   -> count3 == 2       (standalone watchpoint)
	 *                     - SIGIO is delivered
	 *   sig_handler       - fd2 event breakpoint hit   -> count2 == 3
	 *                     - SIGUSR1 is delivered
	 *   sig_handler_2                                  -> overflows_2 == 3  (nested signal)
	 *   sys_rt_sigreturn  - return from sig_handler_2
	 *   overflows++                                    -> overflows == 3
	 *   sys_rt_sigreturn  - return from sig_handler
	 *
	 * The test case check following error conditions:
	 * - we get stuck in signal handler because of debug
	 *   exception being triggered receursively due to
	 *   the wrong RF EFLAG management
	 *
	 * - we never trigger the sig_handler breakpoint due
	 *   to the rong RF EFLAG management
	 *
	 */

	fd1 = bp_event(__test_function, SIGIO);
	fd2 = bp_event(sig_handler, SIGUSR1);
	fd3 = wp_event((void *)&the_var, SIGIO);

	ioctl(fd1, PERF_EVENT_IOC_ENABLE, 0);
	ioctl(fd2, PERF_EVENT_IOC_ENABLE, 0);
	ioctl(fd3, PERF_EVENT_IOC_ENABLE, 0);

	/*
	 * Kick off the test by trigering 'fd1'
	 * breakpoint.
	 */
	test_function();

	ioctl(fd1, PERF_EVENT_IOC_DISABLE, 0);
	ioctl(fd2, PERF_EVENT_IOC_DISABLE, 0);
	ioctl(fd3, PERF_EVENT_IOC_DISABLE, 0);

	count1 = bp_count(fd1);
	count2 = bp_count(fd2);
	count3 = bp_count(fd3);

	close(fd1);
	close(fd2);
	close(fd3);

	pr_debug("count1 %lld, count2 %lld, count3 %lld, overflow %d, overflows_2 %d\n",
		 count1, count2, count3, overflows, overflows_2);

	if (count1 != 1) {
		if (count1 == 11)
			pr_debug("failed: RF EFLAG recursion issue detected\n");
		else
			pr_debug("failed: wrong count for bp1%lld\n", count1);
	}

	if (overflows != 3)
		pr_debug("failed: wrong overflow hit\n");

	if (overflows_2 != 3)
		pr_debug("failed: wrong overflow_2 hit\n");

	if (count2 != 3)
		pr_debug("failed: wrong count for bp2\n");

	if (count3 != 2)
		pr_debug("failed: wrong count for bp3\n");

	return count1 == 1 && overflows == 3 && count2 == 3 && overflows_2 == 3 && count3 == 2 ?
		TEST_OK : TEST_FAIL;
}

bool test__bp_signal_is_supported(void)
{
/*
 * The powerpc so far does not have support to even create
 * instruction breakpoint using the perf event interface.
 * Once it's there we can release this.
 */
#ifdef __powerpc__
	return false;
#else
	return true;
#endif
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
5a6bef47 JO	2	/*
	3	* Inspired by breakpoint overflow test done by
	4	* Vince Weaver <vincent.weaver@maine.edu> for perf_event_tests
	5	* (git://github.com/deater/perf_event_tests)
	6	*/
	7
b3539d21 SB	8	/*
	9	* Powerpc needs __SANE_USERSPACE_TYPES__ before <linux/types.h> to select
	10	* 'int-ll64.h' and avoid compile warnings when printing __u64 with %llu.
	11	*/
	12	#define __SANE_USERSPACE_TYPES__
	13
5a6bef47 JO	14	#include <stdlib.h>
	15	#include <stdio.h>
	16	#include <unistd.h>
	17	#include <string.h>
	18	#include <sys/ioctl.h>
	19	#include <time.h>
	20	#include <fcntl.h>
	21	#include <signal.h>
	22	#include <sys/mman.h>
	23	#include <linux/compiler.h>
	24	#include <linux/hw_breakpoint.h>
	25
	26	#include "tests.h"
	27	#include "debug.h"
	28	#include "perf.h"
57480d2c	29	#include "cloexec.h"
5a6bef47 JO	30
	31	static int fd1;
	32	static int fd2;
8fd34e1c	33	static int fd3;
5a6bef47	34	static int overflows;
8fd34e1c WN	35	static int overflows_2;
	36
	37	volatile long the_var;
	38
	39
	40	/*
	41	* Use ASM to ensure watchpoint and breakpoint can be triggered
	42	* at one instruction.
	43	*/
	44	#if defined (__x86_64__)
	45	extern void __test_function(volatile long *ptr);
	46	asm (
	47	".globl __test_function\n"
	48	"__test_function:\n"
	49	"incq (%rdi)\n"
	50	"ret\n");
	51	#elif defined (__aarch64__)
	52	extern void __test_function(volatile long *ptr);
	53	asm (
	54	".globl __test_function\n"
	55	"__test_function:\n"
	56	"str x30, [x0]\n"
	57	"ret\n");
	58
	59	#else
	60	static void __test_function(volatile long *ptr)
	61	{
	62	*ptr = 0x1234;
	63	}
	64	#endif
5a6bef47	65
9dd4ca47	66	static noinline int test_function(void)
5a6bef47	67	{
8fd34e1c WN	68	__test_function(&the_var);
8fd34e1c WN	69	the_var++;
5a6bef47 JO	70	return time(NULL);
	71	}
	72
8fd34e1c WN	73	static void sig_handler_2(int signum __maybe_unused,
	74	siginfo_t *oh __maybe_unused,
	75	void *uc __maybe_unused)
	76	{
	77	overflows_2++;
	78	if (overflows_2 > 10) {
	79	ioctl(fd1, PERF_EVENT_IOC_DISABLE, 0);
	80	ioctl(fd2, PERF_EVENT_IOC_DISABLE, 0);
	81	ioctl(fd3, PERF_EVENT_IOC_DISABLE, 0);
	82	}
	83	}
	84
5a6bef47 JO	85	static void sig_handler(int signum __maybe_unused,
	86	siginfo_t *oh __maybe_unused,
	87	void *uc __maybe_unused)
	88	{
	89	overflows++;
	90
	91	if (overflows > 10) {
	92	/*
	93	* This should be executed only once during
	94	* this test, if we are here for the 10th
	95	* time, consider this the recursive issue.
	96	*
	97	* We can get out of here by disable events,
	98	* so no new SIGIO is delivered.
	99	*/
	100	ioctl(fd1, PERF_EVENT_IOC_DISABLE, 0);
	101	ioctl(fd2, PERF_EVENT_IOC_DISABLE, 0);
8fd34e1c	102	ioctl(fd3, PERF_EVENT_IOC_DISABLE, 0);
5a6bef47 JO	103	}
	104	}
	105
1ad826ba	106	static int __event(bool is_x, void *addr, int sig)
5a6bef47 JO	107	{
	108	struct perf_event_attr pe;
	109	int fd;
	110
	111	memset(&pe, 0, sizeof(struct perf_event_attr));
	112	pe.type = PERF_TYPE_BREAKPOINT;
	113	pe.size = sizeof(struct perf_event_attr);
	114
	115	pe.config = 0;
8fd34e1c WN	116	pe.bp_type = is_x ? HW_BREAKPOINT_X : HW_BREAKPOINT_W;
8fd34e1c WN	117	pe.bp_addr = (unsigned long) addr;
5a6bef47 JO	118	pe.bp_len = sizeof(long);
	119
	120	pe.sample_period = 1;
	121	pe.sample_type = PERF_SAMPLE_IP;
	122	pe.wakeup_events = 1;
	123
	124	pe.disabled = 1;
	125	pe.exclude_kernel = 1;
	126	pe.exclude_hv = 1;
	127
57480d2c YD	128	fd = sys_perf_event_open(&pe, 0, -1, -1,
57480d2c YD	129	perf_event_open_cloexec_flag());
5a6bef47 JO	130	if (fd < 0) {
	131	pr_debug("failed opening event %llx\n", pe.config);
	132	return TEST_FAIL;
	133	}
	134
8fd34e1c	135	fcntl(fd, F_SETFL, O_RDWR\|O_NONBLOCK\|O_ASYNC);
1ad826ba	136	fcntl(fd, F_SETSIG, sig);
8fd34e1c	137	fcntl(fd, F_SETOWN, getpid());
5a6bef47 JO	138
	139	ioctl(fd, PERF_EVENT_IOC_RESET, 0);
	140
	141	return fd;
	142	}
	143
1ad826ba	144	static int bp_event(void *addr, int sig)
8fd34e1c	145	{
1ad826ba	146	return __event(true, addr, sig);
8fd34e1c WN	147	}
8fd34e1c WN	148
1ad826ba	149	static int wp_event(void *addr, int sig)
8fd34e1c	150	{
1ad826ba	151	return __event(false, addr, sig);
8fd34e1c WN	152	}
8fd34e1c WN	153
5a6bef47 JO	154	static long long bp_count(int fd)
	155	{
	156	long long count;
	157	int ret;
	158
	159	ret = read(fd, &count, sizeof(long long));
	160	if (ret != sizeof(long long)) {
	161	pr_debug("failed to read: %d\n", ret);
	162	return TEST_FAIL;
	163	}
	164
	165	return count;
	166	}
	167
81f17c90	168	int test__bp_signal(struct test *test __maybe_unused, int subtest __maybe_unused)
5a6bef47 JO	169	{
5a6bef47 JO	170	struct sigaction sa;
8fd34e1c	171	long long count1, count2, count3;
5a6bef47 JO	172
	173	/* setup SIGIO signal handler */
	174	memset(&sa, 0, sizeof(struct sigaction));
	175	sa.sa_sigaction = (void *) sig_handler;
	176	sa.sa_flags = SA_SIGINFO;
	177
	178	if (sigaction(SIGIO, &sa, NULL) < 0) {
	179	pr_debug("failed setting up signal handler\n");
	180	return TEST_FAIL;
	181	}
	182
8fd34e1c WN	183	sa.sa_sigaction = (void *) sig_handler_2;
	184	if (sigaction(SIGUSR1, &sa, NULL) < 0) {
	185	pr_debug("failed setting up signal handler 2\n");
	186	return TEST_FAIL;
	187	}
	188
5a6bef47 JO	189	/*
	190	* We create following events:
	191	*
8fd34e1c	192	* fd1 - breakpoint event on __test_function with SIGIO
5a6bef47 JO	193	* signal configured. We should get signal
	194	* notification each time the breakpoint is hit
	195	*
8fd34e1c WN	196	* fd2 - breakpoint event on sig_handler with SIGUSR1
	197	* configured. We should get SIGUSR1 each time when
	198	* breakpoint is hit
	199	*
	200	* fd3 - watchpoint event on __test_function with SIGIO
5a6bef47 JO	201	* configured.
	202	*
	203	* Following processing should happen:
8fd34e1c WN	204	* Exec: Action: Result:
	205	* incq (%rdi) - fd1 event breakpoint hit -> count1 == 1
	206	* - SIGIO is delivered
	207	* sig_handler - fd2 event breakpoint hit -> count2 == 1
	208	* - SIGUSR1 is delivered
	209	* sig_handler_2 -> overflows_2 == 1 (nested signal)
	210	* sys_rt_sigreturn - return from sig_handler_2
	211	* overflows++ -> overflows = 1
	212	* sys_rt_sigreturn - return from sig_handler
	213	* incq (%rdi) - fd3 event watchpoint hit -> count3 == 1 (wp and bp in one insn)
	214	* - SIGIO is delivered
	215	* sig_handler - fd2 event breakpoint hit -> count2 == 2
	216	* - SIGUSR1 is delivered
	217	* sig_handler_2 -> overflows_2 == 2 (nested signal)
	218	* sys_rt_sigreturn - return from sig_handler_2
	219	* overflows++ -> overflows = 2
	220	* sys_rt_sigreturn - return from sig_handler
	221	* the_var++ - fd3 event watchpoint hit -> count3 == 2 (standalone watchpoint)
	222	* - SIGIO is delivered
	223	* sig_handler - fd2 event breakpoint hit -> count2 == 3
	224	* - SIGUSR1 is delivered
	225	* sig_handler_2 -> overflows_2 == 3 (nested signal)
	226	* sys_rt_sigreturn - return from sig_handler_2
	227	* overflows++ -> overflows == 3
	228	* sys_rt_sigreturn - return from sig_handler
5a6bef47 JO	229	*
	230	* The test case check following error conditions:
	231	* - we get stuck in signal handler because of debug
	232	* exception being triggered receursively due to
	233	* the wrong RF EFLAG management
	234	*
	235	* - we never trigger the sig_handler breakpoint due
	236	* to the rong RF EFLAG management
	237	*
	238	*/
	239
8fd34e1c WN	240	fd1 = bp_event(__test_function, SIGIO);
	241	fd2 = bp_event(sig_handler, SIGUSR1);
	242	fd3 = wp_event((void *)&the_var, SIGIO);
5a6bef47 JO	243
	244	ioctl(fd1, PERF_EVENT_IOC_ENABLE, 0);
	245	ioctl(fd2, PERF_EVENT_IOC_ENABLE, 0);
8fd34e1c	246	ioctl(fd3, PERF_EVENT_IOC_ENABLE, 0);
5a6bef47 JO	247
	248	/*
	249	* Kick off the test by trigering 'fd1'
	250	* breakpoint.
	251	*/
	252	test_function();
	253
	254	ioctl(fd1, PERF_EVENT_IOC_DISABLE, 0);
	255	ioctl(fd2, PERF_EVENT_IOC_DISABLE, 0);
8fd34e1c	256	ioctl(fd3, PERF_EVENT_IOC_DISABLE, 0);
5a6bef47 JO	257
	258	count1 = bp_count(fd1);
	259	count2 = bp_count(fd2);
8fd34e1c	260	count3 = bp_count(fd3);
5a6bef47 JO	261
	262	close(fd1);
	263	close(fd2);
8fd34e1c	264	close(fd3);
5a6bef47	265
8fd34e1c WN	266	pr_debug("count1 %lld, count2 %lld, count3 %lld, overflow %d, overflows_2 %d\n",
8fd34e1c WN	267	count1, count2, count3, overflows, overflows_2);
5a6bef47 JO	268
	269	if (count1 != 1) {
	270	if (count1 == 11)
	271	pr_debug("failed: RF EFLAG recursion issue detected\n");
	272	else
	273	pr_debug("failed: wrong count for bp1%lld\n", count1);
	274	}
	275
8fd34e1c	276	if (overflows != 3)
5a6bef47 JO	277	pr_debug("failed: wrong overflow hit\n");
5a6bef47 JO	278
8fd34e1c WN	279	if (overflows_2 != 3)
	280	pr_debug("failed: wrong overflow_2 hit\n");
	281
	282	if (count2 != 3)
5a6bef47 JO	283	pr_debug("failed: wrong count for bp2\n");
5a6bef47 JO	284
8fd34e1c WN	285	if (count3 != 2)
	286	pr_debug("failed: wrong count for bp3\n");
	287
	288	return count1 == 1 && overflows == 3 && count2 == 3 && overflows_2 == 3 && count3 == 2 ?
5a6bef47 JO	289	TEST_OK : TEST_FAIL;
5a6bef47 JO	290	}
598762cf JO	291
	292	bool test__bp_signal_is_supported(void)
	293	{
	294	/*
	295	* The powerpc so far does not have support to even create
	296	* instruction breakpoint using the perf event interface.
	297	* Once it's there we can release this.
	298	*/
	299	#ifdef __powerpc__
	300	return false;
	301	#else
	302	return true;
	303	#endif
	304	}