blob: 5a23b96bfcf15669b105b2414ef5db29f246d3f5 [file] [log] [blame]
Elliott Hughes04303f52014-09-18 16:11:59 -07001/*
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 <gtest/gtest.h>
21#include <limits.h>
22#include <pthread.h>
23#include <time.h>
24#include <unistd.h>
25
26#include "private/bionic_constants.h"
Elliott Hughes71ba5892018-02-07 12:44:45 -080027#include "SignalUtils.h"
Elliott Hughes04303f52014-09-18 16:11:59 -070028
29TEST(semaphore, sem_init) {
30 sem_t s;
31
32 // Perfectly fine initial values.
33 ASSERT_EQ(0, sem_init(&s, 0, 0));
34 ASSERT_EQ(0, sem_init(&s, 0, 1));
35 ASSERT_EQ(0, sem_init(&s, 0, 123));
36
37 // Too small an initial value.
38 errno = 0;
39 ASSERT_EQ(-1, sem_init(&s, 0, -1));
40 ASSERT_EQ(EINVAL, errno);
41
42 ASSERT_EQ(SEM_VALUE_MAX, sysconf(_SC_SEM_VALUE_MAX));
43
44 // The largest initial value.
45 ASSERT_EQ(0, sem_init(&s, 0, SEM_VALUE_MAX));
46
47 // Too large an initial value.
48 errno = 0;
49 ASSERT_EQ(-1, sem_init(&s, 0, SEM_VALUE_MAX + 1));
50 ASSERT_EQ(EINVAL, errno);
51
52 ASSERT_EQ(0, sem_destroy(&s));
53}
54
55TEST(semaphore, sem_trywait) {
56 sem_t s;
57 ASSERT_EQ(0, sem_init(&s, 0, 3));
58 ASSERT_EQ(0, sem_trywait(&s));
59 ASSERT_EQ(0, sem_trywait(&s));
60 ASSERT_EQ(0, sem_trywait(&s));
61 errno = 0;
62 ASSERT_EQ(-1, sem_trywait(&s));
63 ASSERT_EQ(EAGAIN, errno);
64 ASSERT_EQ(0, sem_destroy(&s));
65}
66
67static void SemWaitThreadTestFn(sem_t& sem) {
68 ASSERT_EQ(0, sem_wait(&sem));
69}
70
71static void* SemWaitThreadFn(void* arg) {
72 SemWaitThreadTestFn(*reinterpret_cast<sem_t*>(arg));
73 return nullptr;
74}
75
76TEST(semaphore, sem_wait__sem_post) {
77 sem_t s;
78 ASSERT_EQ(0, sem_init(&s, 0, 0));
79
80 pthread_t t1, t2, t3;
Yi Kong32bc0fc2018-08-02 17:31:13 -070081 ASSERT_EQ(0, pthread_create(&t1, nullptr, SemWaitThreadFn, &s));
82 ASSERT_EQ(0, pthread_create(&t2, nullptr, SemWaitThreadFn, &s));
83 ASSERT_EQ(0, pthread_create(&t3, nullptr, SemWaitThreadFn, &s));
Elliott Hughes04303f52014-09-18 16:11:59 -070084
85 ASSERT_EQ(0, sem_post(&s));
86 ASSERT_EQ(0, sem_post(&s));
87 ASSERT_EQ(0, sem_post(&s));
88
89 void* result;
90 ASSERT_EQ(0, pthread_join(t1, &result));
91 ASSERT_EQ(0, pthread_join(t2, &result));
92 ASSERT_EQ(0, pthread_join(t3, &result));
93}
94
95static inline void timespec_add_ms(timespec& ts, size_t ms) {
96 ts.tv_sec += ms / 1000;
97 ts.tv_nsec += (ms % 1000) * 1000000;
98 if (ts.tv_nsec >= NS_PER_S) {
99 ts.tv_sec++;
100 ts.tv_nsec -= NS_PER_S;
101 }
102}
103
Tom Cherryc6b5bcd2018-03-05 14:14:44 -0800104static void sem_timedwait_helper(clockid_t clock,
105 int (*wait_function)(sem_t* __sem, const timespec* __ts)) {
Elliott Hughes04303f52014-09-18 16:11:59 -0700106 sem_t s;
107 ASSERT_EQ(0, sem_init(&s, 0, 0));
108
109 timespec ts;
Tom Cherryc6b5bcd2018-03-05 14:14:44 -0800110 ASSERT_EQ(0, clock_gettime(clock, &ts));
Elliott Hughes04303f52014-09-18 16:11:59 -0700111 timespec_add_ms(ts, 100);
112
113 errno = 0;
Tom Cherryc6b5bcd2018-03-05 14:14:44 -0800114 ASSERT_EQ(-1, wait_function(&s, &ts));
Elliott Hughes04303f52014-09-18 16:11:59 -0700115 ASSERT_EQ(ETIMEDOUT, errno);
116
117 // A negative timeout is an error.
118 errno = 0;
119 ts.tv_nsec = -1;
Tom Cherryc6b5bcd2018-03-05 14:14:44 -0800120 ASSERT_EQ(-1, wait_function(&s, &ts));
Elliott Hughes04303f52014-09-18 16:11:59 -0700121 ASSERT_EQ(EINVAL, errno);
Yabin Cuic9a659c2015-11-05 15:36:08 -0800122 errno = 0;
123 ts.tv_nsec = NS_PER_S;
Tom Cherryc6b5bcd2018-03-05 14:14:44 -0800124 ASSERT_EQ(-1, wait_function(&s, &ts));
Yabin Cuic9a659c2015-11-05 15:36:08 -0800125 ASSERT_EQ(EINVAL, errno);
126
127 errno = 0;
128 ts.tv_nsec = NS_PER_S - 1;
129 ts.tv_sec = -1;
Tom Cherryc6b5bcd2018-03-05 14:14:44 -0800130 ASSERT_EQ(-1, wait_function(&s, &ts));
Yabin Cuic9a659c2015-11-05 15:36:08 -0800131 ASSERT_EQ(ETIMEDOUT, errno);
Elliott Hughes04303f52014-09-18 16:11:59 -0700132
133 ASSERT_EQ(0, sem_destroy(&s));
134}
135
Tom Cherryc6b5bcd2018-03-05 14:14:44 -0800136TEST(semaphore, sem_timedwait) {
137 sem_timedwait_helper(CLOCK_REALTIME, sem_timedwait);
138}
139
140TEST(semaphore, sem_timedwait_monotonic_np) {
141#if defined(__BIONIC__)
142 sem_timedwait_helper(CLOCK_MONOTONIC, sem_timedwait_monotonic_np);
143#else // __BIONIC__
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800144 GTEST_SKIP() << "sem_timedwait_monotonic_np is only supported on bionic";
Tom Cherryc6b5bcd2018-03-05 14:14:44 -0800145#endif // __BIONIC__
146}
147
Tom Cherry69010802019-05-07 20:33:05 -0700148TEST(semaphore, sem_clockwait) {
149#if defined(__BIONIC__)
150 sem_timedwait_helper(CLOCK_MONOTONIC, [](sem_t* __sem, const timespec* __ts) {
151 return sem_clockwait(__sem, CLOCK_MONOTONIC, __ts);
152 });
153 sem_timedwait_helper(CLOCK_REALTIME, [](sem_t* __sem, const timespec* __ts) {
154 return sem_clockwait(__sem, CLOCK_REALTIME, __ts);
155 });
156#else // __BIONIC__
157 GTEST_SKIP() << "sem_clockwait is only supported on bionic";
158#endif // __BIONIC__
159}
160
Elliott Hughesdd586f22015-12-16 15:15:58 -0800161TEST(semaphore_DeathTest, sem_timedwait_null_timeout) {
162 sem_t s;
163 ASSERT_EQ(0, sem_init(&s, 0, 0));
164
165 ASSERT_EXIT(sem_timedwait(&s, nullptr), testing::KilledBySignal(SIGSEGV), "");
166}
167
Elliott Hughes04303f52014-09-18 16:11:59 -0700168TEST(semaphore, sem_getvalue) {
169 sem_t s;
170 ASSERT_EQ(0, sem_init(&s, 0, 0));
171
172 int i;
173 ASSERT_EQ(0, sem_getvalue(&s, &i));
174 ASSERT_EQ(0, i);
175
176 ASSERT_EQ(0, sem_post(&s));
177 ASSERT_EQ(0, sem_getvalue(&s, &i));
178 ASSERT_EQ(1, i);
179
180 ASSERT_EQ(0, sem_post(&s));
181 ASSERT_EQ(0, sem_getvalue(&s, &i));
182 ASSERT_EQ(2, i);
183
184 ASSERT_EQ(0, sem_wait(&s));
185 ASSERT_EQ(0, sem_getvalue(&s, &i));
186 ASSERT_EQ(1, i);
187}
Yabin Cuica482742016-01-25 17:38:44 -0800188
Elliott Hughesff1428a2018-11-12 16:01:37 -0800189extern "C" void android_set_application_target_sdk_version(int target);
Yabin Cuica482742016-01-25 17:38:44 -0800190
191static void sem_wait_test_signal_handler(int) {
192}
193
194static void* SemWaitEINTRThreadFn(void* arg) {
195 sem_t* sem = reinterpret_cast<sem_t*>(arg);
196 uintptr_t have_eintr = 0;
197 uintptr_t have_error = 0;
198 while (true) {
199 int result = sem_wait(sem);
200 if (result == 0) {
201 break;
202 }
203 if (result == -1) {
204 if (errno == EINTR) {
205 have_eintr = 1;
206 } else {
207 have_error = 1;
208 break;
209 }
210 }
211 }
212 return reinterpret_cast<void*>((have_eintr << 1) | have_error);
213}
214
215TEST(semaphore, sem_wait_no_EINTR_in_sdk_less_equal_than_23) {
216#if defined(__BIONIC__)
Elliott Hughes5bc78c82016-11-16 11:35:43 -0800217 android_set_application_target_sdk_version(__ANDROID_API_M__);
Yabin Cuica482742016-01-25 17:38:44 -0800218 sem_t s;
219 ASSERT_EQ(0, sem_init(&s, 0, 0));
220 ScopedSignalHandler handler(SIGUSR1, sem_wait_test_signal_handler);
221 pthread_t thread;
222 ASSERT_EQ(0, pthread_create(&thread, nullptr, SemWaitEINTRThreadFn, &s));
223 // Give some time for the thread to run sem_wait.
224 usleep(500000);
225 ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
226 // Give some time for the thread to handle signal.
227 usleep(500000);
228 ASSERT_EQ(0, sem_post(&s));
229 void* result;
230 ASSERT_EQ(0, pthread_join(thread, &result));
231 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(result));
232#else
Elliott Hughesbcaa4542019-03-08 15:20:23 -0800233 GTEST_SKIP() << "This test tests sem_wait's compatibility for old sdk versions";
Yabin Cuica482742016-01-25 17:38:44 -0800234#endif
235}
236
237TEST(semaphore, sem_wait_EINTR_in_sdk_greater_than_23) {
238#if defined(__BIONIC__)
239 android_set_application_target_sdk_version(24U);
240#endif
241 sem_t s;
242 ASSERT_EQ(0, sem_init(&s, 0, 0));
243 ScopedSignalHandler handler(SIGUSR1, sem_wait_test_signal_handler);
244 pthread_t thread;
245 ASSERT_EQ(0, pthread_create(&thread, nullptr, SemWaitEINTRThreadFn, &s));
246 // Give some time for the thread to run sem_wait.
247 usleep(500000);
248 ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
249 // Give some time for the thread to handle signal.
250 usleep(500000);
251 ASSERT_EQ(0, sem_post(&s));
252 void* result;
253 ASSERT_EQ(0, pthread_join(thread, &result));
254 ASSERT_EQ(2U, reinterpret_cast<uintptr_t>(result));
255}