| /****************************************************************************** |
| * |
| * Copyright (C) 2014 Google, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| |
| #include "include/bt_target.h" |
| |
| #define LOG_TAG "bt_osi_alarm" |
| |
| #include "osi/include/alarm.h" |
| |
| #include <base/logging.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <inttypes.h> |
| #include <malloc.h> |
| #include <pthread.h> |
| #include <signal.h> |
| #include <string.h> |
| #include <time.h> |
| |
| #include <hardware/bluetooth.h> |
| |
| #include <mutex> |
| |
| #include "osi/include/allocator.h" |
| #include "osi/include/fixed_queue.h" |
| #include "osi/include/list.h" |
| #include "osi/include/log.h" |
| #include "osi/include/osi.h" |
| #include "osi/include/semaphore.h" |
| #include "osi/include/thread.h" |
| #include "osi/include/wakelock.h" |
| |
| // Callback and timer threads should run at RT priority in order to ensure they |
| // meet audio deadlines. Use this priority for all audio/timer related thread. |
| static const int THREAD_RT_PRIORITY = 1; |
| |
| typedef struct { |
| size_t count; |
| period_ms_t total_ms; |
| period_ms_t max_ms; |
| } stat_t; |
| |
| // Alarm-related information and statistics |
| typedef struct { |
| const char* name; |
| size_t scheduled_count; |
| size_t canceled_count; |
| size_t rescheduled_count; |
| size_t total_updates; |
| period_ms_t last_update_ms; |
| stat_t callback_execution; |
| stat_t overdue_scheduling; |
| stat_t premature_scheduling; |
| } alarm_stats_t; |
| |
| struct alarm_t { |
| // The mutex is held while the callback for this alarm is being executed. |
| // It allows us to release the coarse-grained monitor lock while a |
| // potentially long-running callback is executing. |alarm_cancel| uses this |
| // mutex to provide a guarantee to its caller that the callback will not be |
| // in progress when it returns. |
| std::recursive_mutex* callback_mutex; |
| period_ms_t creation_time; |
| period_ms_t period; |
| period_ms_t deadline; |
| period_ms_t prev_deadline; // Previous deadline - used for accounting of |
| // periodic timers |
| bool is_periodic; |
| fixed_queue_t* queue; // The processing queue to add this alarm to |
| alarm_callback_t callback; |
| void* data; |
| alarm_stats_t stats; |
| }; |
| |
| // If the next wakeup time is less than this threshold, we should acquire |
| // a wakelock instead of setting a wake alarm so we're not bouncing in |
| // and out of suspend frequently. This value is externally visible to allow |
| // unit tests to run faster. It should not be modified by production code. |
| int64_t TIMER_INTERVAL_FOR_WAKELOCK_IN_MS = 3000; |
| static const clockid_t CLOCK_ID = CLOCK_BOOTTIME; |
| |
| #if (KERNEL_MISSING_CLOCK_BOOTTIME_ALARM == TRUE) |
| static const clockid_t CLOCK_ID_ALARM = CLOCK_BOOTTIME; |
| #else |
| static const clockid_t CLOCK_ID_ALARM = CLOCK_BOOTTIME_ALARM; |
| #endif |
| |
| // This mutex ensures that the |alarm_set|, |alarm_cancel|, and alarm callback |
| // functions execute serially and not concurrently. As a result, this mutex |
| // also protects the |alarms| list. |
| static std::mutex alarms_mutex; |
| static list_t* alarms; |
| static timer_t timer; |
| static timer_t wakeup_timer; |
| static bool timer_set; |
| |
| // All alarm callbacks are dispatched from |dispatcher_thread| |
| static thread_t* dispatcher_thread; |
| static bool dispatcher_thread_active; |
| static semaphore_t* alarm_expired; |
| |
| // Default alarm callback thread and queue |
| static thread_t* default_callback_thread; |
| static fixed_queue_t* default_callback_queue; |
| |
| static alarm_t* alarm_new_internal(const char* name, bool is_periodic); |
| static bool lazy_initialize(void); |
| static period_ms_t now(void); |
| static void alarm_set_internal(alarm_t* alarm, period_ms_t period, |
| alarm_callback_t cb, void* data, |
| fixed_queue_t* queue); |
| static void alarm_cancel_internal(alarm_t* alarm); |
| static void remove_pending_alarm(alarm_t* alarm); |
| static void schedule_next_instance(alarm_t* alarm); |
| static void reschedule_root_alarm(void); |
| static void alarm_queue_ready(fixed_queue_t* queue, void* context); |
| static void timer_callback(void* data); |
| static void callback_dispatch(void* context); |
| static bool timer_create_internal(const clockid_t clock_id, timer_t* timer); |
| static void update_scheduling_stats(alarm_stats_t* stats, period_ms_t now_ms, |
| period_ms_t deadline_ms, |
| period_ms_t execution_delta_ms); |
| |
| static void update_stat(stat_t* stat, period_ms_t delta) { |
| if (stat->max_ms < delta) stat->max_ms = delta; |
| stat->total_ms += delta; |
| stat->count++; |
| } |
| |
| alarm_t* alarm_new(const char* name) { return alarm_new_internal(name, false); } |
| |
| alarm_t* alarm_new_periodic(const char* name) { |
| return alarm_new_internal(name, true); |
| } |
| |
| static alarm_t* alarm_new_internal(const char* name, bool is_periodic) { |
| // Make sure we have a list we can insert alarms into. |
| if (!alarms && !lazy_initialize()) { |
| CHECK(false); // if initialization failed, we should not continue |
| return NULL; |
| } |
| |
| alarm_t* ret = static_cast<alarm_t*>(osi_calloc(sizeof(alarm_t))); |
| |
| ret->callback_mutex = new std::recursive_mutex; |
| ret->is_periodic = is_periodic; |
| ret->stats.name = osi_strdup(name); |
| // NOTE: The stats were reset by osi_calloc() above |
| |
| return ret; |
| } |
| |
| void alarm_free(alarm_t* alarm) { |
| if (!alarm) return; |
| |
| alarm_cancel(alarm); |
| delete alarm->callback_mutex; |
| osi_free((void*)alarm->stats.name); |
| osi_free(alarm); |
| } |
| |
| period_ms_t alarm_get_remaining_ms(const alarm_t* alarm) { |
| CHECK(alarm != NULL); |
| period_ms_t remaining_ms = 0; |
| period_ms_t just_now = now(); |
| |
| std::lock_guard<std::mutex> lock(alarms_mutex); |
| if (alarm->deadline > just_now) remaining_ms = alarm->deadline - just_now; |
| |
| return remaining_ms; |
| } |
| |
| void alarm_set(alarm_t* alarm, period_ms_t interval_ms, alarm_callback_t cb, |
| void* data) { |
| alarm_set_on_queue(alarm, interval_ms, cb, data, default_callback_queue); |
| } |
| |
| void alarm_set_on_queue(alarm_t* alarm, period_ms_t interval_ms, |
| alarm_callback_t cb, void* data, fixed_queue_t* queue) { |
| CHECK(queue != NULL); |
| alarm_set_internal(alarm, interval_ms, cb, data, queue); |
| } |
| |
| // Runs in exclusion with alarm_cancel and timer_callback. |
| static void alarm_set_internal(alarm_t* alarm, period_ms_t period, |
| alarm_callback_t cb, void* data, |
| fixed_queue_t* queue) { |
| CHECK(alarms != NULL); |
| CHECK(alarm != NULL); |
| CHECK(cb != NULL); |
| |
| std::lock_guard<std::mutex> lock(alarms_mutex); |
| |
| alarm->creation_time = now(); |
| alarm->period = period; |
| alarm->queue = queue; |
| alarm->callback = cb; |
| alarm->data = data; |
| |
| schedule_next_instance(alarm); |
| alarm->stats.scheduled_count++; |
| } |
| |
| void alarm_cancel(alarm_t* alarm) { |
| CHECK(alarms != NULL); |
| if (!alarm) return; |
| |
| { |
| std::lock_guard<std::mutex> lock(alarms_mutex); |
| alarm_cancel_internal(alarm); |
| } |
| |
| // If the callback for |alarm| is in progress, wait here until it completes. |
| std::lock_guard<std::recursive_mutex> lock(*alarm->callback_mutex); |
| } |
| |
| // Internal implementation of canceling an alarm. |
| // The caller must hold the |alarms_mutex| |
| static void alarm_cancel_internal(alarm_t* alarm) { |
| bool needs_reschedule = |
| (!list_is_empty(alarms) && list_front(alarms) == alarm); |
| |
| remove_pending_alarm(alarm); |
| |
| alarm->deadline = 0; |
| alarm->prev_deadline = 0; |
| alarm->callback = NULL; |
| alarm->data = NULL; |
| alarm->stats.canceled_count++; |
| alarm->queue = NULL; |
| |
| if (needs_reschedule) reschedule_root_alarm(); |
| } |
| |
| bool alarm_is_scheduled(const alarm_t* alarm) { |
| if ((alarms == NULL) || (alarm == NULL)) return false; |
| return (alarm->callback != NULL); |
| } |
| |
| void alarm_cleanup(void) { |
| // If lazy_initialize never ran there is nothing else to do |
| if (!alarms) return; |
| |
| dispatcher_thread_active = false; |
| semaphore_post(alarm_expired); |
| thread_free(dispatcher_thread); |
| dispatcher_thread = NULL; |
| |
| std::lock_guard<std::mutex> lock(alarms_mutex); |
| |
| fixed_queue_free(default_callback_queue, NULL); |
| default_callback_queue = NULL; |
| thread_free(default_callback_thread); |
| default_callback_thread = NULL; |
| |
| timer_delete(wakeup_timer); |
| timer_delete(timer); |
| semaphore_free(alarm_expired); |
| alarm_expired = NULL; |
| |
| list_free(alarms); |
| alarms = NULL; |
| } |
| |
| static bool lazy_initialize(void) { |
| CHECK(alarms == NULL); |
| |
| // timer_t doesn't have an invalid value so we must track whether |
| // the |timer| variable is valid ourselves. |
| bool timer_initialized = false; |
| bool wakeup_timer_initialized = false; |
| |
| std::lock_guard<std::mutex> lock(alarms_mutex); |
| |
| alarms = list_new(NULL); |
| if (!alarms) { |
| LOG_ERROR(LOG_TAG, "%s unable to allocate alarm list.", __func__); |
| goto error; |
| } |
| |
| if (!timer_create_internal(CLOCK_ID, &timer)) goto error; |
| timer_initialized = true; |
| |
| if (!timer_create_internal(CLOCK_ID_ALARM, &wakeup_timer)) goto error; |
| wakeup_timer_initialized = true; |
| |
| alarm_expired = semaphore_new(0); |
| if (!alarm_expired) { |
| LOG_ERROR(LOG_TAG, "%s unable to create alarm expired semaphore", __func__); |
| goto error; |
| } |
| |
| default_callback_thread = |
| thread_new_sized("alarm_default_callbacks", SIZE_MAX); |
| if (default_callback_thread == NULL) { |
| LOG_ERROR(LOG_TAG, "%s unable to create default alarm callbacks thread.", |
| __func__); |
| goto error; |
| } |
| thread_set_rt_priority(default_callback_thread, THREAD_RT_PRIORITY); |
| default_callback_queue = fixed_queue_new(SIZE_MAX); |
| if (default_callback_queue == NULL) { |
| LOG_ERROR(LOG_TAG, "%s unable to create default alarm callbacks queue.", |
| __func__); |
| goto error; |
| } |
| alarm_register_processing_queue(default_callback_queue, |
| default_callback_thread); |
| |
| dispatcher_thread_active = true; |
| dispatcher_thread = thread_new("alarm_dispatcher"); |
| if (!dispatcher_thread) { |
| LOG_ERROR(LOG_TAG, "%s unable to create alarm callback thread.", __func__); |
| goto error; |
| } |
| thread_set_rt_priority(dispatcher_thread, THREAD_RT_PRIORITY); |
| thread_post(dispatcher_thread, callback_dispatch, NULL); |
| return true; |
| |
| error: |
| fixed_queue_free(default_callback_queue, NULL); |
| default_callback_queue = NULL; |
| thread_free(default_callback_thread); |
| default_callback_thread = NULL; |
| |
| thread_free(dispatcher_thread); |
| dispatcher_thread = NULL; |
| |
| dispatcher_thread_active = false; |
| |
| semaphore_free(alarm_expired); |
| alarm_expired = NULL; |
| |
| if (wakeup_timer_initialized) timer_delete(wakeup_timer); |
| |
| if (timer_initialized) timer_delete(timer); |
| |
| list_free(alarms); |
| alarms = NULL; |
| |
| return false; |
| } |
| |
| static period_ms_t now(void) { |
| CHECK(alarms != NULL); |
| |
| struct timespec ts; |
| if (clock_gettime(CLOCK_ID, &ts) == -1) { |
| LOG_ERROR(LOG_TAG, "%s unable to get current time: %s", __func__, |
| strerror(errno)); |
| return 0; |
| } |
| |
| return (ts.tv_sec * 1000LL) + (ts.tv_nsec / 1000000LL); |
| } |
| |
| // Remove alarm from internal alarm list and the processing queue |
| // The caller must hold the |alarms_mutex| |
| static void remove_pending_alarm(alarm_t* alarm) { |
| list_remove(alarms, alarm); |
| while (fixed_queue_try_remove_from_queue(alarm->queue, alarm) != NULL) { |
| // Remove all repeated alarm instances from the queue. |
| // NOTE: We are defensive here - we shouldn't have repeated alarm instances |
| } |
| } |
| |
| // Must be called with |alarms_mutex| held |
| static void schedule_next_instance(alarm_t* alarm) { |
| // If the alarm is currently set and it's at the start of the list, |
| // we'll need to re-schedule since we've adjusted the earliest deadline. |
| bool needs_reschedule = |
| (!list_is_empty(alarms) && list_front(alarms) == alarm); |
| if (alarm->callback) remove_pending_alarm(alarm); |
| |
| // Calculate the next deadline for this alarm |
| period_ms_t just_now = now(); |
| period_ms_t ms_into_period = 0; |
| if ((alarm->is_periodic) && (alarm->period != 0)) |
| ms_into_period = ((just_now - alarm->creation_time) % alarm->period); |
| alarm->deadline = just_now + (alarm->period - ms_into_period); |
| |
| // Add it into the timer list sorted by deadline (earliest deadline first). |
| if (list_is_empty(alarms) || |
| ((alarm_t*)list_front(alarms))->deadline > alarm->deadline) { |
| list_prepend(alarms, alarm); |
| } else { |
| for (list_node_t* node = list_begin(alarms); node != list_end(alarms); |
| node = list_next(node)) { |
| list_node_t* next = list_next(node); |
| if (next == list_end(alarms) || |
| ((alarm_t*)list_node(next))->deadline > alarm->deadline) { |
| list_insert_after(alarms, node, alarm); |
| break; |
| } |
| } |
| } |
| |
| // If the new alarm has the earliest deadline, we need to re-evaluate our |
| // schedule. |
| if (needs_reschedule || |
| (!list_is_empty(alarms) && list_front(alarms) == alarm)) { |
| reschedule_root_alarm(); |
| } |
| } |
| |
| // NOTE: must be called with |alarms_mutex| held |
| static void reschedule_root_alarm(void) { |
| CHECK(alarms != NULL); |
| |
| const bool timer_was_set = timer_set; |
| alarm_t* next; |
| int64_t next_expiration; |
| |
| // If used in a zeroed state, disarms the timer. |
| struct itimerspec timer_time; |
| memset(&timer_time, 0, sizeof(timer_time)); |
| |
| if (list_is_empty(alarms)) goto done; |
| |
| next = static_cast<alarm_t*>(list_front(alarms)); |
| next_expiration = next->deadline - now(); |
| if (next_expiration < TIMER_INTERVAL_FOR_WAKELOCK_IN_MS) { |
| if (!timer_set) { |
| if (!wakelock_acquire()) { |
| LOG_ERROR(LOG_TAG, "%s unable to acquire wake lock", __func__); |
| goto done; |
| } |
| } |
| |
| timer_time.it_value.tv_sec = (next->deadline / 1000); |
| timer_time.it_value.tv_nsec = (next->deadline % 1000) * 1000000LL; |
| |
| // It is entirely unsafe to call timer_settime(2) with a zeroed timerspec |
| // for timers with *_ALARM clock IDs. Although the man page states that the |
| // timer would be canceled, the current behavior (as of Linux kernel 3.17) |
| // is that the callback is issued immediately. The only way to cancel an |
| // *_ALARM timer is to delete the timer. But unfortunately, deleting and |
| // re-creating a timer is rather expensive; every timer_create(2) spawns a |
| // new thread. So we simply set the timer to fire at the largest possible |
| // time. |
| // |
| // If we've reached this code path, we're going to grab a wake lock and |
| // wait for the next timer to fire. In that case, there's no reason to |
| // have a pending wakeup timer so we simply cancel it. |
| struct itimerspec end_of_time; |
| memset(&end_of_time, 0, sizeof(end_of_time)); |
| end_of_time.it_value.tv_sec = (time_t)(1LL << (sizeof(time_t) * 8 - 2)); |
| timer_settime(wakeup_timer, TIMER_ABSTIME, &end_of_time, NULL); |
| } else { |
| // WARNING: do not attempt to use relative timers with *_ALARM clock IDs |
| // in kernels before 3.17 unless you have the following patch: |
| // https://lkml.org/lkml/2014/7/7/576 |
| struct itimerspec wakeup_time; |
| memset(&wakeup_time, 0, sizeof(wakeup_time)); |
| |
| wakeup_time.it_value.tv_sec = (next->deadline / 1000); |
| wakeup_time.it_value.tv_nsec = (next->deadline % 1000) * 1000000LL; |
| if (timer_settime(wakeup_timer, TIMER_ABSTIME, &wakeup_time, NULL) == -1) |
| LOG_ERROR(LOG_TAG, "%s unable to set wakeup timer: %s", __func__, |
| strerror(errno)); |
| } |
| |
| done: |
| timer_set = |
| timer_time.it_value.tv_sec != 0 || timer_time.it_value.tv_nsec != 0; |
| if (timer_was_set && !timer_set) { |
| wakelock_release(); |
| } |
| |
| if (timer_settime(timer, TIMER_ABSTIME, &timer_time, NULL) == -1) |
| LOG_ERROR(LOG_TAG, "%s unable to set timer: %s", __func__, strerror(errno)); |
| |
| // If next expiration was in the past (e.g. short timer that got context |
| // switched) then the timer might have diarmed itself. Detect this case and |
| // work around it by manually signalling the |alarm_expired| semaphore. |
| // |
| // It is possible that the timer was actually super short (a few |
| // milliseconds) and the timer expired normally before we called |
| // |timer_gettime|. Worst case, |alarm_expired| is signaled twice for that |
| // alarm. Nothing bad should happen in that case though since the callback |
| // dispatch function checks to make sure the timer at the head of the list |
| // actually expired. |
| if (timer_set) { |
| struct itimerspec time_to_expire; |
| timer_gettime(timer, &time_to_expire); |
| if (time_to_expire.it_value.tv_sec == 0 && |
| time_to_expire.it_value.tv_nsec == 0) { |
| LOG_DEBUG( |
| LOG_TAG, |
| "%s alarm expiration too close for posix timers, switching to guns", |
| __func__); |
| semaphore_post(alarm_expired); |
| } |
| } |
| } |
| |
| void alarm_register_processing_queue(fixed_queue_t* queue, thread_t* thread) { |
| CHECK(queue != NULL); |
| CHECK(thread != NULL); |
| |
| fixed_queue_register_dequeue(queue, thread_get_reactor(thread), |
| alarm_queue_ready, NULL); |
| } |
| |
| void alarm_unregister_processing_queue(fixed_queue_t* queue) { |
| CHECK(alarms != NULL); |
| CHECK(queue != NULL); |
| |
| fixed_queue_unregister_dequeue(queue); |
| |
| // Cancel all alarms that are using this queue |
| std::lock_guard<std::mutex> lock(alarms_mutex); |
| for (list_node_t* node = list_begin(alarms); node != list_end(alarms);) { |
| alarm_t* alarm = (alarm_t*)list_node(node); |
| node = list_next(node); |
| // TODO: Each module is responsible for tearing down its alarms; currently, |
| // this is not the case. In the future, this check should be replaced by |
| // an assert. |
| if (alarm->queue == queue) alarm_cancel_internal(alarm); |
| } |
| } |
| |
| static void alarm_queue_ready(fixed_queue_t* queue, UNUSED_ATTR void* context) { |
| CHECK(queue != NULL); |
| |
| std::unique_lock<std::mutex> lock(alarms_mutex); |
| alarm_t* alarm = (alarm_t*)fixed_queue_try_dequeue(queue); |
| if (alarm == NULL) { |
| return; // The alarm was probably canceled |
| } |
| |
| // |
| // If the alarm is not periodic, we've fully serviced it now, and can reset |
| // some of its internal state. This is useful to distinguish between expired |
| // alarms and active ones. |
| // |
| alarm_callback_t callback = alarm->callback; |
| void* data = alarm->data; |
| period_ms_t deadline = alarm->deadline; |
| if (alarm->is_periodic) { |
| // The periodic alarm has been rescheduled and alarm->deadline has been |
| // updated, hence we need to use the previous deadline. |
| deadline = alarm->prev_deadline; |
| } else { |
| alarm->deadline = 0; |
| alarm->callback = NULL; |
| alarm->data = NULL; |
| alarm->queue = NULL; |
| } |
| |
| std::lock_guard<std::recursive_mutex> cb_lock(*alarm->callback_mutex); |
| lock.unlock(); |
| |
| period_ms_t t0 = now(); |
| callback(data); |
| period_ms_t t1 = now(); |
| |
| // Update the statistics |
| CHECK(t1 >= t0); |
| period_ms_t delta = t1 - t0; |
| update_scheduling_stats(&alarm->stats, t0, deadline, delta); |
| } |
| |
| // Callback function for wake alarms and our posix timer |
| static void timer_callback(UNUSED_ATTR void* ptr) { |
| semaphore_post(alarm_expired); |
| } |
| |
| // Function running on |dispatcher_thread| that performs the following: |
| // (1) Receives a signal using |alarm_exired| that the alarm has expired |
| // (2) Dispatches the alarm callback for processing by the corresponding |
| // thread for that alarm. |
| static void callback_dispatch(UNUSED_ATTR void* context) { |
| while (true) { |
| semaphore_wait(alarm_expired); |
| if (!dispatcher_thread_active) break; |
| |
| std::lock_guard<std::mutex> lock(alarms_mutex); |
| alarm_t* alarm; |
| |
| // Take into account that the alarm may get cancelled before we get to it. |
| // We're done here if there are no alarms or the alarm at the front is in |
| // the future. Exit right away since there's nothing left to do. |
| if (list_is_empty(alarms) || |
| (alarm = static_cast<alarm_t*>(list_front(alarms)))->deadline > now()) { |
| reschedule_root_alarm(); |
| continue; |
| } |
| |
| list_remove(alarms, alarm); |
| |
| if (alarm->is_periodic) { |
| alarm->prev_deadline = alarm->deadline; |
| schedule_next_instance(alarm); |
| alarm->stats.rescheduled_count++; |
| } |
| reschedule_root_alarm(); |
| |
| // Enqueue the alarm for processing |
| fixed_queue_enqueue(alarm->queue, alarm); |
| } |
| |
| LOG_DEBUG(LOG_TAG, "%s Callback thread exited", __func__); |
| } |
| |
| static bool timer_create_internal(const clockid_t clock_id, timer_t* timer) { |
| CHECK(timer != NULL); |
| |
| struct sigevent sigevent; |
| // create timer with RT priority thread |
| pthread_attr_t thread_attr; |
| pthread_attr_init(&thread_attr); |
| pthread_attr_setschedpolicy(&thread_attr, SCHED_FIFO); |
| struct sched_param param; |
| param.sched_priority = THREAD_RT_PRIORITY; |
| pthread_attr_setschedparam(&thread_attr, ¶m); |
| |
| memset(&sigevent, 0, sizeof(sigevent)); |
| sigevent.sigev_notify = SIGEV_THREAD; |
| sigevent.sigev_notify_function = (void (*)(union sigval))timer_callback; |
| sigevent.sigev_notify_attributes = (void*)(&thread_attr); |
| if (timer_create(clock_id, &sigevent, timer) == -1) { |
| LOG_ERROR(LOG_TAG, "%s unable to create timer with clock %d: %s", __func__, |
| clock_id, strerror(errno)); |
| if (clock_id == CLOCK_BOOTTIME_ALARM) { |
| LOG_ERROR(LOG_TAG, |
| "The kernel might not have support for " |
| "timer_create(CLOCK_BOOTTIME_ALARM): " |
| "https://lwn.net/Articles/429925/"); |
| LOG_ERROR(LOG_TAG, |
| "See following patches: " |
| "https://git.kernel.org/cgit/linux/kernel/git/torvalds/" |
| "linux.git/log/?qt=grep&q=CLOCK_BOOTTIME_ALARM"); |
| } |
| return false; |
| } |
| |
| return true; |
| } |
| |
| static void update_scheduling_stats(alarm_stats_t* stats, period_ms_t now_ms, |
| period_ms_t deadline_ms, |
| period_ms_t execution_delta_ms) { |
| stats->total_updates++; |
| stats->last_update_ms = now_ms; |
| |
| update_stat(&stats->callback_execution, execution_delta_ms); |
| |
| if (deadline_ms < now_ms) { |
| // Overdue scheduling |
| period_ms_t delta_ms = now_ms - deadline_ms; |
| update_stat(&stats->overdue_scheduling, delta_ms); |
| } else if (deadline_ms > now_ms) { |
| // Premature scheduling |
| period_ms_t delta_ms = deadline_ms - now_ms; |
| update_stat(&stats->premature_scheduling, delta_ms); |
| } |
| } |
| |
| static void dump_stat(int fd, stat_t* stat, const char* description) { |
| period_ms_t average_time_ms = 0; |
| if (stat->count != 0) average_time_ms = stat->total_ms / stat->count; |
| |
| dprintf(fd, "%-51s: %llu / %llu / %llu\n", description, |
| (unsigned long long)stat->total_ms, (unsigned long long)stat->max_ms, |
| (unsigned long long)average_time_ms); |
| } |
| |
| void alarm_debug_dump(int fd) { |
| dprintf(fd, "\nBluetooth Alarms Statistics:\n"); |
| |
| std::lock_guard<std::mutex> lock(alarms_mutex); |
| |
| if (alarms == NULL) { |
| dprintf(fd, " None\n"); |
| return; |
| } |
| |
| period_ms_t just_now = now(); |
| |
| dprintf(fd, " Total Alarms: %zu\n\n", list_length(alarms)); |
| |
| // Dump info for each alarm |
| for (list_node_t* node = list_begin(alarms); node != list_end(alarms); |
| node = list_next(node)) { |
| alarm_t* alarm = (alarm_t*)list_node(node); |
| alarm_stats_t* stats = &alarm->stats; |
| |
| dprintf(fd, " Alarm : %s (%s)\n", stats->name, |
| (alarm->is_periodic) ? "PERIODIC" : "SINGLE"); |
| |
| dprintf(fd, "%-51s: %zu / %zu / %zu / %zu\n", |
| " Action counts (sched/resched/exec/cancel)", |
| stats->scheduled_count, stats->rescheduled_count, |
| stats->callback_execution.count, stats->canceled_count); |
| |
| dprintf(fd, "%-51s: %zu / %zu\n", |
| " Deviation counts (overdue/premature)", |
| stats->overdue_scheduling.count, stats->premature_scheduling.count); |
| |
| dprintf(fd, "%-51s: %llu / %llu / %lld\n", |
| " Time in ms (since creation/interval/remaining)", |
| (unsigned long long)(just_now - alarm->creation_time), |
| (unsigned long long)alarm->period, |
| (long long)(alarm->deadline - just_now)); |
| |
| dump_stat(fd, &stats->callback_execution, |
| " Callback execution time in ms (total/max/avg)"); |
| |
| dump_stat(fd, &stats->overdue_scheduling, |
| " Overdue scheduling time in ms (total/max/avg)"); |
| |
| dump_stat(fd, &stats->premature_scheduling, |
| " Premature scheduling time in ms (total/max/avg)"); |
| |
| dprintf(fd, "\n"); |
| } |
| } |