[mirror_ubuntu-hirsute-kernel.git] / tools / testing / selftests / sigaltstack / sas.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Stas Sergeev <stsp@users.sourceforge.net>
 *
 * test sigaltstack(SS_ONSTACK | SS_AUTODISARM)
 * If that succeeds, then swapcontext() can be used inside sighandler safely.
 *
 */

#define _GNU_SOURCE
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <ucontext.h>
#include <alloca.h>
#include <string.h>
#include <assert.h>
#include <errno.h>

#include "../kselftest.h"

#ifndef SS_AUTODISARM
#define SS_AUTODISARM  (1U << 31)
#endif

static void *sstack, *ustack;
static ucontext_t uc, sc;
static const char *msg = "[OK]\tStack preserved";
static const char *msg2 = "[FAIL]\tStack corrupted";
struct stk_data {
	char msg[128];
	int flag;
};

void my_usr1(int sig, siginfo_t *si, void *u)
{
	char *aa;
	int err;
	stack_t stk;
	struct stk_data *p;

#if __s390x__
	register unsigned long sp asm("%15");
#else
	register unsigned long sp asm("sp");
#endif

	if (sp < (unsigned long)sstack ||
			sp >= (unsigned long)sstack + SIGSTKSZ) {
		ksft_exit_fail_msg("SP is not on sigaltstack\n");
	}
	/* put some data on stack. other sighandler will try to overwrite it */
	aa = alloca(1024);
	assert(aa);
	p = (struct stk_data *)(aa + 512);
	strcpy(p->msg, msg);
	p->flag = 1;
	ksft_print_msg("[RUN]\tsignal USR1\n");
	err = sigaltstack(NULL, &stk);
	if (err) {
		ksft_exit_fail_msg("sigaltstack() - %s\n", strerror(errno));
		exit(EXIT_FAILURE);
	}
	if (stk.ss_flags != SS_DISABLE)
		ksft_test_result_fail("tss_flags=%x, should be SS_DISABLE\n",
				stk.ss_flags);
	else
		ksft_test_result_pass(
				"sigaltstack is disabled in sighandler\n");
	swapcontext(&sc, &uc);
	ksft_print_msg("%s\n", p->msg);
	if (!p->flag) {
		ksft_exit_skip("[RUN]\tAborting\n");
		exit(EXIT_FAILURE);
	}
}

void my_usr2(int sig, siginfo_t *si, void *u)
{
	char *aa;
	struct stk_data *p;

	ksft_print_msg("[RUN]\tsignal USR2\n");
	aa = alloca(1024);
	/* dont run valgrind on this */
	/* try to find the data stored by previous sighandler */
	p = memmem(aa, 1024, msg, strlen(msg));
	if (p) {
		ksft_test_result_fail("sigaltstack re-used\n");
		/* corrupt the data */
		strcpy(p->msg, msg2);
		/* tell other sighandler that his data is corrupted */
		p->flag = 0;
	}
}

static void switch_fn(void)
{
	ksft_print_msg("[RUN]\tswitched to user ctx\n");
	raise(SIGUSR2);
	setcontext(&sc);
}

int main(void)
{
	struct sigaction act;
	stack_t stk;
	int err;

	ksft_print_header();
	ksft_set_plan(3);

	sigemptyset(&act.sa_mask);
	act.sa_flags = SA_ONSTACK | SA_SIGINFO;
	act.sa_sigaction = my_usr1;
	sigaction(SIGUSR1, &act, NULL);
	act.sa_sigaction = my_usr2;
	sigaction(SIGUSR2, &act, NULL);
	sstack = mmap(NULL, SIGSTKSZ, PROT_READ | PROT_WRITE,
		      MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
	if (sstack == MAP_FAILED) {
		ksft_exit_fail_msg("mmap() - %s\n", strerror(errno));
		return EXIT_FAILURE;
	}

	err = sigaltstack(NULL, &stk);
	if (err) {
		ksft_exit_fail_msg("sigaltstack() - %s\n", strerror(errno));
		exit(EXIT_FAILURE);
	}
	if (stk.ss_flags == SS_DISABLE) {
		ksft_test_result_pass(
				"Initial sigaltstack state was SS_DISABLE\n");
	} else {
		ksft_exit_fail_msg("Initial sigaltstack state was %x; "
		       "should have been SS_DISABLE\n", stk.ss_flags);
		return EXIT_FAILURE;
	}

	stk.ss_sp = sstack;
	stk.ss_size = SIGSTKSZ;
	stk.ss_flags = SS_ONSTACK | SS_AUTODISARM;
	err = sigaltstack(&stk, NULL);
	if (err) {
		if (errno == EINVAL) {
			ksft_exit_skip(
				"[NOTE]\tThe running kernel doesn't support SS_AUTODISARM\n");
			/*
			 * If test cases for the !SS_AUTODISARM variant were
			 * added, we could still run them.  We don't have any
			 * test cases like that yet, so just exit and report
			 * success.
			 */
			return 0;
		} else {
			ksft_exit_fail_msg(
				"sigaltstack(SS_ONSTACK | SS_AUTODISARM)  %s\n",
					strerror(errno));
			return EXIT_FAILURE;
		}
	}

	ustack = mmap(NULL, SIGSTKSZ, PROT_READ | PROT_WRITE,
		      MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
	if (ustack == MAP_FAILED) {
		ksft_exit_fail_msg("mmap() - %s\n", strerror(errno));
		return EXIT_FAILURE;
	}
	getcontext(&uc);
	uc.uc_link = NULL;
	uc.uc_stack.ss_sp = ustack;
	uc.uc_stack.ss_size = SIGSTKSZ;
	makecontext(&uc, switch_fn, 0);
	raise(SIGUSR1);

	err = sigaltstack(NULL, &stk);
	if (err) {
		ksft_exit_fail_msg("sigaltstack() - %s\n", strerror(errno));
		exit(EXIT_FAILURE);
	}
	if (stk.ss_flags != SS_AUTODISARM) {
		ksft_exit_fail_msg("ss_flags=%x, should be SS_AUTODISARM\n",
				stk.ss_flags);
		exit(EXIT_FAILURE);
	}
	ksft_test_result_pass(
			"sigaltstack is still SS_AUTODISARM after signal\n");

	ksft_exit_pass();
	return 0;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
19fd2868 SS	2	/*
	3	* Stas Sergeev <stsp@users.sourceforge.net>
	4	*
	5	* test sigaltstack(SS_ONSTACK \| SS_AUTODISARM)
	6	* If that succeeds, then swapcontext() can be used inside sighandler safely.
	7	*
	8	*/
	9
	10	#define _GNU_SOURCE
	11	#include <signal.h>
	12	#include <stdio.h>
	13	#include <stdlib.h>
	14	#include <sys/mman.h>
	15	#include <ucontext.h>
	16	#include <alloca.h>
	17	#include <string.h>
	18	#include <assert.h>
158b67b5	19	#include <errno.h>
19fd2868	20
5ec8d6ce SK	21	#include "../kselftest.h"
5ec8d6ce SK	22
19fd2868	23	#ifndef SS_AUTODISARM
91c61805	24	#define SS_AUTODISARM (1U << 31)
19fd2868 SS	25	#endif
	26
	27	static void sstack, ustack;
	28	static ucontext_t uc, sc;
	29	static const char *msg = "[OK]\tStack preserved";
	30	static const char *msg2 = "[FAIL]\tStack corrupted";
	31	struct stk_data {
	32	char msg[128];
	33	int flag;
	34	};
	35
	36	void my_usr1(int sig, siginfo_t si, void u)
	37	{
	38	char *aa;
	39	int err;
	40	stack_t stk;
	41	struct stk_data *p;
	42
96e53358 TR	43	#if __s390x__
	44	register unsigned long sp asm("%15");
	45	#else
19fd2868	46	register unsigned long sp asm("sp");
96e53358	47	#endif
19fd2868 SS	48
	49	if (sp < (unsigned long)sstack \|\|
	50	sp >= (unsigned long)sstack + SIGSTKSZ) {
5ec8d6ce	51	ksft_exit_fail_msg("SP is not on sigaltstack\n");
19fd2868 SS	52	}
	53	/* put some data on stack. other sighandler will try to overwrite it */
	54	aa = alloca(1024);
	55	assert(aa);
	56	p = (struct stk_data *)(aa + 512);
	57	strcpy(p->msg, msg);
	58	p->flag = 1;
5ec8d6ce	59	ksft_print_msg("[RUN]\tsignal USR1\n");
19fd2868 SS	60	err = sigaltstack(NULL, &stk);
19fd2868 SS	61	if (err) {
5ec8d6ce	62	ksft_exit_fail_msg("sigaltstack() - %s\n", strerror(errno));
19fd2868 SS	63	exit(EXIT_FAILURE);
	64	}
	65	if (stk.ss_flags != SS_DISABLE)
5ec8d6ce	66	ksft_test_result_fail("tss_flags=%x, should be SS_DISABLE\n",
19fd2868 SS	67	stk.ss_flags);
19fd2868 SS	68	else
5ec8d6ce SK	69	ksft_test_result_pass(
5ec8d6ce SK	70	"sigaltstack is disabled in sighandler\n");
19fd2868	71	swapcontext(&sc, &uc);
5ec8d6ce	72	ksft_print_msg("%s\n", p->msg);
19fd2868	73	if (!p->flag) {
5ec8d6ce	74	ksft_exit_skip("[RUN]\tAborting\n");
19fd2868 SS	75	exit(EXIT_FAILURE);
	76	}
	77	}
	78
	79	void my_usr2(int sig, siginfo_t si, void u)
	80	{
	81	char *aa;
	82	struct stk_data *p;
	83
5ec8d6ce	84	ksft_print_msg("[RUN]\tsignal USR2\n");
19fd2868 SS	85	aa = alloca(1024);
	86	/* dont run valgrind on this */
	87	/* try to find the data stored by previous sighandler */
	88	p = memmem(aa, 1024, msg, strlen(msg));
	89	if (p) {
5ec8d6ce	90	ksft_test_result_fail("sigaltstack re-used\n");
19fd2868 SS	91	/* corrupt the data */
	92	strcpy(p->msg, msg2);
	93	/* tell other sighandler that his data is corrupted */
	94	p->flag = 0;
	95	}
	96	}
	97
	98	static void switch_fn(void)
	99	{
5ec8d6ce	100	ksft_print_msg("[RUN]\tswitched to user ctx\n");
19fd2868 SS	101	raise(SIGUSR2);
	102	setcontext(&sc);
	103	}
	104
	105	int main(void)
	106	{
	107	struct sigaction act;
	108	stack_t stk;
	109	int err;
	110
5ec8d6ce	111	ksft_print_header();
5821ba96	112	ksft_set_plan(3);
5ec8d6ce	113
19fd2868 SS	114	sigemptyset(&act.sa_mask);
	115	act.sa_flags = SA_ONSTACK \| SA_SIGINFO;
	116	act.sa_sigaction = my_usr1;
	117	sigaction(SIGUSR1, &act, NULL);
	118	act.sa_sigaction = my_usr2;
	119	sigaction(SIGUSR2, &act, NULL);
	120	sstack = mmap(NULL, SIGSTKSZ, PROT_READ \| PROT_WRITE,
	121	MAP_PRIVATE \| MAP_ANONYMOUS \| MAP_STACK, -1, 0);
	122	if (sstack == MAP_FAILED) {
5ec8d6ce	123	ksft_exit_fail_msg("mmap() - %s\n", strerror(errno));
19fd2868 SS	124	return EXIT_FAILURE;
19fd2868 SS	125	}
0318bc8a AL	126
	127	err = sigaltstack(NULL, &stk);
	128	if (err) {
5ec8d6ce	129	ksft_exit_fail_msg("sigaltstack() - %s\n", strerror(errno));
0318bc8a AL	130	exit(EXIT_FAILURE);
	131	}
	132	if (stk.ss_flags == SS_DISABLE) {
5ec8d6ce SK	133	ksft_test_result_pass(
5ec8d6ce SK	134	"Initial sigaltstack state was SS_DISABLE\n");
0318bc8a	135	} else {
5ec8d6ce	136	ksft_exit_fail_msg("Initial sigaltstack state was %x; "
0c49ad41	137	"should have been SS_DISABLE\n", stk.ss_flags);
0318bc8a AL	138	return EXIT_FAILURE;
	139	}
	140
19fd2868 SS	141	stk.ss_sp = sstack;
	142	stk.ss_size = SIGSTKSZ;
	143	stk.ss_flags = SS_ONSTACK \| SS_AUTODISARM;
	144	err = sigaltstack(&stk, NULL);
	145	if (err) {
158b67b5	146	if (errno == EINVAL) {
5ec8d6ce SK	147	ksft_exit_skip(
5ec8d6ce SK	148	"[NOTE]\tThe running kernel doesn't support SS_AUTODISARM\n");
158b67b5 AL	149	/*
	150	* If test cases for the !SS_AUTODISARM variant were
	151	* added, we could still run them. We don't have any
	152	* test cases like that yet, so just exit and report
	153	* success.
	154	*/
	155	return 0;
	156	} else {
5ec8d6ce SK	157	ksft_exit_fail_msg(
	158	"sigaltstack(SS_ONSTACK \| SS_AUTODISARM) %s\n",
	159	strerror(errno));
158b67b5 AL	160	return EXIT_FAILURE;
158b67b5 AL	161	}
19fd2868 SS	162	}
	163
	164	ustack = mmap(NULL, SIGSTKSZ, PROT_READ \| PROT_WRITE,
	165	MAP_PRIVATE \| MAP_ANONYMOUS \| MAP_STACK, -1, 0);
	166	if (ustack == MAP_FAILED) {
5ec8d6ce	167	ksft_exit_fail_msg("mmap() - %s\n", strerror(errno));
19fd2868 SS	168	return EXIT_FAILURE;
	169	}
	170	getcontext(&uc);
	171	uc.uc_link = NULL;
	172	uc.uc_stack.ss_sp = ustack;
	173	uc.uc_stack.ss_size = SIGSTKSZ;
	174	makecontext(&uc, switch_fn, 0);
	175	raise(SIGUSR1);
	176
	177	err = sigaltstack(NULL, &stk);
	178	if (err) {
5ec8d6ce	179	ksft_exit_fail_msg("sigaltstack() - %s\n", strerror(errno));
19fd2868 SS	180	exit(EXIT_FAILURE);
19fd2868 SS	181	}
0318bc8a	182	if (stk.ss_flags != SS_AUTODISARM) {
5ec8d6ce	183	ksft_exit_fail_msg("ss_flags=%x, should be SS_AUTODISARM\n",
19fd2868 SS	184	stk.ss_flags);
	185	exit(EXIT_FAILURE);
	186	}
5ec8d6ce SK	187	ksft_test_result_pass(
5ec8d6ce SK	188	"sigaltstack is still SS_AUTODISARM after signal\n");
19fd2868	189
5ec8d6ce	190	ksft_exit_pass();
19fd2868 SS	191	return 0;
19fd2868 SS	192	}