tests/sys/kern/pdeathsig.c

   1 /*-
   2  * Copyright (c) 2018 Thomas Munro
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <assert.h>
  31 #include <atf-c.h>
  32 #include <errno.h>
  33 #include <signal.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <time.h>
  37 #include <unistd.h>
  38 #include <sys/procctl.h>
  39 #include <sys/ptrace.h>
  40 #include <sys/signal.h>
  41 #include <sys/types.h>
  42
  43 static void
  44 dummy_signal_handler(int signum)
  45 {
  46 }
  47
  48 ATF_TC_WITHOUT_HEAD(arg_validation);
  49 ATF_TC_BODY(arg_validation, tc)
  50 {
  51         int signum;
  52         int rc;
  53
  54         /* bad signal */
  55         signum = 8888;
  56         rc = procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signum);
  57         ATF_CHECK_EQ(-1, rc);
  58         ATF_CHECK_EQ(EINVAL, errno);
  59
  60         /* bad id type */
  61         signum = SIGINFO;
  62         rc = procctl(8888, 0, PROC_PDEATHSIG_CTL, &signum);
  63         ATF_CHECK_EQ(-1, rc);
  64         ATF_CHECK_EQ(EINVAL, errno);
  65
  66         /* bad id (pid that doesn't match mine or zero) */
  67         signum = SIGINFO;
  68         rc = procctl(P_PID, (((getpid() + 1) % 10) + 100),
  69             PROC_PDEATHSIG_CTL, &signum);
  70         ATF_CHECK_EQ(-1, rc);
  71         ATF_CHECK_EQ(EINVAL, errno);
  72
  73         /* null pointer */
  74         signum = SIGINFO;
  75         rc = procctl(P_PID, 0, PROC_PDEATHSIG_CTL, NULL);
  76         ATF_CHECK_EQ(-1, rc);
  77         ATF_CHECK_EQ(EFAULT, errno);
  78
  79         /* good (pid == 0) */
  80         signum = SIGINFO;
  81         rc = procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signum);
  82         ATF_CHECK_EQ(0, rc);
  83
  84         /* good (pid == my pid) */
  85         signum = SIGINFO;
  86         rc = procctl(P_PID, getpid(), PROC_PDEATHSIG_CTL, &signum);
  87         ATF_CHECK_EQ(0, rc);
  88
  89         /* check that we can read the signal number back */
  90         signum = 0xdeadbeef;
  91         rc = procctl(P_PID, 0, PROC_PDEATHSIG_STATUS, &signum);
  92         ATF_CHECK_EQ(0, rc);
  93         ATF_CHECK_EQ(SIGINFO, signum);
  94 }
  95
  96 ATF_TC_WITHOUT_HEAD(fork_no_inherit);
  97 ATF_TC_BODY(fork_no_inherit, tc)
  98 {
  99         int status;
 100         int signum;
 101         int rc;
 102
 103         /* request a signal on parent death in the parent */
 104         signum = SIGINFO;
 105         rc = procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signum);
 106
 107         rc = fork();
 108         ATF_REQUIRE(rc != -1);
 109         if (rc == 0) {
 110                 /* check that we didn't inherit the setting */
 111                 signum = 0xdeadbeef;
 112                 rc = procctl(P_PID, 0, PROC_PDEATHSIG_STATUS, &signum);
 113                 assert(rc == 0);
 114                 assert(signum == 0);
 115                 _exit(0);
 116         }
 117
 118         /* wait for the child to exit successfully */
 119         waitpid(rc, &status, 0);
 120         ATF_CHECK_EQ(0, status);
 121 }
 122
 123 ATF_TC_WITHOUT_HEAD(exec_inherit);
 124 ATF_TC_BODY(exec_inherit, tc)
 125 {
 126         int status;
 127         int rc;
 128
 129         rc = fork();
 130         ATF_REQUIRE(rc != -1);
 131         if (rc == 0) {
 132                 char exec_path[1024];
 133                 int signum;
 134
 135                 /* compute the path of the helper executable */
 136                 snprintf(exec_path, sizeof(exec_path), "%s/pdeathsig_helper",
 137                          atf_tc_get_config_var(tc, "srcdir"));
 138
 139                 /* request a signal on parent death and register a handler */
 140                 signum = SIGINFO;
 141                 rc = procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signum);
 142                 assert(rc == 0);
 143
 144                 /* execute helper program: it asserts that it has the setting */
 145                 rc = execl(exec_path, exec_path, NULL);
 146                 assert(rc == 0);
 147                 _exit(0);
 148         }
 149
 150         /* wait for the child to exit successfully */
 151         waitpid(rc, &status, 0);
 152         ATF_CHECK_EQ(0, status);
 153 }
 154
 155 ATF_TC_WITHOUT_HEAD(signal_delivered);
 156 ATF_TC_BODY(signal_delivered, tc)
 157 {
 158         sigset_t sigset;
 159         int signum;
 160         int rc;
 161         int pipe_ca[2];
 162         int pipe_cb[2];
 163         char buffer;
 164
 165         rc = pipe(pipe_ca);
 166         ATF_REQUIRE(rc == 0);
 167         rc = pipe(pipe_cb);
 168         ATF_REQUIRE(rc == 0);
 169
 170         rc = fork();
 171         ATF_REQUIRE(rc != -1);
 172         if (rc == 0) {
 173                 rc = fork();
 174                 assert(rc >= 0);
 175                 if (rc == 0) {
 176                         /* process C */
 177                         signum = SIGINFO;
 178
 179                         /* block signals so we can handle them synchronously */
 180                         rc = sigfillset(&sigset);
 181                         assert(rc == 0);
 182                         rc = sigprocmask(SIG_SETMASK, &sigset, NULL);
 183                         assert(rc == 0);
 184
 185                         /* register a dummy handler or the kernel will not queue it */
 186                         signal(signum, dummy_signal_handler);
 187
 188                         /* request a signal on death of our parent B */
 189                         rc = procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signum);
 190                         assert(rc == 0);
 191
 192                         /* tell B that we're ready for it to exit now */
 193                         rc = write(pipe_cb[1], ".", 1);
 194                         assert(rc == 1);
 195
 196                         /* wait for B to die and signal us... */
 197                         signum = 0xdeadbeef;
 198                         rc = sigwait(&sigset, &signum);
 199                         assert(rc == 0);
 200                         assert(signum == SIGINFO);
 201
 202                         /* tell A the test passed */
 203                         rc = write(pipe_ca[1], ".", 1);
 204                         assert(rc == 1);
 205                         _exit(0);
 206                 }
 207
 208                 /* process B */
 209
 210                 /* wait for C to tell us it is ready for us to exit */
 211                 rc = read(pipe_cb[0], &buffer, 1);
 212                 assert(rc == 1);
 213
 214                 /* now we exit so that C gets a signal */
 215                 _exit(0);
 216         }
 217         /* process A */
 218
 219         /* wait for C to tell us the test passed */
 220         rc = read(pipe_ca[0], &buffer, 1);
 221         ATF_CHECK_EQ(1, rc);
 222 }
 223
 224 ATF_TC_WITHOUT_HEAD(signal_delivered_ptrace);
 225 ATF_TC_BODY(signal_delivered_ptrace, tc)
 226 {
 227         sigset_t sigset;
 228         int signum;
 229         int rc;
 230         int pipe_ca[2];
 231         int pipe_db[2];
 232         char buffer;
 233         int status;
 234
 235         rc = pipe(pipe_ca);
 236         ATF_REQUIRE(rc == 0);
 237         rc = pipe(pipe_db);
 238         ATF_REQUIRE(rc == 0);
 239
 240         rc = fork();
 241         ATF_REQUIRE(rc != -1);
 242         if (rc == 0) {
 243                 pid_t c_pid;
 244
 245                 /* process B */
 246
 247                 rc = fork();
 248                 assert(rc >= 0);
 249                 if (rc == 0) {
 250                         /* process C */
 251                         signum = SIGINFO;
 252
 253                         /* block signals so we can handle them synchronously */
 254                         rc = sigfillset(&sigset);
 255                         assert(rc == 0);
 256                         rc = sigprocmask(SIG_SETMASK, &sigset, NULL);
 257                         assert(rc == 0);
 258
 259                         /* register a dummy handler or the kernel will not queue it */
 260                         signal(signum, dummy_signal_handler);
 261
 262                         /* request a signal on parent death and register a handler */
 263                         rc = procctl(P_PID, 0, PROC_PDEATHSIG_CTL, &signum);
 264                         assert(rc == 0);
 265
 266                         /* wait for B to die and signal us... */
 267                         signum = 0xdeadbeef;
 268                         rc = sigwait(&sigset, &signum);
 269                         assert(rc == 0);
 270                         assert(signum == SIGINFO);
 271
 272                         /* tell A the test passed */
 273                         rc = write(pipe_ca[1], ".", 1);
 274                         assert(rc == 1);
 275                         _exit(0);
 276                 }
 277                 c_pid = rc;
 278
 279
 280                 /* fork another process to ptrace C */
 281                 rc = fork();
 282                 assert(rc >= 0);
 283                 if (rc == 0) {
 284
 285                         /* process D */
 286                         rc = ptrace(PT_ATTACH, c_pid, 0, 0);
 287                         assert(rc == 0);
 288
 289                         waitpid(c_pid, &status, 0);
 290                         assert(WIFSTOPPED(status));
 291                         assert(WSTOPSIG(status) == SIGSTOP);
 292
 293                         rc = ptrace(PT_CONTINUE, c_pid, (caddr_t) 1, 0);
 294                         assert(rc == 0);
 295
 296                         /* tell B that we're ready for it to exit now */
 297                         rc = write(pipe_db[1], ".", 1);
 298                         assert(rc == 1);
 299
 300                         waitpid(c_pid, &status, 0);
 301                         assert(WIFSTOPPED(status));
 302                         assert(WSTOPSIG(status) == SIGINFO);
 303
 304                         rc = ptrace(PT_CONTINUE, c_pid, (caddr_t) 1,
 305                                     WSTOPSIG(status));
 306                         assert(rc == 0);
 307
 308                         ptrace(PT_DETACH, c_pid, 0, 0);
 309
 310                         _exit(0);
 311                 }
 312
 313                 /* wait for D to tell us it is ready for us to exit */
 314                 rc = read(pipe_db[0], &buffer, 1);
 315                 assert(rc == 1);
 316
 317                 /* now we exit so that C gets a signal */
 318                 _exit(0);
 319         }
 320
 321         /* process A */
 322
 323         /* wait for C to tell us the test passed */
 324         rc = read(pipe_ca[0], &buffer, 1);
 325         ATF_CHECK_EQ(1, rc);
 326 }
 327
 328 ATF_TP_ADD_TCS(tp)
 329 {
 330         ATF_TP_ADD_TC(tp, arg_validation);
 331         ATF_TP_ADD_TC(tp, fork_no_inherit);
 332         ATF_TP_ADD_TC(tp, exec_inherit);
 333         ATF_TP_ADD_TC(tp, signal_delivered);
 334         ATF_TP_ADD_TC(tp, signal_delivered_ptrace);
 335         return (atf_no_error());
 336 }