tools/testing/selftests/sigaltstack/sas.c

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