1 // SPDX-License-Identifier: GPL-2.0 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> 19 #include <errno.h> 20 21 #include "../kselftest.h" 22 23 #ifndef SS_AUTODISARM 24 #define SS_AUTODISARM (1U << 31) 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 43 #if __s390x__ 44 register unsigned long sp asm("%15"); 45 #else 46 register unsigned long sp asm("sp"); 47 #endif 48 49 if (sp < (unsigned long)sstack || 50 sp >= (unsigned long)sstack + SIGSTKSZ) { 51 ksft_exit_fail_msg("SP is not on sigaltstack\n"); 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; 59 ksft_print_msg("[RUN]\tsignal USR1\n"); 60 err = sigaltstack(NULL, &stk); 61 if (err) { 62 ksft_exit_fail_msg("sigaltstack() - %s\n", strerror(errno)); 63 exit(EXIT_FAILURE); 64 } 65 if (stk.ss_flags != SS_DISABLE) 66 ksft_test_result_fail("tss_flags=%x, should be SS_DISABLE\n", 67 stk.ss_flags); 68 else 69 ksft_test_result_pass( 70 "sigaltstack is disabled in sighandler\n"); 71 swapcontext(&sc, &uc); 72 ksft_print_msg("%s\n", p->msg); 73 if (!p->flag) { 74 ksft_exit_fail_msg("[RUN]\tAborting\n"); 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 84 ksft_print_msg("[RUN]\tsignal USR2\n"); 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) { 90 ksft_test_result_fail("sigaltstack re-used\n"); 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 { 100 ksft_print_msg("[RUN]\tswitched to user ctx\n"); 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 111 ksft_print_header(); 112 ksft_set_plan(3); 113 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) { 123 ksft_exit_fail_msg("mmap() - %s\n", strerror(errno)); 124 return EXIT_FAILURE; 125 } 126 127 err = sigaltstack(NULL, &stk); 128 if (err) { 129 ksft_exit_fail_msg("sigaltstack() - %s\n", strerror(errno)); 130 exit(EXIT_FAILURE); 131 } 132 if (stk.ss_flags == SS_DISABLE) { 133 ksft_test_result_pass( 134 "Initial sigaltstack state was SS_DISABLE\n"); 135 } else { 136 ksft_exit_fail_msg("Initial sigaltstack state was %x; " 137 "should have been SS_DISABLE\n", stk.ss_flags); 138 return EXIT_FAILURE; 139 } 140 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) { 146 if (errno == EINVAL) { 147 ksft_test_result_skip( 148 "[NOTE]\tThe running kernel doesn't support SS_AUTODISARM\n"); 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 { 157 ksft_exit_fail_msg( 158 "sigaltstack(SS_ONSTACK | SS_AUTODISARM) %s\n", 159 strerror(errno)); 160 return EXIT_FAILURE; 161 } 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) { 167 ksft_exit_fail_msg("mmap() - %s\n", strerror(errno)); 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) { 179 ksft_exit_fail_msg("sigaltstack() - %s\n", strerror(errno)); 180 exit(EXIT_FAILURE); 181 } 182 if (stk.ss_flags != SS_AUTODISARM) { 183 ksft_exit_fail_msg("ss_flags=%x, should be SS_AUTODISARM\n", 184 stk.ss_flags); 185 exit(EXIT_FAILURE); 186 } 187 ksft_test_result_pass( 188 "sigaltstack is still SS_AUTODISARM after signal\n"); 189 190 ksft_exit_pass(); 191 return 0; 192 } 193