granicus.if.org Git - strace/blob - tests/threads-execve.c

   1 /*
   2  * Check decoding of threads when a non-leader thread invokes execve.
   3  *
   4  * Copyright (c) 2016 Dmitry V. Levin <ldv@altlinux.org>
   5  * Copyright (c) 2016-2018 The strace developers.
   6  * All rights reserved.
   7  *
   8  * SPDX-License-Identifier: GPL-2.0-or-later
   9  */
  10
  11 #include "tests.h"
  12 #include <asm/unistd.h>
  13 #include <errno.h>
  14 #include <pthread.h>
  15 #include <signal.h>
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <time.h>
  19 #include <unistd.h>
  20
  21 static pid_t leader;
  22 static pid_t tid;
  23
  24 static void
  25 handler(int signo)
  26 {
  27 }
  28
  29 static unsigned int sigsetsize;
  30 static long
  31 k_sigsuspend(const sigset_t *const set)
  32 {
  33         return syscall(__NR_rt_sigsuspend, set, sigsetsize);
  34 }
  35
  36 static pid_t
  37 k_gettid(void)
  38 {
  39         return syscall(__NR_gettid);
  40 }
  41
  42 static void
  43 get_sigsetsize(void)
  44 {
  45         static const struct sigaction sa = { .sa_handler = handler };
  46         if (sigaction(SIGUSR1, &sa, NULL))
  47                 perror_msg_and_fail("sigaction");
  48
  49         sigset_t mask;
  50         sigemptyset(&mask);
  51         sigaddset(&mask, SIGUSR1);
  52         if (sigprocmask(SIG_BLOCK, &mask, NULL))
  53                 perror_msg_and_fail("sigprocmask");
  54
  55         raise(SIGUSR1);
  56
  57         sigemptyset(&mask);
  58         for (sigsetsize = sizeof(mask) / sizeof(long);
  59              sigsetsize; sigsetsize >>= 1) {
  60                 long rc = k_sigsuspend(&mask);
  61                 if (!rc)
  62                         error_msg_and_fail("rt_sigsuspend");
  63                 if (EINTR == errno)
  64                         break;
  65                 printf("%-5d rt_sigsuspend(%p, %u) = %s\n",
  66                        leader, &mask, sigsetsize, sprintrc(rc));
  67         }
  68         if (!sigsetsize)
  69                 perror_msg_and_fail("rt_sigsuspend");
  70         printf("%-5d rt_sigsuspend([], %u) = ? ERESTARTNOHAND"
  71                " (To be restarted if no handler)\n", leader, sigsetsize);
  72 }
  73
  74 enum {
  75         ACTION_exit = 0,
  76         ACTION_rt_sigsuspend,
  77         ACTION_nanosleep,
  78         NUMBER_OF_ACTIONS
  79 };
  80
  81 static const unsigned int NUMBER_OF_ITERATIONS = 1;
  82 static unsigned int action;
  83 static int fds[2];
  84
  85 static unsigned int
  86 arglen(char **args)
  87 {
  88         char **p;
  89
  90         for (p = args; *p; ++p)
  91                 ;
  92
  93         return p - args;
  94 }
  95
  96 static void *
  97 thread(void *arg)
  98 {
  99         tid = k_gettid();
 100
 101         static char buf[sizeof(action) * 3];
 102         sprintf(buf, "%u", action + 1);
 103
 104         char **argv = arg;
 105         argv[2] = buf;
 106
 107         if (read(fds[0], fds, sizeof(fds[0])))
 108                 perror_msg_and_fail("execve");
 109
 110         struct timespec ts = { .tv_nsec = 100000000 };
 111         (void) clock_nanosleep(CLOCK_REALTIME, 0, &ts, NULL);
 112
 113         ts.tv_nsec = 12345;
 114         printf("%-5d nanosleep({tv_sec=0, tv_nsec=%u}, NULL) = 0\n",
 115                tid, (unsigned int) ts.tv_nsec);
 116
 117         switch (action % NUMBER_OF_ACTIONS) {
 118                 case ACTION_exit:
 119                         printf("%-5d execve(\"%s\", [\"%s\", \"%s\", \"%s\"]"
 120                                ", %p /* %u vars */ <pid changed to %u ...>\n",
 121                                tid, argv[0], argv[0], argv[1], argv[2],
 122                                environ, arglen(environ), leader);
 123                         break;
 124                 case ACTION_rt_sigsuspend:
 125                         printf("%-5d execve(\"%s\", [\"%s\", \"%s\", \"%s\"]"
 126                                ", %p /* %u vars */ <unfinished ...>\n"
 127                                "%-5d <... rt_sigsuspend resumed>) = ?\n",
 128                                tid, argv[0], argv[0], argv[1], argv[2],
 129                                environ, arglen(environ),
 130                                leader);
 131                         break;
 132                 case ACTION_nanosleep:
 133                         printf("%-5d execve(\"%s\", [\"%s\", \"%s\", \"%s\"]"
 134                                ", %p /* %u vars */ <unfinished ...>\n"
 135                                "%-5d <... nanosleep resumed> <unfinished ...>)"
 136                                " = ?\n",
 137                                tid, argv[0], argv[0], argv[1], argv[2],
 138                                environ, arglen(environ),
 139                                leader);
 140                         break;
 141         }
 142
 143         printf("%-5d +++ superseded by execve in pid %u +++\n"
 144                "%-5d <... execve resumed> ) = 0\n",
 145                leader, tid,
 146                leader);
 147
 148         (void) nanosleep(&ts, NULL);
 149         execve(argv[0], argv, environ);
 150         perror_msg_and_fail("execve");
 151 }
 152
 153 int
 154 main(int ac, char **av)
 155 {
 156         setvbuf(stdout, NULL, _IONBF, 0);
 157         leader = getpid();
 158
 159         if (ac < 3) {
 160                 struct timespec ts = { .tv_nsec = 1 };
 161                 if (clock_nanosleep(CLOCK_REALTIME, 0, &ts, NULL))
 162                         perror_msg_and_skip("clock_nanosleep CLOCK_REALTIME");
 163
 164                 get_sigsetsize();
 165                 static char buf[sizeof(sigsetsize) * 3];
 166                 sprintf(buf, "%u", sigsetsize);
 167
 168                 char *argv[] = { av[0], buf, (char *) "0", NULL };
 169                 printf("%-5d execve(\"%s\", [\"%s\", \"%s\", \"%s\"]"
 170                        ", %p /* %u vars */) = 0\n",
 171                        leader, argv[0], argv[0], argv[1], argv[2],
 172                        environ, arglen(environ));
 173                 execve(argv[0], argv, environ);
 174                 perror_msg_and_fail("execve");
 175         }
 176
 177         sigsetsize = atoi(av[1]);
 178         action = atoi(av[2]);
 179
 180         if (action >= NUMBER_OF_ACTIONS * NUMBER_OF_ITERATIONS) {
 181                 printf("%-5d +++ exited with 0 +++\n", leader);
 182                 return 0;
 183         }
 184
 185         if (pipe(fds))
 186                 perror_msg_and_fail("pipe");
 187
 188         pthread_t t;
 189         errno = pthread_create(&t, NULL, thread, av);
 190         if (errno)
 191                 perror_msg_and_fail("pthread_create");
 192
 193         struct timespec ts = { .tv_sec = 123 };
 194         sigset_t mask;
 195         sigemptyset(&mask);
 196
 197         static char leader_str[sizeof(leader) * 3];
 198         int leader_str_len =
 199                 snprintf(leader_str, sizeof(leader_str), "%-5d", leader);
 200
 201         switch (action % NUMBER_OF_ACTIONS) {
 202                 case ACTION_exit:
 203                         printf("%s exit(42)%*s= ?\n", leader_str,
 204                                (int) sizeof(leader_str) - leader_str_len, " ");
 205                         close(fds[1]);
 206                         (void) syscall(__NR_exit, 42);
 207                         break;
 208                 case ACTION_rt_sigsuspend:
 209                         printf("%s rt_sigsuspend([], %u <unfinished ...>\n",
 210                                leader_str, sigsetsize);
 211                         close(fds[1]);
 212                         (void) k_sigsuspend(&mask);
 213                         break;
 214                 case ACTION_nanosleep:
 215                         printf("%s nanosleep({tv_sec=%u, tv_nsec=0}"
 216                                ",  <unfinished ...>\n",
 217                                leader_str, (unsigned int) ts.tv_sec);
 218                         close(fds[1]);
 219                         (void) nanosleep(&ts, 0);
 220                         break;
 221         }
 222
 223         return 1;
 224 }