1 /******************************************************************************
2 *
3 * Copyright (C) 2014 Google, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 #define LOG_TAG "bt_osi_alarm"
20
21 #include <assert.h>
22 #include <errno.h>
23 #include <hardware/bluetooth.h>
24 #include <inttypes.h>
25 #include <time.h>
26 #include <utils/Log.h>
27
28 #include "alarm.h"
29 #include "list.h"
30 #include "osi.h"
31
32 struct alarm_t {
33 // The lock is held while the callback for this alarm is being executed.
34 // It allows us to release the coarse-grained monitor lock while a potentially
35 // long-running callback is executing. |alarm_cancel| uses this lock to provide
36 // a guarantee to its caller that the callback will not be in progress when it
37 // returns.
38 pthread_mutex_t callback_lock;
39 period_ms_t deadline;
40 alarm_callback_t callback;
41 void *data;
42 };
43
44 extern bt_os_callouts_t *bt_os_callouts;
45
46 // If the next wakeup time is less than this threshold, we should acquire
47 // a wakelock instead of setting a wake alarm so we're not bouncing in
48 // and out of suspend frequently. This value is externally visible to allow
49 // unit tests to run faster. It should not be modified by production code.
50 int64_t TIMER_INTERVAL_FOR_WAKELOCK_IN_MS = 3000;
51 static const clockid_t CLOCK_ID = CLOCK_BOOTTIME;
52 static const char *WAKE_LOCK_ID = "bluedroid_timer";
53
54 // This mutex ensures that the |alarm_set|, |alarm_cancel|, and alarm callback
55 // functions execute serially and not concurrently. As a result, this mutex also
56 // protects the |alarms| list.
57 static pthread_mutex_t monitor;
58 static list_t *alarms;
59 static timer_t timer;
60 static bool timer_set;
61
62 static bool lazy_initialize(void);
63 static period_ms_t now(void);
64 static void timer_callback(void *data);
65 static void reschedule(void);
66
alarm_new(void)67 alarm_t *alarm_new(void) {
68 // Make sure we have a list we can insert alarms into.
69 if (!alarms && !lazy_initialize())
70 return NULL;
71
72 pthread_mutexattr_t attr;
73 pthread_mutexattr_init(&attr);
74
75 alarm_t *ret = calloc(1, sizeof(alarm_t));
76 if (!ret) {
77 ALOGE("%s unable to allocate memory for alarm.", __func__);
78 goto error;
79 }
80
81 // Make this a recursive mutex to make it safe to call |alarm_cancel| from
82 // within the callback function of the alarm.
83 int error = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
84 if (error) {
85 ALOGE("%s unable to create a recursive mutex: %s", __func__, strerror(error));
86 goto error;
87 }
88
89 error = pthread_mutex_init(&ret->callback_lock, &attr);
90 if (error) {
91 ALOGE("%s unable to initialize mutex: %s", __func__, strerror(error));
92 goto error;
93 }
94
95 pthread_mutexattr_destroy(&attr);
96 return ret;
97
98 error:;
99 pthread_mutexattr_destroy(&attr);
100 free(ret);
101 return NULL;
102 }
103
alarm_free(alarm_t * alarm)104 void alarm_free(alarm_t *alarm) {
105 if (!alarm)
106 return;
107
108 alarm_cancel(alarm);
109 pthread_mutex_destroy(&alarm->callback_lock);
110 free(alarm);
111 }
112
113 // Runs in exclusion with alarm_cancel and timer_callback.
alarm_set(alarm_t * alarm,period_ms_t deadline,alarm_callback_t cb,void * data)114 void alarm_set(alarm_t *alarm, period_ms_t deadline, alarm_callback_t cb, void *data) {
115 assert(alarms != NULL);
116 assert(alarm != NULL);
117 assert(cb != NULL);
118
119 pthread_mutex_lock(&monitor);
120
121 // If the alarm is currently set and it's at the start of the list,
122 // we'll need to re-schedule since we've adjusted the earliest deadline.
123 bool needs_reschedule = (!list_is_empty(alarms) && list_front(alarms) == alarm);
124 if (alarm->callback)
125 list_remove(alarms, alarm);
126
127 alarm->deadline = now() + deadline;
128 alarm->callback = cb;
129 alarm->data = data;
130
131 // Add it into the timer list sorted by deadline (earliest deadline first).
132 if (list_is_empty(alarms))
133 list_prepend(alarms, alarm);
134 else
135 for (list_node_t *node = list_begin(alarms); node != list_end(alarms); node = list_next(node)) {
136 list_node_t *next = list_next(node);
137 if (next == list_end(alarms) || ((alarm_t *)list_node(next))->deadline >= alarm->deadline) {
138 list_insert_after(alarms, node, alarm);
139 break;
140 }
141 }
142
143 // If the new alarm has the earliest deadline, we need to re-evaluate our schedule.
144 if (needs_reschedule || (!list_is_empty(alarms) && list_front(alarms) == alarm))
145 reschedule();
146
147 pthread_mutex_unlock(&monitor);
148 }
149
alarm_cancel(alarm_t * alarm)150 void alarm_cancel(alarm_t *alarm) {
151 assert(alarms != NULL);
152 assert(alarm != NULL);
153
154 pthread_mutex_lock(&monitor);
155
156 bool needs_reschedule = (!list_is_empty(alarms) && list_front(alarms) == alarm);
157
158 list_remove(alarms, alarm);
159 alarm->deadline = 0;
160 alarm->callback = NULL;
161 alarm->data = NULL;
162
163 if (needs_reschedule)
164 reschedule();
165
166 pthread_mutex_unlock(&monitor);
167
168 // If the callback for |alarm| is in progress, wait here until it completes.
169 pthread_mutex_lock(&alarm->callback_lock);
170 pthread_mutex_unlock(&alarm->callback_lock);
171 }
172
lazy_initialize(void)173 static bool lazy_initialize(void) {
174 assert(alarms == NULL);
175
176 pthread_mutex_init(&monitor, NULL);
177
178 alarms = list_new(NULL);
179 if (!alarms) {
180 ALOGE("%s unable to allocate alarm list.", __func__);
181 return false;
182 }
183
184 return true;
185 }
186
now(void)187 static period_ms_t now(void) {
188 assert(alarms != NULL);
189
190 struct timespec ts;
191 if (clock_gettime(CLOCK_ID, &ts) == -1) {
192 ALOGE("%s unable to get current time: %s", __func__, strerror(errno));
193 return 0;
194 }
195
196 return (ts.tv_sec * 1000LL) + (ts.tv_nsec / 1000000LL);
197 }
198
199 // Warning: this function is called in the context of an unknown thread.
200 // As a result, it must be thread-safe relative to other operations on
201 // the alarm list.
timer_callback(void * ptr)202 static void timer_callback(void *ptr) {
203 alarm_t *alarm = (alarm_t *)ptr;
204 assert(alarm != NULL);
205
206 pthread_mutex_lock(&monitor);
207
208 bool alarm_valid = list_remove(alarms, alarm);
209 alarm_callback_t callback = alarm->callback;
210 void *data = alarm->data;
211
212 alarm->deadline = 0;
213 alarm->callback = NULL;
214 alarm->data = NULL;
215
216 reschedule();
217
218 // The alarm was cancelled before we got to it. Release the monitor
219 // lock and exit right away since there's nothing left to do.
220 if (!alarm_valid) {
221 pthread_mutex_unlock(&monitor);
222 return;
223 }
224
225 // Downgrade lock.
226 pthread_mutex_lock(&alarm->callback_lock);
227 pthread_mutex_unlock(&monitor);
228
229 callback(data);
230
231 pthread_mutex_unlock(&alarm->callback_lock);
232 }
233
234 // NOTE: must be called with monitor lock.
reschedule(void)235 static void reschedule(void) {
236 assert(alarms != NULL);
237
238 if (timer_set) {
239 timer_delete(timer);
240 timer_set = false;
241 }
242
243 if (list_is_empty(alarms)) {
244 bt_os_callouts->release_wake_lock(WAKE_LOCK_ID);
245 return;
246 }
247
248 alarm_t *next = list_front(alarms);
249 int64_t next_exp = next->deadline - now();
250 if (next_exp < TIMER_INTERVAL_FOR_WAKELOCK_IN_MS) {
251 int status = bt_os_callouts->acquire_wake_lock(WAKE_LOCK_ID);
252 if (status != BT_STATUS_SUCCESS) {
253 ALOGE("%s unable to acquire wake lock: %d", __func__, status);
254 return;
255 }
256
257 struct sigevent sigevent;
258 memset(&sigevent, 0, sizeof(sigevent));
259 sigevent.sigev_notify = SIGEV_THREAD;
260 sigevent.sigev_notify_function = (void (*)(union sigval))timer_callback;
261 sigevent.sigev_value.sival_ptr = next;
262 if (timer_create(CLOCK_ID, &sigevent, &timer) == -1) {
263 ALOGE("%s unable to create timer: %s", __func__, strerror(errno));
264 return;
265 }
266
267 struct itimerspec wakeup_time;
268 memset(&wakeup_time, 0, sizeof(wakeup_time));
269 wakeup_time.it_value.tv_sec = (next->deadline / 1000);
270 wakeup_time.it_value.tv_nsec = (next->deadline % 1000) * 1000000LL;
271 if (timer_settime(timer, TIMER_ABSTIME, &wakeup_time, NULL) == -1) {
272 ALOGE("%s unable to set timer: %s", __func__, strerror(errno));
273 timer_delete(timer);
274 return;
275 }
276 timer_set = true;
277 } else {
278 if (!bt_os_callouts->set_wake_alarm(next_exp, true, timer_callback, next))
279 ALOGE("%s unable to set wake alarm for %" PRId64 "ms.", __func__, next_exp);
280
281 bt_os_callouts->release_wake_lock(WAKE_LOCK_ID);
282 }
283 }
284