Mark Salyzyn | 655b949 | 2014-10-02 11:12:28 -0700 | [diff] [blame] | 1 | /* |
| 2 | ** Copyright 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 | |
Tom Cherry | f623f02 | 2019-01-10 10:37:36 -0800 | [diff] [blame] | 17 | #include <log/log_properties.h> |
| 18 | |
Mark Salyzyn | 655b949 | 2014-10-02 11:12:28 -0700 | [diff] [blame] | 19 | #include <ctype.h> |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 20 | #include <pthread.h> |
| 21 | #include <stdlib.h> |
Mark Salyzyn | 655b949 | 2014-10-02 11:12:28 -0700 | [diff] [blame] | 22 | #include <string.h> |
Mark Salyzyn | cbf691a | 2016-09-26 13:21:05 -0700 | [diff] [blame] | 23 | #include <unistd.h> |
Mark Salyzyn | 655b949 | 2014-10-02 11:12:28 -0700 | [diff] [blame] | 24 | |
Tom Cherry | 4004460 | 2020-01-16 15:58:02 -0800 | [diff] [blame] | 25 | #include <algorithm> |
| 26 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 27 | #include <android-base/macros.h> |
| 28 | |
Mark Salyzyn | cbf691a | 2016-09-26 13:21:05 -0700 | [diff] [blame] | 29 | #include <private/android_logger.h> |
Mark Salyzyn | 655b949 | 2014-10-02 11:12:28 -0700 | [diff] [blame] | 30 | |
Tom Cherry | 77ddcd3 | 2020-01-27 08:35:13 -0800 | [diff] [blame] | 31 | #include "logger_write.h" |
| 32 | |
Tom Cherry | c377c7d | 2020-01-27 15:45:52 -0800 | [diff] [blame] | 33 | #ifdef __ANDROID__ |
| 34 | #define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_ |
| 35 | #include <sys/_system_properties.h> |
| 36 | |
Mark Salyzyn | 4c68f3f | 2015-11-06 12:26:52 -0800 | [diff] [blame] | 37 | static pthread_mutex_t lock_loggable = PTHREAD_MUTEX_INITIALIZER; |
| 38 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 39 | static bool trylock() { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 40 | /* |
| 41 | * If we trigger a signal handler in the middle of locked activity and the |
| 42 | * signal handler logs a message, we could get into a deadlock state. |
| 43 | */ |
| 44 | /* |
| 45 | * Any contention, and we can turn around and use the non-cached method |
| 46 | * in less time than the system call associated with a mutex to deal with |
| 47 | * the contention. |
| 48 | */ |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 49 | return pthread_mutex_trylock(&lock_loggable) == 0; |
Mark Salyzyn | 4c68f3f | 2015-11-06 12:26:52 -0800 | [diff] [blame] | 50 | } |
| 51 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 52 | static void unlock() { |
| 53 | pthread_mutex_unlock(&lock_loggable); |
Mark Salyzyn | 4c68f3f | 2015-11-06 12:26:52 -0800 | [diff] [blame] | 54 | } |
| 55 | |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 56 | struct cache { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 57 | const prop_info* pinfo; |
| 58 | uint32_t serial; |
Mark Salyzyn | cbf691a | 2016-09-26 13:21:05 -0700 | [diff] [blame] | 59 | }; |
| 60 | |
| 61 | struct cache_char { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 62 | struct cache cache; |
| 63 | unsigned char c; |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 64 | }; |
| 65 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 66 | static int check_cache(struct cache* cache) { |
| 67 | return cache->pinfo && __system_property_serial(cache->pinfo) != cache->serial; |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 68 | } |
| 69 | |
Mark Salyzyn | 233e475 | 2015-12-04 10:59:45 -0800 | [diff] [blame] | 70 | #define BOOLEAN_TRUE 0xFF |
| 71 | #define BOOLEAN_FALSE 0xFE |
| 72 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 73 | static void refresh_cache(struct cache_char* cache, const char* key) { |
| 74 | char buf[PROP_VALUE_MAX]; |
Mark Salyzyn | 655b949 | 2014-10-02 11:12:28 -0700 | [diff] [blame] | 75 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 76 | if (!cache->cache.pinfo) { |
| 77 | cache->cache.pinfo = __system_property_find(key); |
Mark Salyzyn | cbf691a | 2016-09-26 13:21:05 -0700 | [diff] [blame] | 78 | if (!cache->cache.pinfo) { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 79 | return; |
Mark Salyzyn | 655b949 | 2014-10-02 11:12:28 -0700 | [diff] [blame] | 80 | } |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 81 | } |
| 82 | cache->cache.serial = __system_property_serial(cache->cache.pinfo); |
| 83 | __system_property_read(cache->cache.pinfo, 0, buf); |
| 84 | switch (buf[0]) { |
| 85 | case 't': |
| 86 | case 'T': |
| 87 | cache->c = strcasecmp(buf + 1, "rue") ? buf[0] : BOOLEAN_TRUE; |
| 88 | break; |
| 89 | case 'f': |
| 90 | case 'F': |
| 91 | cache->c = strcasecmp(buf + 1, "alse") ? buf[0] : BOOLEAN_FALSE; |
| 92 | break; |
Mark Salyzyn | 233e475 | 2015-12-04 10:59:45 -0800 | [diff] [blame] | 93 | default: |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 94 | cache->c = buf[0]; |
| 95 | } |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 96 | } |
Mark Salyzyn | 655b949 | 2014-10-02 11:12:28 -0700 | [diff] [blame] | 97 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 98 | static int __android_log_level(const char* tag, size_t tag_len) { |
| 99 | if (tag == nullptr || tag_len == 0) { |
Tom Cherry | 77ddcd3 | 2020-01-27 08:35:13 -0800 | [diff] [blame] | 100 | auto& tag_string = GetDefaultTag(); |
| 101 | tag = tag_string.c_str(); |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 102 | tag_len = tag_string.size(); |
Tom Cherry | 77ddcd3 | 2020-01-27 08:35:13 -0800 | [diff] [blame] | 103 | } |
| 104 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 105 | /* |
| 106 | * Single layer cache of four properties. Priorities are: |
| 107 | * log.tag.<tag> |
| 108 | * persist.log.tag.<tag> |
| 109 | * log.tag |
| 110 | * persist.log.tag |
| 111 | * Where the missing tag matches all tags and becomes the |
| 112 | * system global default. We do not support ro.log.tag* . |
| 113 | */ |
Elliott Hughes | 80883da | 2021-03-04 07:55:22 -0800 | [diff] [blame] | 114 | static std::string* last_tag = new std::string; |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 115 | static uint32_t global_serial; |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 116 | uint32_t current_global_serial; |
| 117 | static cache_char tag_cache[2]; |
| 118 | static cache_char global_cache[2]; |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 119 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 120 | static const char* log_namespace = "persist.log.tag."; |
| 121 | char key[strlen(log_namespace) + tag_len + 1]; |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 122 | strcpy(key, log_namespace); |
| 123 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 124 | bool locked = trylock(); |
| 125 | bool change_detected, global_change_detected; |
| 126 | global_change_detected = change_detected = !locked; |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 127 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 128 | char c = 0; |
| 129 | if (locked) { |
| 130 | // Check all known serial numbers for changes. |
| 131 | for (size_t i = 0; i < arraysize(tag_cache); ++i) { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 132 | if (check_cache(&tag_cache[i].cache)) { |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 133 | change_detected = true; |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 134 | } |
| 135 | } |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 136 | for (size_t i = 0; i < arraysize(global_cache); ++i) { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 137 | if (check_cache(&global_cache[i].cache)) { |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 138 | global_change_detected = true; |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 139 | } |
| 140 | } |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 141 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 142 | current_global_serial = __system_property_area_serial(); |
| 143 | if (current_global_serial != global_serial) { |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 144 | global_change_detected = change_detected = true; |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 145 | } |
| 146 | } |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 147 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 148 | if (tag_len != 0) { |
| 149 | bool local_change_detected = change_detected; |
| 150 | if (locked) { |
| 151 | // compare() rather than == because tag isn't guaranteed 0-terminated. |
Elliott Hughes | 80883da | 2021-03-04 07:55:22 -0800 | [diff] [blame] | 152 | if (last_tag->compare(0, last_tag->size(), tag, tag_len) != 0) { |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 153 | // Invalidate log.tag.<tag> cache. |
| 154 | for (size_t i = 0; i < arraysize(tag_cache); ++i) { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 155 | tag_cache[i].cache.pinfo = NULL; |
| 156 | tag_cache[i].c = '\0'; |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 157 | } |
Elliott Hughes | 80883da | 2021-03-04 07:55:22 -0800 | [diff] [blame] | 158 | last_tag->assign(tag, tag_len); |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 159 | local_change_detected = true; |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 160 | } |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 161 | } |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 162 | *stpncpy(key + strlen(log_namespace), tag, tag_len) = '\0'; |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 163 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 164 | for (size_t i = 0; i < arraysize(tag_cache); ++i) { |
| 165 | cache_char* cache = &tag_cache[i]; |
| 166 | cache_char temp_cache; |
Mark Salyzyn | 655b949 | 2014-10-02 11:12:28 -0700 | [diff] [blame] | 167 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 168 | if (!locked) { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 169 | temp_cache.cache.pinfo = NULL; |
| 170 | temp_cache.c = '\0'; |
| 171 | cache = &temp_cache; |
| 172 | } |
| 173 | if (local_change_detected) { |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 174 | refresh_cache(cache, i == 0 ? key : key + strlen("persist.")); |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 175 | } |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 176 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 177 | if (cache->c) { |
| 178 | c = cache->c; |
| 179 | break; |
| 180 | } |
Mark Salyzyn | 655b949 | 2014-10-02 11:12:28 -0700 | [diff] [blame] | 181 | } |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 182 | } |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 183 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 184 | switch (toupper(c)) { /* if invalid, resort to global */ |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 185 | case 'V': |
| 186 | case 'D': |
| 187 | case 'I': |
| 188 | case 'W': |
| 189 | case 'E': |
| 190 | case 'F': /* Not officially supported */ |
| 191 | case 'A': |
| 192 | case 'S': |
Mark Salyzyn | 233e475 | 2015-12-04 10:59:45 -0800 | [diff] [blame] | 193 | case BOOLEAN_FALSE: /* Not officially supported */ |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 194 | break; |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 195 | default: |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 196 | /* clear '.' after log.tag */ |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 197 | key[strlen(log_namespace) - 1] = '\0'; |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 198 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 199 | for (size_t i = 0; i < arraysize(global_cache); ++i) { |
| 200 | cache_char* cache = &global_cache[i]; |
| 201 | cache_char temp_cache; |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 202 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 203 | if (!locked) { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 204 | temp_cache = *cache; |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 205 | if (temp_cache.cache.pinfo != cache->cache.pinfo) { // check atomic |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 206 | temp_cache.cache.pinfo = NULL; |
| 207 | temp_cache.c = '\0'; |
| 208 | } |
| 209 | cache = &temp_cache; |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 210 | } |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 211 | if (global_change_detected) { |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 212 | refresh_cache(cache, i == 0 ? key : key + strlen("persist.")); |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 213 | } |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 214 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 215 | if (cache->c) { |
| 216 | c = cache->c; |
| 217 | break; |
| 218 | } |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 219 | } |
| 220 | break; |
| 221 | } |
| 222 | |
Elliott Hughes | c1a5ec5 | 2021-02-09 13:29:33 -0800 | [diff] [blame] | 223 | if (locked) { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 224 | global_serial = current_global_serial; |
| 225 | unlock(); |
| 226 | } |
| 227 | |
| 228 | switch (toupper(c)) { |
| 229 | /* clang-format off */ |
Mark Salyzyn | 500cd1c | 2015-03-12 15:46:29 -0700 | [diff] [blame] | 230 | case 'V': return ANDROID_LOG_VERBOSE; |
| 231 | case 'D': return ANDROID_LOG_DEBUG; |
| 232 | case 'I': return ANDROID_LOG_INFO; |
| 233 | case 'W': return ANDROID_LOG_WARN; |
| 234 | case 'E': return ANDROID_LOG_ERROR; |
| 235 | case 'F': /* FALLTHRU */ /* Not officially supported */ |
| 236 | case 'A': return ANDROID_LOG_FATAL; |
Mark Salyzyn | 233e475 | 2015-12-04 10:59:45 -0800 | [diff] [blame] | 237 | case BOOLEAN_FALSE: /* FALLTHRU */ /* Not Officially supported */ |
Tom Cherry | 4004460 | 2020-01-16 15:58:02 -0800 | [diff] [blame] | 238 | case 'S': return ANDROID_LOG_SILENT; |
Tom Cherry | f623f02 | 2019-01-10 10:37:36 -0800 | [diff] [blame] | 239 | /* clang-format on */ |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 240 | } |
Tom Cherry | 4004460 | 2020-01-16 15:58:02 -0800 | [diff] [blame] | 241 | return -1; |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 242 | } |
| 243 | |
Tom Cherry | 3d6a878 | 2019-02-08 11:46:19 -0800 | [diff] [blame] | 244 | int __android_log_is_loggable_len(int prio, const char* tag, size_t len, int default_prio) { |
Tom Cherry | 4004460 | 2020-01-16 15:58:02 -0800 | [diff] [blame] | 245 | int minimum_log_priority = __android_log_get_minimum_priority(); |
| 246 | int property_log_level = __android_log_level(tag, len); |
| 247 | |
| 248 | if (property_log_level >= 0 && minimum_log_priority != ANDROID_LOG_DEFAULT) { |
| 249 | return prio >= std::min(property_log_level, minimum_log_priority); |
| 250 | } else if (property_log_level >= 0) { |
| 251 | return prio >= property_log_level; |
| 252 | } else if (minimum_log_priority != ANDROID_LOG_DEFAULT) { |
| 253 | return prio >= minimum_log_priority; |
| 254 | } else { |
| 255 | return prio >= default_prio; |
| 256 | } |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 257 | } |
| 258 | |
Tom Cherry | 3d6a878 | 2019-02-08 11:46:19 -0800 | [diff] [blame] | 259 | int __android_log_is_loggable(int prio, const char* tag, int default_prio) { |
Tom Cherry | 4004460 | 2020-01-16 15:58:02 -0800 | [diff] [blame] | 260 | auto len = tag ? strlen(tag) : 0; |
| 261 | return __android_log_is_loggable_len(prio, tag, len, default_prio); |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 262 | } |
| 263 | |
Tom Cherry | 3d6a878 | 2019-02-08 11:46:19 -0800 | [diff] [blame] | 264 | int __android_log_is_debuggable() { |
Tom Cherry | 5ad3568 | 2020-07-27 15:31:44 -0700 | [diff] [blame] | 265 | static int is_debuggable = [] { |
| 266 | char value[PROP_VALUE_MAX] = {}; |
| 267 | return __system_property_get("ro.debuggable", value) > 0 && !strcmp(value, "1"); |
| 268 | }(); |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 269 | |
Tom Cherry | 5ad3568 | 2020-07-27 15:31:44 -0700 | [diff] [blame] | 270 | return is_debuggable; |
Mark Salyzyn | 509c142 | 2016-03-25 15:50:46 -0700 | [diff] [blame] | 271 | } |
| 272 | |
Mark Salyzyn | 4c68f3f | 2015-11-06 12:26:52 -0800 | [diff] [blame] | 273 | /* |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 274 | * For properties that are read often, but generally remain constant. |
| 275 | * Since a change is rare, we will accept a trylock failure gracefully. |
| 276 | * Use a separate lock from is_loggable to keep contention down b/25563384. |
Mark Salyzyn | 4c68f3f | 2015-11-06 12:26:52 -0800 | [diff] [blame] | 277 | */ |
Mark Salyzyn | cbf691a | 2016-09-26 13:21:05 -0700 | [diff] [blame] | 278 | struct cache2_char { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 279 | pthread_mutex_t lock; |
| 280 | uint32_t serial; |
| 281 | const char* key_persist; |
| 282 | struct cache_char cache_persist; |
| 283 | const char* key_ro; |
| 284 | struct cache_char cache_ro; |
| 285 | unsigned char (*const evaluate)(const struct cache2_char* self); |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 286 | }; |
Mark Salyzyn | 4c68f3f | 2015-11-06 12:26:52 -0800 | [diff] [blame] | 287 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 288 | static inline unsigned char do_cache2_char(struct cache2_char* self) { |
| 289 | uint32_t current_serial; |
| 290 | int change_detected; |
| 291 | unsigned char c; |
Mark Salyzyn | 2cdfd8e | 2015-09-08 08:32:01 -0700 | [diff] [blame] | 292 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 293 | if (pthread_mutex_trylock(&self->lock)) { |
| 294 | /* We are willing to accept some race in this context */ |
| 295 | return self->evaluate(self); |
| 296 | } |
Mark Salyzyn | 2cdfd8e | 2015-09-08 08:32:01 -0700 | [diff] [blame] | 297 | |
Tom Cherry | f623f02 | 2019-01-10 10:37:36 -0800 | [diff] [blame] | 298 | change_detected = check_cache(&self->cache_persist.cache) || check_cache(&self->cache_ro.cache); |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 299 | current_serial = __system_property_area_serial(); |
| 300 | if (current_serial != self->serial) { |
| 301 | change_detected = 1; |
| 302 | } |
| 303 | if (change_detected) { |
| 304 | refresh_cache(&self->cache_persist, self->key_persist); |
| 305 | refresh_cache(&self->cache_ro, self->key_ro); |
| 306 | self->serial = current_serial; |
| 307 | } |
| 308 | c = self->evaluate(self); |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 309 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 310 | pthread_mutex_unlock(&self->lock); |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 311 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 312 | return c; |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 313 | } |
| 314 | |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 315 | /* |
| 316 | * Security state generally remains constant, but the DO must be able |
| 317 | * to turn off logging should it become spammy after an attack is detected. |
| 318 | */ |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 319 | static unsigned char evaluate_security(const struct cache2_char* self) { |
| 320 | unsigned char c = self->cache_ro.c; |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 321 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 322 | return (c != BOOLEAN_FALSE) && c && (self->cache_persist.c == BOOLEAN_TRUE); |
Mark Salyzyn | d486019 | 2015-12-21 12:32:48 -0800 | [diff] [blame] | 323 | } |
Mark Salyzyn | 233e475 | 2015-12-04 10:59:45 -0800 | [diff] [blame] | 324 | |
Tom Cherry | 3d6a878 | 2019-02-08 11:46:19 -0800 | [diff] [blame] | 325 | int __android_log_security() { |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 326 | static struct cache2_char security = { |
Tom Cherry | f623f02 | 2019-01-10 10:37:36 -0800 | [diff] [blame] | 327 | PTHREAD_MUTEX_INITIALIZER, 0, |
| 328 | "persist.logd.security", {{NULL, 0xFFFFFFFF}, BOOLEAN_FALSE}, |
Rubin Xu | 68dbc9e | 2020-02-17 11:42:54 +0000 | [diff] [blame] | 329 | "ro.organization_owned", {{NULL, 0xFFFFFFFF}, BOOLEAN_FALSE}, |
Tom Cherry | f623f02 | 2019-01-10 10:37:36 -0800 | [diff] [blame] | 330 | evaluate_security}; |
Mark Salyzyn | 233e475 | 2015-12-04 10:59:45 -0800 | [diff] [blame] | 331 | |
Mark Salyzyn | 6e31568 | 2017-03-09 08:09:43 -0800 | [diff] [blame] | 332 | return do_cache2_char(&security); |
Mark Salyzyn | cbf691a | 2016-09-26 13:21:05 -0700 | [diff] [blame] | 333 | } |
| 334 | |
Tom Cherry | c377c7d | 2020-01-27 15:45:52 -0800 | [diff] [blame] | 335 | #else |
| 336 | |
| 337 | int __android_log_is_loggable(int prio, const char*, int) { |
| 338 | int minimum_priority = __android_log_get_minimum_priority(); |
| 339 | if (minimum_priority == ANDROID_LOG_DEFAULT) { |
| 340 | minimum_priority = ANDROID_LOG_INFO; |
| 341 | } |
| 342 | return prio >= minimum_priority; |
| 343 | } |
| 344 | |
| 345 | int __android_log_is_loggable_len(int prio, const char*, size_t, int def) { |
| 346 | return __android_log_is_loggable(prio, nullptr, def); |
| 347 | } |
| 348 | |
| 349 | int __android_log_is_debuggable() { |
| 350 | return 1; |
| 351 | } |
| 352 | |
Tom Cherry | cbd31f9 | 2020-07-27 11:20:29 -0700 | [diff] [blame] | 353 | #endif |