xref: /minix/tests/lib/libpthread/t_sigmask.c (revision 84d9c625)
1 /* $NetBSD: t_sigmask.c,v 1.3 2013/10/19 17:45:01 christos Exp $ */
2 
3 /*
4  * Copyright (c) 2008, 2010 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26  * POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 __COPYRIGHT("@(#) Copyright (c) 2008, 2010\
31  The NetBSD Foundation, inc. All rights reserved.");
32 __RCSID("$NetBSD: t_sigmask.c,v 1.3 2013/10/19 17:45:01 christos Exp $");
33 
34 /*
35  * Regression test for pthread_sigmask when SA upcalls aren't started yet.
36  *
37  * Written by Christian Limpach <cl@NetBSD.org>, December 2003.
38  * Public domain.
39  */
40 
41 #include <errno.h>
42 #include <pthread.h>
43 #include <signal.h>
44 #include <stdio.h>
45 #include <unistd.h>
46 
47 #include <sys/resource.h>
48 
49 #include <atf-c.h>
50 
51 #include "h_common.h"
52 
53 static volatile sig_atomic_t flag;
54 static volatile sig_atomic_t flag2;
55 
56 static volatile pthread_t thr_usr1;
57 static volatile pthread_t thr_usr2;
58 
59 static sig_atomic_t count = 0;
60 
61 ATF_TC(upcalls_not_started);
ATF_TC_HEAD(upcalls_not_started,tc)62 ATF_TC_HEAD(upcalls_not_started, tc)
63 {
64 	atf_tc_set_md_var(tc, "descr", "Checks pthread_sigmask when SA upcalls "
65 	    "aren't started yet");
66 }
ATF_TC_BODY(upcalls_not_started,tc)67 ATF_TC_BODY(upcalls_not_started, tc)
68 {
69 	sigset_t nset;
70 	struct rlimit rlim;
71 
72 	rlim.rlim_cur = rlim.rlim_max = 0;
73 	(void) setrlimit(RLIMIT_CORE, &rlim);
74 
75 	sigemptyset(&nset);
76 	sigaddset(&nset, SIGFPE);
77 	pthread_sigmask(SIG_BLOCK, &nset, NULL);
78 
79 	kill(getpid(), SIGFPE);
80 }
81 
82 static void
upcalls_not_started_handler1(int sig,siginfo_t * info,void * ctx)83 upcalls_not_started_handler1(int sig, siginfo_t *info, void *ctx)
84 {
85 
86 	kill(getpid(), SIGUSR2);
87 	/*
88 	 * If the mask is properly set, SIGUSR2 will not be handled
89 	 * until this handler returns.
90 	 */
91 	flag = 1;
92 }
93 
94 static void
upcalls_not_started_handler2(int sig,siginfo_t * info,void * ctx)95 upcalls_not_started_handler2(int sig, siginfo_t *info, void *ctx)
96 {
97 	if (flag == 1)
98 		flag = 2;
99 }
100 
101 ATF_TC(before_threads);
ATF_TC_HEAD(before_threads,tc)102 ATF_TC_HEAD(before_threads, tc)
103 {
104 	atf_tc_set_md_var(tc, "descr", "Checks that signal masks are respected "
105 	    "before threads are started");
106 }
ATF_TC_BODY(before_threads,tc)107 ATF_TC_BODY(before_threads, tc)
108 {
109 	struct sigaction act;
110 
111 	act.sa_sigaction = upcalls_not_started_handler1;
112 	sigemptyset(&act.sa_mask);
113 	sigaddset(&act.sa_mask, SIGUSR2);
114 	act.sa_flags = SA_SIGINFO;
115 
116 	ATF_REQUIRE_EQ(sigaction(SIGUSR1, &act, NULL), 0);
117 
118 	act.sa_sigaction = upcalls_not_started_handler2;
119 	sigemptyset(&act.sa_mask);
120 	act.sa_flags = SA_SIGINFO;
121 	(void)sigaction(SIGUSR2, &act, NULL);
122 
123 	kill(getpid(), SIGUSR1);
124 
125 	ATF_REQUIRE_EQ(flag, 2);
126 	printf("Success: Both handlers ran in order\n");
127 }
128 
129 static void
respected_while_running_handler1(int sig,siginfo_t * info,void * ctx)130 respected_while_running_handler1(int sig, siginfo_t *info, void *ctx)
131 {
132 
133 	kill(getpid(), SIGUSR2);
134 	/*
135 	 * If the mask is properly set, SIGUSR2 will not be handled
136 	 * by the current thread until this handler returns.
137 	 */
138 	flag = 1;
139 	thr_usr1 = pthread_self();
140 }
141 
142 static void
respected_while_running_handler2(int sig,siginfo_t * info,void * ctx)143 respected_while_running_handler2(int sig, siginfo_t *info, void *ctx)
144 {
145 	if (flag == 1)
146 		flag = 2;
147 	flag2 = 1;
148 	thr_usr2 = pthread_self();
149 }
150 
151 static void *
respected_while_running_threadroutine(void * arg)152 respected_while_running_threadroutine(void *arg)
153 {
154 
155 	kill(getpid(), SIGUSR1);
156 	sleep(1);
157 
158 	if (flag == 2)
159 		printf("Success: Both handlers ran in order\n");
160 	else if (flag == 1 && flag2 == 1 && thr_usr1 != thr_usr2)
161 		printf("Success: Handlers were invoked by different threads\n");
162 	else {
163 		printf("Failure: flag=%d, flag2=%d, thr1=%p, thr2=%p\n",
164 			(int)flag, (int)flag2, (void *)thr_usr1, (void *)thr_usr2);
165 		atf_tc_fail("failure");
166 	}
167 
168 	return NULL;
169 }
170 
171 ATF_TC(respected_while_running);
ATF_TC_HEAD(respected_while_running,tc)172 ATF_TC_HEAD(respected_while_running, tc)
173 {
174 	atf_tc_set_md_var(tc, "descr", "Checks that signal masks are respected "
175 	    "while threads are running");
176 }
ATF_TC_BODY(respected_while_running,tc)177 ATF_TC_BODY(respected_while_running, tc)
178 {
179 	struct sigaction act;
180 	pthread_t thread;
181 
182 	act.sa_sigaction = respected_while_running_handler1;
183 	sigemptyset(&act.sa_mask);
184 	sigaddset(&act.sa_mask, SIGUSR2);
185 	act.sa_flags = SA_SIGINFO;
186 
187 	ATF_REQUIRE_EQ(sigaction(SIGUSR1, &act, NULL), 0);
188 
189 	act.sa_sigaction = respected_while_running_handler2;
190 	sigemptyset(&act.sa_mask);
191 	act.sa_flags = SA_SIGINFO;
192 	(void)sigaction(SIGUSR2, &act, NULL);
193 
194 	PTHREAD_REQUIRE(pthread_create(&thread, NULL,
195 	    respected_while_running_threadroutine, NULL));
196 	PTHREAD_REQUIRE(pthread_join(thread, NULL));
197 }
198 
199 static void
incorrect_mask_bug_handler(int sig)200 incorrect_mask_bug_handler(int sig)
201 {
202 	count++;
203 }
204 
205 static void *
incorrect_mask_bug_sleeper(void * arg)206 incorrect_mask_bug_sleeper(void* arg)
207 {
208 	int i;
209 	for (i = 0; i < 10; i++)
210 		sleep(1);
211 
212 	atf_tc_fail("sleeper");
213 }
214 
215 ATF_TC(incorrect_mask_bug);
ATF_TC_HEAD(incorrect_mask_bug,tc)216 ATF_TC_HEAD(incorrect_mask_bug, tc)
217 {
218 	atf_tc_set_md_var(tc, "descr", "Checks for bug in libpthread where "
219 	    "incorrect signal mask was used");
220 }
ATF_TC_BODY(incorrect_mask_bug,tc)221 ATF_TC_BODY(incorrect_mask_bug, tc)
222 {
223 	pthread_t id;
224 	struct sigaction act;
225 
226 	act.sa_sigaction = NULL;
227 	sigemptyset(&act.sa_mask);
228 	act.sa_flags = 0;
229 	act.sa_handler = incorrect_mask_bug_handler;
230 
231 	ATF_REQUIRE_EQ_MSG(sigaction(SIGALRM, &act, NULL), 0, "%s",
232 	    strerror(errno));
233 
234 	sigaddset(&act.sa_mask, SIGALRM);
235 	PTHREAD_REQUIRE(pthread_sigmask(SIG_SETMASK, &act.sa_mask, NULL));
236 
237 	PTHREAD_REQUIRE(pthread_create(&id, NULL, incorrect_mask_bug_sleeper,
238 	    NULL));
239 	sleep(1);
240 
241 	sigemptyset(&act.sa_mask);
242 	PTHREAD_REQUIRE(pthread_sigmask(SIG_SETMASK, &act.sa_mask, NULL));
243 
244 	for (;;) {
245 		alarm(1);
246 		if (select(1, NULL, NULL, NULL, NULL) == -1 && errno == EINTR)
247 			if (count == 2)
248 				return;
249 	}
250 }
251 
ATF_TP_ADD_TCS(tp)252 ATF_TP_ADD_TCS(tp)
253 {
254 
255 	ATF_TP_ADD_TC(tp, upcalls_not_started);
256 	ATF_TP_ADD_TC(tp, before_threads);
257 	ATF_TP_ADD_TC(tp, respected_while_running);
258 	ATF_TP_ADD_TC(tp, incorrect_mask_bug);
259 
260 	return atf_no_error();
261 }
262