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 <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"
27 #include "SignalUtils.h"
28 
TEST(semaphore,sem_init)29 TEST(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 
TEST(semaphore,sem_trywait)55 TEST(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 
SemWaitThreadTestFn(sem_t & sem)67 static void SemWaitThreadTestFn(sem_t& sem) {
68   ASSERT_EQ(0, sem_wait(&sem));
69 }
70 
SemWaitThreadFn(void * arg)71 static void* SemWaitThreadFn(void* arg) {
72   SemWaitThreadTestFn(*reinterpret_cast<sem_t*>(arg));
73   return nullptr;
74 }
75 
TEST(semaphore,sem_wait__sem_post)76 TEST(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;
81   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));
84 
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 
timespec_add_ms(timespec & ts,size_t ms)95 static 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 
sem_timedwait_helper(clockid_t clock,int (* wait_function)(sem_t * __sem,const timespec * __ts))104 static void sem_timedwait_helper(clockid_t clock,
105                                  int (*wait_function)(sem_t* __sem, const timespec* __ts)) {
106   sem_t s;
107   ASSERT_EQ(0, sem_init(&s, 0, 0));
108 
109   timespec ts;
110   ASSERT_EQ(0, clock_gettime(clock, &ts));
111   timespec_add_ms(ts, 100);
112 
113   errno = 0;
114   ASSERT_EQ(-1, wait_function(&s, &ts));
115   ASSERT_EQ(ETIMEDOUT, errno);
116 
117   // A negative timeout is an error.
118   errno = 0;
119   ts.tv_nsec = -1;
120   ASSERT_EQ(-1, wait_function(&s, &ts));
121   ASSERT_EQ(EINVAL, errno);
122   errno = 0;
123   ts.tv_nsec = NS_PER_S;
124   ASSERT_EQ(-1, wait_function(&s, &ts));
125   ASSERT_EQ(EINVAL, errno);
126 
127   errno = 0;
128   ts.tv_nsec = NS_PER_S - 1;
129   ts.tv_sec = -1;
130   ASSERT_EQ(-1, wait_function(&s, &ts));
131   ASSERT_EQ(ETIMEDOUT, errno);
132 
133   ASSERT_EQ(0, sem_destroy(&s));
134 }
135 
TEST(semaphore,sem_timedwait)136 TEST(semaphore, sem_timedwait) {
137   sem_timedwait_helper(CLOCK_REALTIME, sem_timedwait);
138 }
139 
TEST(semaphore,sem_timedwait_monotonic_np)140 TEST(semaphore, sem_timedwait_monotonic_np) {
141 #if defined(__BIONIC__)
142   sem_timedwait_helper(CLOCK_MONOTONIC, sem_timedwait_monotonic_np);
143 #else   // __BIONIC__
144   GTEST_SKIP() << "sem_timedwait_monotonic_np is only supported on bionic";
145 #endif  // __BIONIC__
146 }
147 
TEST(semaphore,sem_clockwait)148 TEST(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 
TEST(semaphore_DeathTest,sem_timedwait_null_timeout)161 TEST(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 
TEST(semaphore,sem_getvalue)168 TEST(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 }
188 
189 extern "C" void android_set_application_target_sdk_version(int target);
190 
sem_wait_test_signal_handler(int)191 static void sem_wait_test_signal_handler(int) {
192 }
193 
SemWaitEINTRThreadFn(void * arg)194 static 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 
TEST(semaphore,sem_wait_no_EINTR_in_sdk_less_equal_than_23)215 TEST(semaphore, sem_wait_no_EINTR_in_sdk_less_equal_than_23) {
216 #if defined(__BIONIC__)
217   android_set_application_target_sdk_version(23);
218   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
233   GTEST_SKIP() << "This test tests sem_wait's compatibility for old sdk versions";
234 #endif
235 }
236 
TEST(semaphore,sem_wait_EINTR_in_sdk_greater_than_23)237 TEST(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 }
256