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 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 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 67 static void SemWaitThreadTestFn(sem_t& sem) { 68 ASSERT_EQ(0, sem_wait(&sem)); 69 } 70 71 static void* SemWaitThreadFn(void* arg) { 72 SemWaitThreadTestFn(*reinterpret_cast<sem_t*>(arg)); 73 return nullptr; 74 } 75 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 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 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 136 TEST(semaphore, sem_timedwait) { 137 sem_timedwait_helper(CLOCK_REALTIME, sem_timedwait); 138 } 139 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_LOG_(INFO) 145 << "This test does nothing since sem_timedwait_monotonic_np is only supported on bionic"; 146 #endif // __BIONIC__ 147 } 148 149 TEST(semaphore_DeathTest, sem_timedwait_null_timeout) { 150 sem_t s; 151 ASSERT_EQ(0, sem_init(&s, 0, 0)); 152 153 ASSERT_EXIT(sem_timedwait(&s, nullptr), testing::KilledBySignal(SIGSEGV), ""); 154 } 155 156 TEST(semaphore, sem_getvalue) { 157 sem_t s; 158 ASSERT_EQ(0, sem_init(&s, 0, 0)); 159 160 int i; 161 ASSERT_EQ(0, sem_getvalue(&s, &i)); 162 ASSERT_EQ(0, i); 163 164 ASSERT_EQ(0, sem_post(&s)); 165 ASSERT_EQ(0, sem_getvalue(&s, &i)); 166 ASSERT_EQ(1, i); 167 168 ASSERT_EQ(0, sem_post(&s)); 169 ASSERT_EQ(0, sem_getvalue(&s, &i)); 170 ASSERT_EQ(2, i); 171 172 ASSERT_EQ(0, sem_wait(&s)); 173 ASSERT_EQ(0, sem_getvalue(&s, &i)); 174 ASSERT_EQ(1, i); 175 } 176 177 extern "C" void android_set_application_target_sdk_version(uint32_t target); 178 179 static void sem_wait_test_signal_handler(int) { 180 } 181 182 static void* SemWaitEINTRThreadFn(void* arg) { 183 sem_t* sem = reinterpret_cast<sem_t*>(arg); 184 uintptr_t have_eintr = 0; 185 uintptr_t have_error = 0; 186 while (true) { 187 int result = sem_wait(sem); 188 if (result == 0) { 189 break; 190 } 191 if (result == -1) { 192 if (errno == EINTR) { 193 have_eintr = 1; 194 } else { 195 have_error = 1; 196 break; 197 } 198 } 199 } 200 return reinterpret_cast<void*>((have_eintr << 1) | have_error); 201 } 202 203 TEST(semaphore, sem_wait_no_EINTR_in_sdk_less_equal_than_23) { 204 #if defined(__BIONIC__) 205 android_set_application_target_sdk_version(__ANDROID_API_M__); 206 sem_t s; 207 ASSERT_EQ(0, sem_init(&s, 0, 0)); 208 ScopedSignalHandler handler(SIGUSR1, sem_wait_test_signal_handler); 209 pthread_t thread; 210 ASSERT_EQ(0, pthread_create(&thread, nullptr, SemWaitEINTRThreadFn, &s)); 211 // Give some time for the thread to run sem_wait. 212 usleep(500000); 213 ASSERT_EQ(0, pthread_kill(thread, SIGUSR1)); 214 // Give some time for the thread to handle signal. 215 usleep(500000); 216 ASSERT_EQ(0, sem_post(&s)); 217 void* result; 218 ASSERT_EQ(0, pthread_join(thread, &result)); 219 ASSERT_EQ(0U, reinterpret_cast<uintptr_t>(result)); 220 #else 221 GTEST_LOG_(INFO) << "This test tests sem_wait's compatibility for old sdk versions"; 222 #endif 223 } 224 225 TEST(semaphore, sem_wait_EINTR_in_sdk_greater_than_23) { 226 #if defined(__BIONIC__) 227 android_set_application_target_sdk_version(24U); 228 #endif 229 sem_t s; 230 ASSERT_EQ(0, sem_init(&s, 0, 0)); 231 ScopedSignalHandler handler(SIGUSR1, sem_wait_test_signal_handler); 232 pthread_t thread; 233 ASSERT_EQ(0, pthread_create(&thread, nullptr, SemWaitEINTRThreadFn, &s)); 234 // Give some time for the thread to run sem_wait. 235 usleep(500000); 236 ASSERT_EQ(0, pthread_kill(thread, SIGUSR1)); 237 // Give some time for the thread to handle signal. 238 usleep(500000); 239 ASSERT_EQ(0, sem_post(&s)); 240 void* result; 241 ASSERT_EQ(0, pthread_join(thread, &result)); 242 ASSERT_EQ(2U, reinterpret_cast<uintptr_t>(result)); 243 } 244
