8000 minix/minix/tests/test37.c at master · elypter/minix · GitHub
[go: up one dir, main page]

Skip to content

Latest commit

 

History

History
1055 lines (907 loc) · 26.8 KB

test37.c

File metadata and controls

1055 lines (907 loc) · 26.8 KB
wait_for(pid);
break;
case -1: e(22); break;
}
}
/*---------------------------------------------------------------------------*/
/* Test that the signal handler can be invoked recursively with the
* state being properly saved and restored.
*/
static int y;
static int z;
void catch3(signo)
int signo;
{
if (z == 1) { /* catching a nested signal */
y = 2;
return;
}
z = 1;
if (kill(getpid(), SIGHUP) != 0) e(1);
while (y != 2);
y = 1;
}
void test37d()
{
struct sigaction act;
subtest = 4;
clearsigstate();
y = 0;
z = 0;
act.sa_handler = catch3;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_NODEFER; /* Otherwise, nested occurence of
* SIGINT is blocked. */
if (sigaction(SIGHUP, &act, (struct sigaction *) NULL) != 0) e(2);
if (kill(getpid(), SIGHUP) != 0) e(3);
if (y != 1) e(4);
}
/*---------------------------------------------------------------------------*/
/* Test that the signal mask in effect for the duration of a signal handler
* is as specified in POSIX Section 3, lines 718 -724. Test that the
* previous signal mask is restored when the signal handler returns.
*/
void catch4(signo)
int signo;
{
sigset_t oset;
sigset_t set;
if (sigemptyset(&set) == -1) e(5001);
if (sigaddset(&set, SIGTERM) == -1) e(5002);
if (sigaddset(&set, SIGHUP) == -1) e(5003);
if (sigaddset(&set, SIGINT) == -1) e(5004);
if (sigaddset(&set, SIGPIPE) == -1) e(5005);
if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset) != 0) e(5006);
if (sigmemcmp(&oset, &set, sizeof(set))) e(5007);
}
void test37e()
{
struct sigaction act, oact;
sigset_t set, oset;
subtest = 5;
clearsigstate();
act.sa_handler = catch4;
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask, SIGTERM);
sigaddset(&act.sa_mask, SIGHUP);
act.sa_flags = 0;
if (sigaction(SIGINT, &act, &oact) == -1) e(2);
if (sigemptyset(&set) == -1) e(3);
if (sigaddset(&set, SIGPIPE) == -1) e(4);
if (sigprocmask(SIG_SETMASK, &set, &oset) == -1) e(5);
if (kill(getpid(), SIGINT) == -1) e(6);
if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &oset) == -1) e(7);
if (sigemptyset(&set) == -1) e(8);
if (sigaddset(&set, SIGPIPE) == -1) e(9);
if (sigmemcmp(&set, &oset, sizeof(set))) e(10);
}
/*---------------------------------------------------------------------------*/
/* Test the basic functionality of sigsuspend(2). */
void catch5(signo)
int signo;
{
x = 1;
}
void test37f()
{
sigset_t set;
int r;
struct sigaction act;
pid_t pid;
subtest = 6;
clearsigstate();
switch (pid = fork()) {
case 0: /* child */
errct = 0;
sleep(1);
if (kill(getppid(), SIGINT) == -1) e(1);
exit(errct == 0 ? 0 : 1);
case -1: e(2); break;
default: /* parent */
if (sigemptyset(&act.sa_mask) == -1) e(3);
act.sa_flags = 0;
act.sa_handler = catch5;
if (sigaction(SIGINT, &act, (struct sigaction *) NULL) == -1) e(4);
if (sigemptyset(&set) == -1) e(5);
r = sigsuspend(&set);
if (r != -1 || errno != EINTR || x != 1) e(6);
wait_for(pid);
break;
}
}
/*----------------------------------------------------------------------*/
/* Test that sigsuspend() does block the signals specified in its
* argument, and after sigsuspend returns, the previous signal
* mask is restored.
*
* The child sends two signals to the parent SIGINT and then SIGPIPE,
* separated by a long delay. The parent executes sigsuspend() with
* SIGINT blocked. It is expected that the parent's SIGPIPE handler
* will be invoked, then sigsuspend will return restoring the
* original signal mask, and then the SIGPIPE handler will be
* invoked.
*/
void sigint_handler(signo)
int signo;
{
x = 1;
z++;
}
void sigpipe_handler(signo)
int signo;
{
x = 2;
z++;
}
void test37g()
{
sigset_t set;
int r;
struct sigaction act;
pid_t pid;
subtest = 7;
clearsigstate();
x = 0;
z = 0;
switch (pid = fork()) {
case 0: /* child */
errct = 0;
sleep(1);
if (kill(getppid(), SIGINT) == -1) e(1);
sleep(1);
if (kill(getppid(), SIGPIPE) == -1) e(2);
exit(errct == 0 ? 0 : 1);
case -1: e(3); break;
default: /* parent */
if (sigemptyset(&act.sa_mask) == -1) e(3);
act.sa_flags = 0;
act.sa_handler = sigint_handler;
if (sigaction(SIGINT, &act, (struct sigaction *) NULL) == -1) e(4);
act.sa_handler = sigpipe_handler;
if (sigaction(SIGPIPE, &act, (struct sigaction *) NULL) == -1) e(5);
if (sigemptyset(&set) == -1) e(6);
if (sigaddset(&set, SIGINT) == -1) e(7);
r = sigsuspend(&set);
if (r != -1) e(8);
if (errno != EINTR) e(9);
if (z != 2) e(10);
if (x != 1) e(11);
wait_for(pid);
break;
}
}
/*--------------------------------------------------------------------------*/
/* Test that sigsuspend() does block the signals specified in its
* argument, and after sigsuspend returns, the previous signal
* mask is restored.
*
* The child sends three signals to the parent: SIGHUP, then SIGPIPE,
* and then SIGTERM, separated by a long delay. The parent executes
* sigsuspend() with SIGHUP and SIGPIPE blocked. It is expected that
* the parent's SIGTERM handler will be invoked first, then sigsuspend()
* will return restoring the original signal mask, and then the other
* two handlers will be invoked.
*/
void sighup8(signo)
int signo;
{
x = 1;
z++;
}
void sigpip8(signo)
int signo;
{
x = 1;
z++;
}
void sigter8(signo)
int signo;
{
x = 2;
z++;
}
void test37h()
{
sigset_t set;
int r;
struct sigaction act;
pid_t pid;
subtest = 8;
clearsigstate();
x = 0;
z = 0;
switch (pid = fork()) {
case 0: /* child */
errct = 0;
sleep(1);
if (kill(getppid(), SIGHUP) == -1) e(1);
sleep(1);
if (kill(getppid(), SIGPIPE) == -1) e(2);
sleep(1);
if (kill(getppid(), SIGTERM) == -1) e(3);
exit(errct == 0 ? 0 : 1);
case -1: e(5); break;
default: /* parent */
if (sigemptyset(&act.sa_mask) == -1) e(6);
act.sa_flags = 0;
act.sa_handler = sighup8;
if (sigaction(SIGHUP, &act, (struct sigaction *) NULL) == -1) e(7);
act.sa_handler = sigpip8;
if (sigaction(SIGPIPE, &act, (struct sigaction *) NULL) == -1) e(8);
act.sa_handler = sigter8;
if (sigaction(SIGTERM, &act, (struct sigaction *) NULL) == -1) e(9);
if (sigemptyset(&set) == -1) e(10);
if (sigaddset(&set, SIGHUP) == -1) e(11);
if (sigaddset(&set, SIGPIPE) == -1) e(12);
r = sigsuspend(&set);
if (r != -1) e(13);
if (errno != EINTR) e(14);
if (z != 3) e(15);
if (x != 1) e(16);
wait_for(pid);
break;
}
}
/*--------------------------------------------------------------------------*/
/* Block SIGHUP and SIGTERM with sigprocmask(), send ourself SIGHUP
* and SIGTERM, unblock these signals with sigprocmask, and verify
* that these signals are delivered.
*/
void sighup9(signo)
int signo;
{
y++;
}
void sigter9(signo)
int signo;
{
z++;
}
void test37i()
{
sigset_t set;
struct sigaction act;
subtest = 9;
clearsigstate();
y = 0;
z = 0;
if (sigemptyset(&act.sa_mask) == -1) e(1);
act.sa_flags = 0;
act.sa_handler = sighup9;
if (sigaction(SIGHUP, &act, (struct sigaction *) NULL) == -1) e(2);
act.sa_handler = sigter9;
if (sigaction(SIGTERM, &act, (struct sigaction *) NULL) == -1) e(3);
if (sigemptyset(&set) == -1) e(4);
if (sigaddset(&set, SIGTERM) == -1) e(5);
if (sigaddset(&set, SIGHUP) == -1) e(6);
if (sigprocmask(SIG_SETMASK, &set, (sigset_t *)NULL) == -1) e(7);
if (kill(getpid(), SIGHUP) == -1) e(8);
if (kill(getpid(), SIGTERM) == -1) e(9);
if (y != 0) e(10);
if (z != 0) e(11);
if (sigemptyset(&set) == -1) e(12);
if (sigprocmask(SIG_SETMASK, &set, (sigset_t *)NULL) == -1) e(12);
if (y != 1) e(13);
if (z != 1) e(14);
}
/*---------------------------------------------------------------------------*/
/* Block SIGINT and then send this signal to ourself.
*
* Install signal handlers for SIGALRM and SIGINT.
*
* Set an alarm for 6 seconds, then sleep for 7.
*
* The SIGALRM should interrupt the sleep, but the SIGINT
* should remain pending.
*/
void sighup10(signo)
int signo;
{
y++;
}
void sigalrm_handler10(signo)
int signo;
{
z++;
}
void test37j()
{
sigset_t set, set2;
struct sigaction act;
subtest = 10;
clearsigstate();
y = 0;
z = 0;
if (sigemptyset(&act.sa_mask) == -1) e(1);
act.sa_flags = 0;
act.sa_handler = sighup10;
if (sigaction(SIGHUP, &act, (struct sigaction *) NULL) == -1) e(2);
act.sa_handler = sigalrm_handler10;
if (sigaction(SIGALRM, &act, (struct sigaction *) NULL) == -1) e(3);
if (sigemptyset(&set) == -1) e(4);
if (sigaddset(&set, SIGHUP) == -1) e(5);
if (sigprocmask(SIG_SETMASK, &set, (sigset_t *)NULL) == -1) e(6);
if (kill(getpid(), SIGHUP) == -1) e(7);
if (sigpending(&set) == -1) e(8);
if (sigemptyset(&set2) == -1) e(9);
if (sigaddset(&set2, SIGHUP) == -1) e(10);
if (sigmemcmp(&set2, &set, sizeof(set))) e(11);
alarm(6);
sleep(7);
if (sigpending(&set) == -1) e(12);
if (sigmemcmp(&set, &set2, sizeof(set))) e(13);
if (y != 0) e(14);
if (z != 1) e(15);
}
/*--------------------------------------------------------------------------*/
void test37k()
{
subtest = 11;
}
void test37l()
{
subtest = 12;
}
/*---------------------------------------------------------------------------*/
/* Basic test for setjmp/longjmp. This includes testing that the
* signal mask is properly restored.
*/
#define TEST_SETJMP(_name, _subtest, _type, _setjmp, _longjmp, _save) \
void _name(void) \
{ \
_type jb; \
sigset_t ss, ss2, ss_orig; \
\
subtest = _subtest; \
clearsigstate(); \
\
sigemptyset(&ss); sigemptyset(&ss2); \
sigaddset(&ss, 2); sigaddset(&ss, 4); sigaddset(&ss, 5); \
sigaddset(&ss2, 20); sigaddset(&ss2, 22); sigaddset(&ss2, 65); \
memcpy(&ss_orig, &ss, sizeof(ss)); \
if (sigprocmask(SIG_SETMASK, &ss, (sigset_t *)NULL) == -1) e(1); \
if (_setjmp) { \
sigset_t ssexp; \
if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &ss) == -1) e(2); \
ssexp = _save ? ss_orig : ss2; \
sigdelset(&ssexp, SIGKILL); \
if (sigmemcmp(&ss, &ssexp, sizeof(ss))) e(388); \
return; \
} \
ss = ss2; \
if (sigprocmask(SIG_SETMASK, &ss, (sigset_t *)NULL) == -1) e(4); \
_longjmp; \
}
TEST_SETJMP(test37m, 13, jmp_buf, setjmp(jb), longjmp(jb, 1), 1)
TEST_SETJMP(test37p, 16, sigjmp_buf, sigsetjmp(jb, 0), siglongjmp(jb, 1), 0)
TEST_SETJMP(test37q, 17, sigjmp_buf, sigsetjmp(jb, 1), siglongjmp(jb, 1), 1)
void longjerr()
{
e(5);
}
/*--------------------------------------------------------------------------*/
/* Test for setjmp/longjmp.
*
* Catch a signal. While in signal handler do setjmp/longjmp.
*/
void catch14(signo, code, scp)
int signo;
int code;
struct sigcontext *scp;
{
jmp_buf jb;
if (setjmp(jb)) {
x++;
sigreturn(scp);
e(1);
}
y++;
longjmp(jb, 1);
e(2);
}
void test37n()
{
struct sigaction act;
typedef void(*sighandler_t) (int sig);
subtest = 14;
clearsigstate();
x = 0;
y = 0;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
act.sa_handler = (sighandler_t) catch14; /* fudge */
if (sigaction(SIGSEGV, &act, (struct sigaction *) NULL) == -1) e(3);
if (kill(getpid(), SIGSEGV) == -1) e(4);
if (x != 1) e(5);
if (y != 1) e(6);
}
/*---------------------------------------------------------------------------*/
/* Test for setjmp/longjmp.
*
* Catch a signal. Longjmp out of signal handler.
*/
jmp_buf glo_jb;
void catch15(signo)
int signo;
{
z++;
longjmp(glo_jb, 7);
e(1);
}
void test37o()
{
struct sigaction act;
int k;
0