1 /*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <semaphore.h>
18
19 #include <errno.h>
20 #include <limits.h>
21 #include <pthread.h>
22 #include <time.h>
23 #include <unistd.h>
24
25 #include <android-base/silent_death_test.h>
26 #include <gtest/gtest.h>
27
28 #include "SignalUtils.h"
29 #include "private/bionic_constants.h"
30
31 using semaphore_DeathTest = SilentDeathTest;
32
TEST(semaphore,sem_init)33 TEST(semaphore, sem_init) {
34 sem_t s;
35
36 // Perfectly fine initial values.
37 ASSERT_EQ(0, sem_init(&s, 0, 0));
38 ASSERT_EQ(0, sem_init(&s, 0, 1));
39 ASSERT_EQ(0, sem_init(&s, 0, 123));
40
41 // Too small an initial value.
42 errno = 0;
43 ASSERT_EQ(-1, sem_init(&s, 0, -1));
44 ASSERT_EQ(EINVAL, errno);
45
46 ASSERT_EQ(SEM_VALUE_MAX, sysconf(_SC_SEM_VALUE_MAX));
47
48 // The largest initial value.
49 ASSERT_EQ(0, sem_init(&s, 0, SEM_VALUE_MAX));
50
51 // Too large an initial value.
52 errno = 0;
53 ASSERT_EQ(-1, sem_init(&s, 0, SEM_VALUE_MAX + 1));
54 ASSERT_EQ(EINVAL, errno);
55
56 ASSERT_EQ(0, sem_destroy(&s));
57 }
58
TEST(semaphore,sem_trywait)59 TEST(semaphore, sem_trywait) {
60 sem_t s;
61 ASSERT_EQ(0, sem_init(&s, 0, 3));
62 ASSERT_EQ(0, sem_trywait(&s));
63 ASSERT_EQ(0, sem_trywait(&s));
64 ASSERT_EQ(0, sem_trywait(&s));
65 errno = 0;
66 ASSERT_EQ(-1, sem_trywait(&s));
67 ASSERT_EQ(EAGAIN, errno);
68 ASSERT_EQ(0, sem_destroy(&s));
69 }
70
SemWaitThreadTestFn(sem_t & sem)71 static void SemWaitThreadTestFn(sem_t& sem) {
72 ASSERT_EQ(0, sem_wait(&sem));
73 }
74
SemWaitThreadFn(void * arg)75 static void* SemWaitThreadFn(void* arg) {
76 SemWaitThreadTestFn(*reinterpret_cast<sem_t*>(arg));
77 return nullptr;
78 }
79
TEST(semaphore,sem_wait__sem_post)80 TEST(semaphore, sem_wait__sem_post) {
81 sem_t s;
82 ASSERT_EQ(0, sem_init(&s, 0, 0));
83
84 pthread_t t1, t2, t3;
85 ASSERT_EQ(0, pthread_create(&t1, nullptr, SemWaitThreadFn, &s));
86 ASSERT_EQ(0, pthread_create(&t2, nullptr, SemWaitThreadFn, &s));
87 ASSERT_EQ(0, pthread_create(&t3, nullptr, SemWaitThreadFn, &s));
88
89 ASSERT_EQ(0, sem_post(&s));
90 ASSERT_EQ(0, sem_post(&s));
91 ASSERT_EQ(0, sem_post(&s));
92
93 void* result;
94 ASSERT_EQ(0, pthread_join(t1, &result));
95 ASSERT_EQ(0, pthread_join(t2, &result));
96 ASSERT_EQ(0, pthread_join(t3, &result));
97 }
98
timespec_add_ms(timespec & ts,size_t ms)99 static inline void timespec_add_ms(timespec& ts, size_t ms) {
100 ts.tv_sec += ms / 1000;
101 ts.tv_nsec += (ms % 1000) * 1000000;
102 if (ts.tv_nsec >= NS_PER_S) {
103 ts.tv_sec++;
104 ts.tv_nsec -= NS_PER_S;
105 }
106 }
107
sem_timedwait_helper(clockid_t clock,int (* wait_function)(sem_t * __sem,const timespec * __ts))108 static void sem_timedwait_helper(clockid_t clock,
109 int (*wait_function)(sem_t* __sem, const timespec* __ts)) {
110 sem_t s;
111 ASSERT_EQ(0, sem_init(&s, 0, 0));
112
113 timespec ts;
114 ASSERT_EQ(0, clock_gettime(clock, &ts));
115 timespec_add_ms(ts, 100);
116
117 errno = 0;
118 ASSERT_EQ(-1, wait_function(&s, &ts));
119 ASSERT_EQ(ETIMEDOUT, errno);
120
121 // A negative timeout is an error.
122 errno = 0;
123 ts.tv_nsec = -1;
124 ASSERT_EQ(-1, wait_function(&s, &ts));
125 ASSERT_EQ(EINVAL, errno);
126 errno = 0;
127 ts.tv_nsec = NS_PER_S;
128 ASSERT_EQ(-1, wait_function(&s, &ts));
129 ASSERT_EQ(EINVAL, errno);
130
131 errno = 0;
132 ts.tv_nsec = NS_PER_S - 1;
133 ts.tv_sec = -1;
134 ASSERT_EQ(-1, wait_function(&s, &ts));
135 ASSERT_EQ(ETIMEDOUT, errno);
136
137 ASSERT_EQ(0, sem_destroy(&s));
138 }
139
TEST(semaphore,sem_timedwait)140 TEST(semaphore, sem_timedwait) {
141 sem_timedwait_helper(CLOCK_REALTIME, sem_timedwait);
142 }
143
TEST(semaphore,sem_timedwait_monotonic_np)144 TEST(semaphore, sem_timedwait_monotonic_np) {
145 #if defined(__BIONIC__)
146 sem_timedwait_helper(CLOCK_MONOTONIC, sem_timedwait_monotonic_np);
147 #else // __BIONIC__
148 GTEST_SKIP() << "sem_timedwait_monotonic_np is only supported on bionic";
149 #endif // __BIONIC__
150 }
151
TEST(semaphore,sem_clockwait)152 TEST(semaphore, sem_clockwait) {
153 #if defined(__BIONIC__)
154 sem_timedwait_helper(CLOCK_MONOTONIC, [](sem_t* __sem, const timespec* __ts) {
155 return sem_clockwait(__sem, CLOCK_MONOTONIC, __ts);
156 });
157 sem_timedwait_helper(CLOCK_REALTIME, [](sem_t* __sem, const timespec* __ts) {
158 return sem_clockwait(__sem, CLOCK_REALTIME, __ts);
159 });
160 #else // __BIONIC__
161 GTEST_SKIP() << "sem_clockwait is only supported on bionic";
162 #endif // __BIONIC__
163 }
164
TEST_F(semaphore_DeathTest,sem_timedwait_null_timeout)165 TEST_F(semaphore_DeathTest, sem_timedwait_null_timeout) {
166 sem_t s;
167 ASSERT_EQ(0, sem_init(&s, 0, 0));
168 #pragma clang diagnostic push
169 #pragma clang diagnostic ignored "-Wnonnull"
170 ASSERT_EXIT(sem_timedwait(&s, nullptr), testing::KilledBySignal(SIGSEGV), "");
171 #pragma clang diagnostic pop
172 }
173
TEST(semaphore,sem_getvalue)174 TEST(semaphore, sem_getvalue) {
175 sem_t s;
176 ASSERT_EQ(0, sem_init(&s, 0, 0));
177
178 int i;
179 ASSERT_EQ(0, sem_getvalue(&s, &i));
180 ASSERT_EQ(0, i);
181
182 ASSERT_EQ(0, sem_post(&s));
183 ASSERT_EQ(0, sem_getvalue(&s, &i));
184 ASSERT_EQ(1, i);
185
186 ASSERT_EQ(0, sem_post(&s));
187 ASSERT_EQ(0, sem_getvalue(&s, &i));
188 ASSERT_EQ(2, i);
189
190 ASSERT_EQ(0, sem_wait(&s));
191 ASSERT_EQ(0, sem_getvalue(&s, &i));
192 ASSERT_EQ(1, i);
193 }
194
195 extern "C" void android_set_application_target_sdk_version(int target);
196
sem_wait_test_signal_handler(int)197 static void sem_wait_test_signal_handler(int) {
198 }
199
SemWaitEINTRThreadFn(void * arg)200 static void* SemWaitEINTRThreadFn(void* arg) {
201 sem_t* sem = reinterpret_cast<sem_t*>(arg);
202 uintptr_t have_eintr = 0;
203 uintptr_t have_error = 0;
204 while (true) {
205 int result = sem_wait(sem);
206 if (result == 0) {
207 break;
208 }
209 if (result == -1) {
210 if (errno == EINTR) {
211 have_eintr = 1;
212 } else {
213 have_error = 1;
214 break;
215 }
216 }
217 }
218 return reinterpret_cast<void*>((have_eintr << 1) | have_error);
219 }
220
TEST(semaphore,sem_wait_no_EINTR_in_sdk_less_equal_than_23)221 TEST(semaphore, sem_wait_no_EINTR_in_sdk_less_equal_than_23) {
222 #if defined(__BIONIC__)
223 android_set_application_target_sdk_version(23);
224 sem_t s;
225 ASSERT_EQ(0, sem_init(&s, 0, 0));
226 ScopedSignalHandler handler(SIGUSR1, sem_wait_test_signal_handler);
227 pthread_t thread;
228 ASSERT_EQ(0, pthread_create(&thread, nullptr, SemWaitEINTRThreadFn, &s));
229 // Give some time for the thread to run sem_wait.
230 usleep(500000);
231 ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
232 // Give some time for the thread to handle signal.
233 usleep(500000);
234 ASSERT_EQ(0, sem_post(&s));
235 void* result;
236 ASSERT_EQ(0, pthread_join(thread, &result));
237 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(result));
238 #else
239 GTEST_SKIP() << "This test tests sem_wait's compatibility for old sdk versions";
240 #endif
241 }
242
TEST(semaphore,sem_wait_EINTR_in_sdk_greater_than_23)243 TEST(semaphore, sem_wait_EINTR_in_sdk_greater_than_23) {
244 #if defined(__BIONIC__)
245 android_set_application_target_sdk_version(24U);
246 #endif
247 sem_t s;
248 ASSERT_EQ(0, sem_init(&s, 0, 0));
249 ScopedSignalHandler handler(SIGUSR1, sem_wait_test_signal_handler);
250 pthread_t thread;
251 ASSERT_EQ(0, pthread_create(&thread, nullptr, SemWaitEINTRThreadFn, &s));
252 // Give some time for the thread to run sem_wait.
253 usleep(500000);
254 ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
255 // Give some time for the thread to handle signal.
256 usleep(500000);
257 ASSERT_EQ(0, sem_post(&s));
258 void* result;
259 ASSERT_EQ(0, pthread_join(thread, &result));
260 ASSERT_EQ(2U, reinterpret_cast<uintptr_t>(result));
261 }
262