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 
169   ASSERT_EXIT(sem_timedwait(&s, nullptr), testing::KilledBySignal(SIGSEGV), "");
170 }
171 
TEST(semaphore,sem_getvalue)172 TEST(semaphore, sem_getvalue) {
173   sem_t s;
174   ASSERT_EQ(0, sem_init(&s, 0, 0));
175 
176   int i;
177   ASSERT_EQ(0, sem_getvalue(&s, &i));
178   ASSERT_EQ(0, i);
179 
180   ASSERT_EQ(0, sem_post(&s));
181   ASSERT_EQ(0, sem_getvalue(&s, &i));
182   ASSERT_EQ(1, i);
183 
184   ASSERT_EQ(0, sem_post(&s));
185   ASSERT_EQ(0, sem_getvalue(&s, &i));
186   ASSERT_EQ(2, i);
187 
188   ASSERT_EQ(0, sem_wait(&s));
189   ASSERT_EQ(0, sem_getvalue(&s, &i));
190   ASSERT_EQ(1, i);
191 }
192 
193 extern "C" void android_set_application_target_sdk_version(int target);
194 
sem_wait_test_signal_handler(int)195 static void sem_wait_test_signal_handler(int) {
196 }
197 
SemWaitEINTRThreadFn(void * arg)198 static void* SemWaitEINTRThreadFn(void* arg) {
199   sem_t* sem = reinterpret_cast<sem_t*>(arg);
200   uintptr_t have_eintr = 0;
201   uintptr_t have_error = 0;
202   while (true) {
203     int result = sem_wait(sem);
204     if (result == 0) {
205       break;
206     }
207     if (result == -1) {
208       if (errno == EINTR) {
209         have_eintr = 1;
210       } else {
211         have_error = 1;
212         break;
213       }
214     }
215   }
216   return reinterpret_cast<void*>((have_eintr << 1) | have_error);
217 }
218 
TEST(semaphore,sem_wait_no_EINTR_in_sdk_less_equal_than_23)219 TEST(semaphore, sem_wait_no_EINTR_in_sdk_less_equal_than_23) {
220 #if defined(__BIONIC__)
221   android_set_application_target_sdk_version(23);
222   sem_t s;
223   ASSERT_EQ(0, sem_init(&s, 0, 0));
224   ScopedSignalHandler handler(SIGUSR1, sem_wait_test_signal_handler);
225   pthread_t thread;
226   ASSERT_EQ(0, pthread_create(&thread, nullptr, SemWaitEINTRThreadFn, &s));
227   // Give some time for the thread to run sem_wait.
228   usleep(500000);
229   ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
230   // Give some time for the thread to handle signal.
231   usleep(500000);
232   ASSERT_EQ(0, sem_post(&s));
233   void* result;
234   ASSERT_EQ(0, pthread_join(thread, &result));
235   ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(result));
236 #else
237   GTEST_SKIP() << "This test tests sem_wait's compatibility for old sdk versions";
238 #endif
239 }
240 
TEST(semaphore,sem_wait_EINTR_in_sdk_greater_than_23)241 TEST(semaphore, sem_wait_EINTR_in_sdk_greater_than_23) {
242 #if defined(__BIONIC__)
243   android_set_application_target_sdk_version(24U);
244 #endif
245   sem_t s;
246   ASSERT_EQ(0, sem_init(&s, 0, 0));
247   ScopedSignalHandler handler(SIGUSR1, sem_wait_test_signal_handler);
248   pthread_t thread;
249   ASSERT_EQ(0, pthread_create(&thread, nullptr, SemWaitEINTRThreadFn, &s));
250   // Give some time for the thread to run sem_wait.
251   usleep(500000);
252   ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
253   // Give some time for the thread to handle signal.
254   usleep(500000);
255   ASSERT_EQ(0, sem_post(&s));
256   void* result;
257   ASSERT_EQ(0, pthread_join(thread, &result));
258   ASSERT_EQ(2U, reinterpret_cast<uintptr_t>(result));
259 }
260