1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include "pthread_internal.h" 30 #include "private/bionic_futex.h" 31 #include "private/kernel_sigset_t.h" 32 33 #include <errno.h> 34 #include <stdio.h> 35 #include <string.h> 36 37 // System calls. 38 extern "C" int __rt_sigtimedwait(const sigset_t*, siginfo_t*, const struct timespec*, size_t); 39 extern "C" int __timer_create(clockid_t, sigevent*, __kernel_timer_t*); 40 extern "C" int __timer_delete(__kernel_timer_t); 41 extern "C" int __timer_getoverrun(__kernel_timer_t); 42 extern "C" int __timer_gettime(__kernel_timer_t, itimerspec*); 43 extern "C" int __timer_settime(__kernel_timer_t, int, const itimerspec*, itimerspec*); 44 45 // Most POSIX timers are handled directly by the kernel. We translate SIGEV_THREAD timers 46 // into SIGEV_THREAD_ID timers so the kernel handles all the time-related stuff and we just 47 // need to worry about running user code on a thread. 48 49 // We can't use SIGALRM because too many other C library functions throw that around, and since 50 // they don't send to a specific thread, all threads are eligible to handle the signal and we can 51 // end up with one of our POSIX timer threads handling it (meaning that the intended recipient 52 // doesn't). glibc uses SIGRTMIN for its POSIX timer implementation, so in the absence of any 53 // reason to use anything else, we use that too. 54 static const int TIMER_SIGNAL = (__SIGRTMIN + 0); 55 56 struct PosixTimer { 57 __kernel_timer_t kernel_timer_id; 58 59 int sigev_notify; 60 61 // These fields are only needed for a SIGEV_THREAD timer. 62 pthread_t callback_thread; 63 void (*callback)(sigval_t); 64 sigval_t callback_argument; 65 }; 66 67 static __kernel_timer_t to_kernel_timer_id(timer_t timer) { 68 return reinterpret_cast<PosixTimer*>(timer)->kernel_timer_id; 69 } 70 71 static void* __timer_thread_start(void* arg) { 72 PosixTimer* timer = reinterpret_cast<PosixTimer*>(arg); 73 74 kernel_sigset_t sigset; 75 sigaddset(sigset.get(), TIMER_SIGNAL); 76 77 while (true) { 78 // Wait for a signal... 79 siginfo_t si; 80 memset(&si, 0, sizeof(si)); 81 int rc = __rt_sigtimedwait(sigset.get(), &si, NULL, sizeof(sigset)); 82 if (rc == -1) { 83 continue; 84 } 85 86 if (si.si_code == SI_TIMER) { 87 // This signal was sent because a timer fired, so call the callback. 88 timer->callback(timer->callback_argument); 89 } else if (si.si_code == SI_TKILL) { 90 // This signal was sent because someone wants us to exit. 91 free(timer); 92 return NULL; 93 } 94 } 95 } 96 97 static void __timer_thread_stop(PosixTimer* timer) { 98 pthread_kill(timer->callback_thread, TIMER_SIGNAL); 99 } 100 101 // http://pubs.opengroup.org/onlinepubs/9699919799/functions/timer_create.html 102 int timer_create(clockid_t clock_id, sigevent* evp, timer_t* timer_id) { 103 PosixTimer* timer = reinterpret_cast<PosixTimer*>(malloc(sizeof(PosixTimer))); 104 if (timer == NULL) { 105 return -1; 106 } 107 108 timer->sigev_notify = (evp == NULL) ? SIGEV_SIGNAL : evp->sigev_notify; 109 110 // If not a SIGEV_THREAD timer, the kernel can handle it without our help. 111 if (timer->sigev_notify != SIGEV_THREAD) { 112 if (__timer_create(clock_id, evp, &timer->kernel_timer_id) == -1) { 113 free(timer); 114 return -1; 115 } 116 117 *timer_id = timer; 118 return 0; 119 } 120 121 // Otherwise, this must be SIGEV_THREAD timer... 122 timer->callback = evp->sigev_notify_function; 123 timer->callback_argument = evp->sigev_value; 124 125 // Check arguments that the kernel doesn't care about but we do. 126 if (timer->callback == NULL) { 127 free(timer); 128 errno = EINVAL; 129 return -1; 130 } 131 132 // Create this timer's thread. 133 pthread_attr_t thread_attributes; 134 if (evp->sigev_notify_attributes == NULL) { 135 pthread_attr_init(&thread_attributes); 136 } else { 137 thread_attributes = *reinterpret_cast<pthread_attr_t*>(evp->sigev_notify_attributes); 138 } 139 pthread_attr_setdetachstate(&thread_attributes, PTHREAD_CREATE_DETACHED); 140 141 // We start the thread with TIMER_SIGNAL blocked by blocking the signal here and letting it 142 // inherit. If it tried to block the signal itself, there would be a race. 143 kernel_sigset_t sigset; 144 sigaddset(sigset.get(), TIMER_SIGNAL); 145 kernel_sigset_t old_sigset; 146 pthread_sigmask(SIG_BLOCK, sigset.get(), old_sigset.get()); 147 148 int rc = pthread_create(&timer->callback_thread, &thread_attributes, __timer_thread_start, timer); 149 150 pthread_sigmask(SIG_SETMASK, old_sigset.get(), NULL); 151 152 if (rc != 0) { 153 free(timer); 154 errno = rc; 155 return -1; 156 } 157 158 sigevent se = *evp; 159 se.sigev_signo = TIMER_SIGNAL; 160 se.sigev_notify = SIGEV_THREAD_ID; 161 se.sigev_notify_thread_id = pthread_gettid_np(timer->callback_thread); 162 if (__timer_create(clock_id, &se, &timer->kernel_timer_id) == -1) { 163 __timer_thread_stop(timer); 164 return -1; 165 } 166 167 // Give the thread a meaningful name. 168 // It can't do this itself because the kernel timer isn't created until after it's running. 169 char name[32]; 170 snprintf(name, sizeof(name), "POSIX interval timer %d", to_kernel_timer_id(timer)); 171 pthread_setname_np(timer->callback_thread, name); 172 173 *timer_id = timer; 174 return 0; 175 } 176 177 // http://pubs.opengroup.org/onlinepubs/9699919799/functions/timer_delete.html 178 int timer_delete(timer_t id) { 179 int rc = __timer_delete(to_kernel_timer_id(id)); 180 if (rc == -1) { 181 return -1; 182 } 183 184 PosixTimer* timer = reinterpret_cast<PosixTimer*>(id); 185 if (timer->sigev_notify == SIGEV_THREAD) { 186 // Stopping the timer's thread frees the timer data when it's safe. 187 __timer_thread_stop(timer); 188 } else { 189 // For timers without threads, we can just free right away. 190 free(timer); 191 } 192 193 return 0; 194 } 195 196 // http://pubs.opengroup.org/onlinepubs/9699919799/functions/timer_getoverrun.html 197 int timer_gettime(timer_t id, itimerspec* ts) { 198 return __timer_gettime(to_kernel_timer_id(id), ts); 199 } 200 201 // http://pubs.opengroup.org/onlinepubs/9699919799/functions/timer_getoverrun.html 202 int timer_settime(timer_t id, int flags, const itimerspec* ts, itimerspec* ots) { 203 return __timer_settime(to_kernel_timer_id(id), flags, ts, ots); 204 } 205 206 // http://pubs.opengroup.org/onlinepubs/9699919799/functions/timer_getoverrun.html 207 int timer_getoverrun(timer_t id) { 208 return __timer_getoverrun(to_kernel_timer_id(id)); 209 } 210
