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 "ScopedSignalHandler.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, NULL, SemWaitThreadFn, &s));
82   ASSERT_EQ(0, pthread_create(&t2, NULL, SemWaitThreadFn, &s));
83   ASSERT_EQ(0, pthread_create(&t3, NULL, 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 
TEST(semaphore,sem_timedwait)104 TEST(semaphore, sem_timedwait) {
105   sem_t s;
106   ASSERT_EQ(0, sem_init(&s, 0, 0));
107 
108   timespec ts;
109   ASSERT_EQ(0, clock_gettime(CLOCK_REALTIME, &ts));
110   timespec_add_ms(ts, 100);
111 
112   errno = 0;
113   ASSERT_EQ(-1, sem_timedwait(&s, &ts));
114   ASSERT_EQ(ETIMEDOUT, errno);
115 
116   // A negative timeout is an error.
117   errno = 0;
118   ts.tv_nsec = -1;
119   ASSERT_EQ(-1, sem_timedwait(&s, &ts));
120   ASSERT_EQ(EINVAL, errno);
121   errno = 0;
122   ts.tv_nsec = NS_PER_S;
123   ASSERT_EQ(-1, sem_timedwait(&s, &ts));
124   ASSERT_EQ(EINVAL, errno);
125 
126   errno = 0;
127   ts.tv_nsec = NS_PER_S - 1;
128   ts.tv_sec = -1;
129   ASSERT_EQ(-1, sem_timedwait(&s, &ts));
130   ASSERT_EQ(ETIMEDOUT, errno);
131 
132   ASSERT_EQ(0, sem_destroy(&s));
133 }
134 
TEST(semaphore_DeathTest,sem_timedwait_null_timeout)135 TEST(semaphore_DeathTest, sem_timedwait_null_timeout) {
136   sem_t s;
137   ASSERT_EQ(0, sem_init(&s, 0, 0));
138 
139   ASSERT_EXIT(sem_timedwait(&s, nullptr), testing::KilledBySignal(SIGSEGV), "");
140 }
141 
TEST(semaphore,sem_getvalue)142 TEST(semaphore, sem_getvalue) {
143   sem_t s;
144   ASSERT_EQ(0, sem_init(&s, 0, 0));
145 
146   int i;
147   ASSERT_EQ(0, sem_getvalue(&s, &i));
148   ASSERT_EQ(0, i);
149 
150   ASSERT_EQ(0, sem_post(&s));
151   ASSERT_EQ(0, sem_getvalue(&s, &i));
152   ASSERT_EQ(1, i);
153 
154   ASSERT_EQ(0, sem_post(&s));
155   ASSERT_EQ(0, sem_getvalue(&s, &i));
156   ASSERT_EQ(2, i);
157 
158   ASSERT_EQ(0, sem_wait(&s));
159   ASSERT_EQ(0, sem_getvalue(&s, &i));
160   ASSERT_EQ(1, i);
161 }
162 
163 extern "C" void android_set_application_target_sdk_version(uint32_t target);
164 
sem_wait_test_signal_handler(int)165 static void sem_wait_test_signal_handler(int) {
166 }
167 
SemWaitEINTRThreadFn(void * arg)168 static void* SemWaitEINTRThreadFn(void* arg) {
169   sem_t* sem = reinterpret_cast<sem_t*>(arg);
170   uintptr_t have_eintr = 0;
171   uintptr_t have_error = 0;
172   while (true) {
173     int result = sem_wait(sem);
174     if (result == 0) {
175       break;
176     }
177     if (result == -1) {
178       if (errno == EINTR) {
179         have_eintr = 1;
180       } else {
181         have_error = 1;
182         break;
183       }
184     }
185   }
186   return reinterpret_cast<void*>((have_eintr << 1) | have_error);
187 }
188 
TEST(semaphore,sem_wait_no_EINTR_in_sdk_less_equal_than_23)189 TEST(semaphore, sem_wait_no_EINTR_in_sdk_less_equal_than_23) {
190 #if defined(__BIONIC__)
191   android_set_application_target_sdk_version(23U);
192   sem_t s;
193   ASSERT_EQ(0, sem_init(&s, 0, 0));
194   ScopedSignalHandler handler(SIGUSR1, sem_wait_test_signal_handler);
195   pthread_t thread;
196   ASSERT_EQ(0, pthread_create(&thread, nullptr, SemWaitEINTRThreadFn, &s));
197   // Give some time for the thread to run sem_wait.
198   usleep(500000);
199   ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
200   // Give some time for the thread to handle signal.
201   usleep(500000);
202   ASSERT_EQ(0, sem_post(&s));
203   void* result;
204   ASSERT_EQ(0, pthread_join(thread, &result));
205   ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(result));
206 #else
207   GTEST_LOG_(INFO) << "This test tests sem_wait's compatibility for old sdk versions";
208 #endif
209 }
210 
TEST(semaphore,sem_wait_EINTR_in_sdk_greater_than_23)211 TEST(semaphore, sem_wait_EINTR_in_sdk_greater_than_23) {
212 #if defined(__BIONIC__)
213   android_set_application_target_sdk_version(24U);
214 #endif
215   sem_t s;
216   ASSERT_EQ(0, sem_init(&s, 0, 0));
217   ScopedSignalHandler handler(SIGUSR1, sem_wait_test_signal_handler);
218   pthread_t thread;
219   ASSERT_EQ(0, pthread_create(&thread, nullptr, SemWaitEINTRThreadFn, &s));
220   // Give some time for the thread to run sem_wait.
221   usleep(500000);
222   ASSERT_EQ(0, pthread_kill(thread, SIGUSR1));
223   // Give some time for the thread to handle signal.
224   usleep(500000);
225   ASSERT_EQ(0, sem_post(&s));
226   void* result;
227   ASSERT_EQ(0, pthread_join(thread, &result));
228   ASSERT_EQ(2U, reinterpret_cast<uintptr_t>(result));
229 }
230