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
53static volatile sig_atomic_t flag;
54static volatile sig_atomic_t flag2;
55
56static volatile pthread_t thr_usr1;
57static volatile pthread_t thr_usr2;
58
59static sig_atomic_t count = 0;
60
61ATF_TC(upcalls_not_started);
62ATF_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}
67ATF_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
82static void
83upcalls_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
94static void
95upcalls_not_started_handler2(int sig, siginfo_t *info, void *ctx)
96{
97	if (flag == 1)
98		flag = 2;
99}
100
101ATF_TC(before_threads);
102ATF_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}
107ATF_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
129static void
130respected_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
142static void
143respected_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
151static void *
152respected_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
171ATF_TC(respected_while_running);
172ATF_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}
177ATF_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
199static void
200incorrect_mask_bug_handler(int sig)
201{
202	count++;
203}
204
205static void *
206incorrect_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
215ATF_TC(incorrect_mask_bug);
216ATF_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}
221ATF_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
252ATF_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