1 #include <pthread.h>
2 #include <signal.h>
3 #include <darwintest.h>
4 #include <dispatch/dispatch.h>
5
6 // For BSDTHREAD_CTL_WORKQ_PRESERVE_SIGMASK
7 #define __PTHREAD_EXPOSE_INTERNALS__
8 #include <pthread/bsdthread_private.h>
9 #undef __PTHREAD_EXPOSE_INTERNALS__
10
11 extern int __bsdthread_ctl(uintptr_t cmd, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3);
12
13 T_GLOBAL_META(
14 T_META_NAMESPACE("xnu.workq"),
15 T_META_RADAR_COMPONENT_NAME("xnu"),
16 T_META_RADAR_COMPONENT_VERSION("workq"),
17 T_META_RUN_CONCURRENTLY(true));
18
19 T_DECL(invalid_allow_sigmask, "test that BSDTHREAD_CTL_WORKQ_ALLOW_SIGMASK returns EINVAL for things like SIGKILL")
20 {
21 int ret = __bsdthread_ctl(BSDTHREAD_CTL_WORKQ_ALLOW_SIGMASK, sigmask(SIGKILL), 0, 0);
22 T_ASSERT_EQ(ret, -1, "BSDTHREAD_CTL_WORKQ_ALLOW_SIGMASK should not work on prohibited signals");
23 }
24
25 static void
print_sigmask(void)26 print_sigmask(void)
27 {
28 sigset_t omask;
29 sigprocmask(0, NULL, &omask);
30 T_LOG("sigmask is %x\n", omask);
31 }
32
33
34 T_DECL(preserve_sigmask_unblock, "test that BSDTHREAD_CTL_WORKQ_ALLOW_SIGMASK preserves unblocking SIGUSR1 on a workq thread")
35 {
36 __block int ret;
37 const int sig = SIGUSR1;
38 const sigset_t mask = sigmask(sig);
39 const sigset_t expected = 0;
40
41 dispatch_queue_t q = dispatch_get_global_queue(0, 0);
42 dispatch_async(q, ^{
43 T_WITH_ERRNO;
44 ret = __bsdthread_ctl(BSDTHREAD_CTL_WORKQ_ALLOW_SIGMASK, mask, 0, 0);
45 T_ASSERT_POSIX_SUCCESS(ret, "BSDTHREAD_CTL_WORKQ_ALLOW_SIGMASK");
46
47 print_sigmask();
48
49 T_WITH_ERRNO;
50 ret = sigprocmask(SIG_UNBLOCK, &mask, NULL);
51 T_ASSERT_POSIX_SUCCESS(ret, "sigprocmask");
52
53 print_sigmask();
54
55 sigset_t omask;
56 T_WITH_ERRNO;
57 ret = sigprocmask(0, NULL, &omask);
58 T_ASSERT_POSIX_SUCCESS(ret, "sigprocmask");
59 T_ASSERT_EQ(omask & mask, expected, "Is the mask right?");
60 });
61
62 // This should park the workq, and hopefully use it again
63 dispatch_time_t sec = dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC);
64 dispatch_after(sec, q, ^{
65 print_sigmask();
66
67 sigset_t omask;
68 T_WITH_ERRNO;
69 ret = sigprocmask(0, NULL, &omask);
70 T_ASSERT_POSIX_SUCCESS(ret, "sigprocmask");
71 T_ASSERT_EQ(omask & mask, expected, "Was mask preserved across park?");
72 T_END;
73 });
74 dispatch_main();
75 }
76
77 static volatile bool handled;
78
79 static void
handler(int signum)80 handler(int signum)
81 {
82 T_ASSERT_EQ(signum, SIGUSR2, "did we get the signal we expected?");
83 handled = true;
84 }
85
86 T_DECL(sigmask_signallable, "test that a workq thread can be signalled after BSDTHREAD_CTL_WORKQ_ALLOW_SIGMASK")
87 {
88 __block int ret;
89 const int sig = SIGUSR2;
90 const sigset_t mask = sigmask(sig);
91
92 T_ASSERT_FALSE(handled, "make sure our static bool is sane");
93
94 // Set up handler
95 struct sigaction action = {
96 .sa_handler = handler,
97 };
98 ret = sigaction(sig, &action, NULL);
99 T_ASSERT_POSIX_SUCCESS(ret, "sigaction");
100
101 // Enable signal for workq threads
102 T_WITH_ERRNO;
103 ret = __bsdthread_ctl(BSDTHREAD_CTL_WORKQ_ALLOW_SIGMASK, mask, 0, 0);
104 T_ASSERT_POSIX_SUCCESS(ret, "BSDTHREAD_CTL_WORKQ_ALLOW_SIGMASK");
105
106 // Set sigmask
107 dispatch_queue_t q = dispatch_get_global_queue(0, 0);
108 dispatch_async(q, ^{
109 print_sigmask();
110
111 T_WITH_ERRNO;
112 ret = sigprocmask(SIG_UNBLOCK, &mask, NULL);
113 T_ASSERT_POSIX_SUCCESS(ret, "sigprocmask");
114
115 print_sigmask();
116 });
117
118 sleep(1);
119
120 // Get workq and signal it
121 dispatch_async(q, ^{
122 T_WITH_ERRNO;
123 ret = pthread_kill(pthread_self(), sig);
124 T_ASSERT_POSIX_SUCCESS(ret, "pthread_kill");
125 });
126
127 sleep(2);
128
129 // Check delivery
130 T_ASSERT_TRUE(handled, "signal should have been handled");
131 }
132