1 /****************************************************************************** 2 * 3 * Copyright 2015 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_wakelock" 20 21 #include <errno.h> 22 #include <fcntl.h> 23 #include <hardware/bluetooth.h> 24 #include <inttypes.h> 25 #include <limits.h> 26 #include <pthread.h> 27 #include <string.h> 28 #include <sys/stat.h> 29 #include <sys/types.h> 30 #include <time.h> 31 #include <unistd.h> 32 33 #include <mutex> 34 #include <string> 35 36 #include "base/logging.h" 37 #include "osi/include/alarm.h" 38 #include "osi/include/allocator.h" 39 #include "osi/include/log.h" 40 #include "osi/include/metrics.h" 41 #include "osi/include/osi.h" 42 #include "osi/include/thread.h" 43 #include "osi/include/wakelock.h" 44 45 using system_bt_osi::BluetoothMetricsLogger; 46 47 static bt_os_callouts_t* wakelock_os_callouts = NULL; 48 static bool is_native = true; 49 50 static const clockid_t CLOCK_ID = CLOCK_BOOTTIME; 51 static const char* WAKE_LOCK_ID = "bluetooth_timer"; 52 static const std::string DEFAULT_WAKE_LOCK_PATH = "/sys/power/wake_lock"; 53 static const std::string DEFAULT_WAKE_UNLOCK_PATH = "/sys/power/wake_unlock"; 54 static std::string wake_lock_path; 55 static std::string wake_unlock_path; 56 static ssize_t locked_id_len = -1; 57 static pthread_once_t initialized = PTHREAD_ONCE_INIT; 58 static int wake_lock_fd = INVALID_FD; 59 static int wake_unlock_fd = INVALID_FD; 60 61 // Wakelock statistics for the "bluetooth_timer" 62 typedef struct { 63 bool is_acquired; 64 size_t acquired_count; 65 size_t released_count; 66 size_t acquired_errors; 67 size_t released_errors; 68 period_ms_t min_acquired_interval_ms; 69 period_ms_t max_acquired_interval_ms; 70 period_ms_t last_acquired_interval_ms; 71 period_ms_t total_acquired_interval_ms; 72 period_ms_t last_acquired_timestamp_ms; 73 period_ms_t last_released_timestamp_ms; 74 period_ms_t last_reset_timestamp_ms; 75 int last_acquired_error; 76 int last_released_error; 77 } wakelock_stats_t; 78 79 static wakelock_stats_t wakelock_stats; 80 81 // This mutex ensures that the functions that update and dump the statistics 82 // are executed serially. 83 static std::mutex stats_mutex; 84 85 static bt_status_t wakelock_acquire_callout(void); 86 static bt_status_t wakelock_acquire_native(void); 87 static bt_status_t wakelock_release_callout(void); 88 static bt_status_t wakelock_release_native(void); 89 static void wakelock_initialize(void); 90 static void wakelock_initialize_native(void); 91 static void reset_wakelock_stats(void); 92 static void update_wakelock_acquired_stats(bt_status_t acquired_status); 93 static void update_wakelock_released_stats(bt_status_t released_status); 94 95 void wakelock_set_os_callouts(bt_os_callouts_t* callouts) { 96 wakelock_os_callouts = callouts; 97 is_native = (wakelock_os_callouts == NULL); 98 LOG_INFO(LOG_TAG, "%s set to %s", __func__, 99 (is_native) ? "native" : "non-native"); 100 } 101 102 bool wakelock_acquire(void) { 103 pthread_once(&initialized, wakelock_initialize); 104 105 bt_status_t status = BT_STATUS_FAIL; 106 107 if (is_native) 108 status = wakelock_acquire_native(); 109 else 110 status = wakelock_acquire_callout(); 111 112 update_wakelock_acquired_stats(status); 113 114 if (status != BT_STATUS_SUCCESS) 115 LOG_ERROR(LOG_TAG, "%s unable to acquire wake lock: %d", __func__, status); 116 117 return (status == BT_STATUS_SUCCESS); 118 } 119 120 static bt_status_t wakelock_acquire_callout(void) { 121 return static_cast<bt_status_t>( 122 wakelock_os_callouts->acquire_wake_lock(WAKE_LOCK_ID)); 123 } 124 125 static bt_status_t wakelock_acquire_native(void) { 126 if (wake_lock_fd == INVALID_FD) { 127 LOG_ERROR(LOG_TAG, "%s lock not acquired, invalid fd", __func__); 128 return BT_STATUS_PARM_INVALID; 129 } 130 131 if (wake_unlock_fd == INVALID_FD) { 132 LOG_ERROR(LOG_TAG, "%s not acquiring lock: can't release lock", __func__); 133 return BT_STATUS_PARM_INVALID; 134 } 135 136 long lock_name_len = strlen(WAKE_LOCK_ID); 137 locked_id_len = write(wake_lock_fd, WAKE_LOCK_ID, lock_name_len); 138 if (locked_id_len == -1) { 139 LOG_ERROR(LOG_TAG, "%s wake lock not acquired: %s", __func__, 140 strerror(errno)); 141 return BT_STATUS_FAIL; 142 } else if (locked_id_len < lock_name_len) { 143 // TODO (jamuraa): this is weird. maybe we should release and retry. 144 LOG_WARN(LOG_TAG, "%s wake lock truncated to %zd chars", __func__, 145 locked_id_len); 146 } 147 return BT_STATUS_SUCCESS; 148 } 149 150 bool wakelock_release(void) { 151 pthread_once(&initialized, wakelock_initialize); 152 153 bt_status_t status = BT_STATUS_FAIL; 154 155 if (is_native) 156 status = wakelock_release_native(); 157 else 158 status = wakelock_release_callout(); 159 160 update_wakelock_released_stats(status); 161 162 return (status == BT_STATUS_SUCCESS); 163 } 164 165 static bt_status_t wakelock_release_callout(void) { 166 return static_cast<bt_status_t>( 167 wakelock_os_callouts->release_wake_lock(WAKE_LOCK_ID)); 168 } 169 170 static bt_status_t wakelock_release_native(void) { 171 if (wake_unlock_fd == INVALID_FD) { 172 LOG_ERROR(LOG_TAG, "%s lock not released, invalid fd", __func__); 173 return BT_STATUS_PARM_INVALID; 174 } 175 176 ssize_t wrote_name_len = write(wake_unlock_fd, WAKE_LOCK_ID, locked_id_len); 177 if (wrote_name_len == -1) { 178 LOG_ERROR(LOG_TAG, "%s can't release wake lock: %s", __func__, 179 strerror(errno)); 180 } else if (wrote_name_len < locked_id_len) { 181 LOG_ERROR(LOG_TAG, "%s lock release only wrote %zd, assuming released", 182 __func__, wrote_name_len); 183 } 184 return BT_STATUS_SUCCESS; 185 } 186 187 static void wakelock_initialize(void) { 188 reset_wakelock_stats(); 189 190 if (is_native) wakelock_initialize_native(); 191 } 192 193 static void wakelock_initialize_native(void) { 194 LOG_DEBUG(LOG_TAG, "%s opening wake locks", __func__); 195 196 if (wake_lock_path.empty()) wake_lock_path = DEFAULT_WAKE_LOCK_PATH; 197 198 wake_lock_fd = open(wake_lock_path.c_str(), O_RDWR | O_CLOEXEC); 199 if (wake_lock_fd == INVALID_FD) { 200 LOG_ERROR(LOG_TAG, "%s can't open wake lock %s: %s", __func__, 201 wake_lock_path.c_str(), strerror(errno)); 202 CHECK(wake_lock_fd != INVALID_FD); 203 } 204 205 if (wake_unlock_path.empty()) wake_unlock_path = DEFAULT_WAKE_UNLOCK_PATH; 206 207 wake_unlock_fd = open(wake_unlock_path.c_str(), O_RDWR | O_CLOEXEC); 208 if (wake_unlock_fd == INVALID_FD) { 209 LOG_ERROR(LOG_TAG, "%s can't open wake unlock %s: %s", __func__, 210 wake_unlock_path.c_str(), strerror(errno)); 211 CHECK(wake_unlock_fd != INVALID_FD); 212 } 213 } 214 215 void wakelock_cleanup(void) { 216 wake_lock_path.clear(); 217 wake_unlock_path.clear(); 218 initialized = PTHREAD_ONCE_INIT; 219 } 220 221 void wakelock_set_paths(const char* lock_path, const char* unlock_path) { 222 if (lock_path) wake_lock_path = lock_path; 223 224 if (unlock_path) wake_unlock_path = unlock_path; 225 } 226 227 static period_ms_t now(void) { 228 struct timespec ts; 229 if (clock_gettime(CLOCK_ID, &ts) == -1) { 230 LOG_ERROR(LOG_TAG, "%s unable to get current time: %s", __func__, 231 strerror(errno)); 232 return 0; 233 } 234 235 return (ts.tv_sec * 1000LL) + (ts.tv_nsec / 1000000LL); 236 } 237 238 // Reset the Bluetooth wakelock statistics. 239 // This function is thread-safe. 240 static void reset_wakelock_stats(void) { 241 std::lock_guard<std::mutex> lock(stats_mutex); 242 243 wakelock_stats.is_acquired = false; 244 wakelock_stats.acquired_count = 0; 245 wakelock_stats.released_count = 0; 246 wakelock_stats.acquired_errors = 0; 247 wakelock_stats.released_errors = 0; 248 wakelock_stats.min_acquired_interval_ms = 0; 249 wakelock_stats.max_acquired_interval_ms = 0; 250 wakelock_stats.last_acquired_interval_ms = 0; 251 wakelock_stats.total_acquired_interval_ms = 0; 252 wakelock_stats.last_acquired_timestamp_ms = 0; 253 wakelock_stats.last_released_timestamp_ms = 0; 254 wakelock_stats.last_reset_timestamp_ms = now(); 255 } 256 257 // 258 // Update the Bluetooth acquire wakelock statistics. 259 // 260 // This function should be called every time when the wakelock is acquired. 261 // |acquired_status| is the status code that was return when the wakelock was 262 // acquired. 263 // This function is thread-safe. 264 // 265 static void update_wakelock_acquired_stats(bt_status_t acquired_status) { 266 const period_ms_t now_ms = now(); 267 268 std::lock_guard<std::mutex> lock(stats_mutex); 269 270 if (acquired_status != BT_STATUS_SUCCESS) { 271 wakelock_stats.acquired_errors++; 272 wakelock_stats.last_acquired_error = acquired_status; 273 } 274 275 if (wakelock_stats.is_acquired) { 276 return; 277 } 278 279 wakelock_stats.is_acquired = true; 280 wakelock_stats.acquired_count++; 281 wakelock_stats.last_acquired_timestamp_ms = now_ms; 282 283 BluetoothMetricsLogger::GetInstance()->LogWakeEvent( 284 system_bt_osi::WAKE_EVENT_ACQUIRED, "", "", now_ms); 285 } 286 287 // 288 // Update the Bluetooth release wakelock statistics. 289 // 290 // This function should be called every time when the wakelock is released. 291 // |released_status| is the status code that was return when the wakelock was 292 // released. 293 // This function is thread-safe. 294 // 295 static void update_wakelock_released_stats(bt_status_t released_status) { 296 const period_ms_t now_ms = now(); 297 298 std::lock_guard<std::mutex> lock(stats_mutex); 299 300 if (released_status != BT_STATUS_SUCCESS) { 301 wakelock_stats.released_errors++; 302 wakelock_stats.last_released_error = released_status; 303 } 304 305 if (!wakelock_stats.is_acquired) { 306 return; 307 } 308 309 wakelock_stats.is_acquired = false; 310 wakelock_stats.released_count++; 311 wakelock_stats.last_released_timestamp_ms = now_ms; 312 313 // Compute the acquired interval and update the statistics 314 period_ms_t delta_ms = now_ms - wakelock_stats.last_acquired_timestamp_ms; 315 if (delta_ms < wakelock_stats.min_acquired_interval_ms || 316 wakelock_stats.released_count == 1) { 317 wakelock_stats.min_acquired_interval_ms = delta_ms; 318 } 319 if (delta_ms > wakelock_stats.max_acquired_interval_ms) { 320 wakelock_stats.max_acquired_interval_ms = delta_ms; 321 } 322 wakelock_stats.last_acquired_interval_ms = delta_ms; 323 wakelock_stats.total_acquired_interval_ms += delta_ms; 324 325 BluetoothMetricsLogger::GetInstance()->LogWakeEvent( 326 system_bt_osi::WAKE_EVENT_RELEASED, "", "", now_ms); 327 } 328 329 void wakelock_debug_dump(int fd) { 330 const period_ms_t now_ms = now(); 331 332 std::lock_guard<std::mutex> lock(stats_mutex); 333 334 // Compute the last acquired interval if the wakelock is still acquired 335 period_ms_t delta_ms = 0; 336 period_ms_t last_interval = wakelock_stats.last_acquired_interval_ms; 337 period_ms_t min_interval = wakelock_stats.min_acquired_interval_ms; 338 period_ms_t max_interval = wakelock_stats.max_acquired_interval_ms; 339 period_ms_t ave_interval = 0; 340 341 if (wakelock_stats.is_acquired) { 342 delta_ms = now_ms - wakelock_stats.last_acquired_timestamp_ms; 343 if (delta_ms > max_interval) max_interval = delta_ms; 344 if (delta_ms < min_interval) min_interval = delta_ms; 345 last_interval = delta_ms; 346 } 347 period_ms_t total_interval = 348 wakelock_stats.total_acquired_interval_ms + delta_ms; 349 350 if (wakelock_stats.acquired_count > 0) 351 ave_interval = total_interval / wakelock_stats.acquired_count; 352 353 dprintf(fd, "\nBluetooth Wakelock Statistics:\n"); 354 dprintf(fd, " Is acquired : %s\n", 355 wakelock_stats.is_acquired ? "true" : "false"); 356 dprintf(fd, " Acquired/released count : %zu / %zu\n", 357 wakelock_stats.acquired_count, wakelock_stats.released_count); 358 dprintf(fd, " Acquired/released error count : %zu / %zu\n", 359 wakelock_stats.acquired_errors, wakelock_stats.released_errors); 360 dprintf(fd, " Last acquire/release error code: %d / %d\n", 361 wakelock_stats.last_acquired_error, 362 wakelock_stats.last_released_error); 363 dprintf(fd, " Last acquired time (ms) : %llu\n", 364 (unsigned long long)last_interval); 365 dprintf(fd, " Acquired time min/max/avg (ms) : %llu / %llu / %llu\n", 366 (unsigned long long)min_interval, (unsigned long long)max_interval, 367 (unsigned long long)ave_interval); 368 dprintf(fd, " Total acquired time (ms) : %llu\n", 369 (unsigned long long)total_interval); 370 dprintf( 371 fd, " Total run time (ms) : %llu\n", 372 (unsigned long long)(now_ms - wakelock_stats.last_reset_timestamp_ms)); 373 } 374
