1 /* 2 * Copyright (C) 2007 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 #include <time.h> 17 #include <stdio.h> 18 #ifdef HAVE_PTHREADS 19 #include <pthread.h> 20 #endif 21 #include <unistd.h> 22 #include <errno.h> 23 #include <fcntl.h> 24 #include <string.h> 25 #include <stdlib.h> 26 #include <stdarg.h> 27 #include <sys/types.h> 28 #include <sys/stat.h> 29 30 #include <cutils/logger.h> 31 #include <cutils/logd.h> 32 #include <cutils/log.h> 33 34 #define LOG_BUF_SIZE 1024 35 36 #if FAKE_LOG_DEVICE 37 // This will be defined when building for the host. 38 #define log_open(pathname, flags) fakeLogOpen(pathname, flags) 39 #define log_writev(filedes, vector, count) fakeLogWritev(filedes, vector, count) 40 #define log_close(filedes) fakeLogClose(filedes) 41 #else 42 #define log_open(pathname, flags) open(pathname, (flags) | O_CLOEXEC) 43 #define log_writev(filedes, vector, count) writev(filedes, vector, count) 44 #define log_close(filedes) close(filedes) 45 #endif 46 47 static int __write_to_log_init(log_id_t, struct iovec *vec, size_t nr); 48 static int (*write_to_log)(log_id_t, struct iovec *vec, size_t nr) = __write_to_log_init; 49 #ifdef HAVE_PTHREADS 50 static pthread_mutex_t log_init_lock = PTHREAD_MUTEX_INITIALIZER; 51 #endif 52 53 static int log_fds[(int)LOG_ID_MAX] = { -1, -1, -1, -1 }; 54 55 /* 56 * This is used by the C++ code to decide if it should write logs through 57 * the C code. Basically, if /dev/log/... is available, we're running in 58 * the simulator rather than a desktop tool and want to use the device. 59 */ 60 static enum { 61 kLogUninitialized, kLogNotAvailable, kLogAvailable 62 } g_log_status = kLogUninitialized; 63 int __android_log_dev_available(void) 64 { 65 if (g_log_status == kLogUninitialized) { 66 if (access("/dev/"LOGGER_LOG_MAIN, W_OK) == 0) 67 g_log_status = kLogAvailable; 68 else 69 g_log_status = kLogNotAvailable; 70 } 71 72 return (g_log_status == kLogAvailable); 73 } 74 75 static int __write_to_log_null(log_id_t log_fd, struct iovec *vec, size_t nr) 76 { 77 return -1; 78 } 79 80 static int __write_to_log_kernel(log_id_t log_id, struct iovec *vec, size_t nr) 81 { 82 ssize_t ret; 83 int log_fd; 84 85 if (/*(int)log_id >= 0 &&*/ (int)log_id < (int)LOG_ID_MAX) { 86 log_fd = log_fds[(int)log_id]; 87 } else { 88 return EBADF; 89 } 90 91 do { 92 ret = log_writev(log_fd, vec, nr); 93 } while (ret < 0 && errno == EINTR); 94 95 return ret; 96 } 97 98 static int __write_to_log_init(log_id_t log_id, struct iovec *vec, size_t nr) 99 { 100 #ifdef HAVE_PTHREADS 101 pthread_mutex_lock(&log_init_lock); 102 #endif 103 104 if (write_to_log == __write_to_log_init) { 105 log_fds[LOG_ID_MAIN] = log_open("/dev/"LOGGER_LOG_MAIN, O_WRONLY); 106 log_fds[LOG_ID_RADIO] = log_open("/dev/"LOGGER_LOG_RADIO, O_WRONLY); 107 log_fds[LOG_ID_EVENTS] = log_open("/dev/"LOGGER_LOG_EVENTS, O_WRONLY); 108 log_fds[LOG_ID_SYSTEM] = log_open("/dev/"LOGGER_LOG_SYSTEM, O_WRONLY); 109 110 write_to_log = __write_to_log_kernel; 111 112 if (log_fds[LOG_ID_MAIN] < 0 || log_fds[LOG_ID_RADIO] < 0 || 113 log_fds[LOG_ID_EVENTS] < 0) { 114 log_close(log_fds[LOG_ID_MAIN]); 115 log_close(log_fds[LOG_ID_RADIO]); 116 log_close(log_fds[LOG_ID_EVENTS]); 117 log_fds[LOG_ID_MAIN] = -1; 118 log_fds[LOG_ID_RADIO] = -1; 119 log_fds[LOG_ID_EVENTS] = -1; 120 write_to_log = __write_to_log_null; 121 } 122 123 if (log_fds[LOG_ID_SYSTEM] < 0) { 124 log_fds[LOG_ID_SYSTEM] = log_fds[LOG_ID_MAIN]; 125 } 126 } 127 128 #ifdef HAVE_PTHREADS 129 pthread_mutex_unlock(&log_init_lock); 130 #endif 131 132 return write_to_log(log_id, vec, nr); 133 } 134 135 int __android_log_write(int prio, const char *tag, const char *msg) 136 { 137 struct iovec vec[3]; 138 log_id_t log_id = LOG_ID_MAIN; 139 char tmp_tag[32]; 140 141 if (!tag) 142 tag = ""; 143 144 /* XXX: This needs to go! */ 145 if (!strcmp(tag, "HTC_RIL") || 146 !strncmp(tag, "RIL", 3) || /* Any log tag with "RIL" as the prefix */ 147 !strncmp(tag, "IMS", 3) || /* Any log tag with "IMS" as the prefix */ 148 !strcmp(tag, "AT") || 149 !strcmp(tag, "GSM") || 150 !strcmp(tag, "STK") || 151 !strcmp(tag, "CDMA") || 152 !strcmp(tag, "PHONE") || 153 !strcmp(tag, "SMS")) { 154 log_id = LOG_ID_RADIO; 155 // Inform third party apps/ril/radio.. to use Rlog or RLOG 156 snprintf(tmp_tag, sizeof(tmp_tag), "use-Rlog/RLOG-%s", tag); 157 tag = tmp_tag; 158 } 159 160 vec[0].iov_base = (unsigned char *) &prio; 161 vec[0].iov_len = 1; 162 vec[1].iov_base = (void *) tag; 163 vec[1].iov_len = strlen(tag) + 1; 164 vec[2].iov_base = (void *) msg; 165 vec[2].iov_len = strlen(msg) + 1; 166 167 return write_to_log(log_id, vec, 3); 168 } 169 170 int __android_log_buf_write(int bufID, int prio, const char *tag, const char *msg) 171 { 172 struct iovec vec[3]; 173 char tmp_tag[32]; 174 175 if (!tag) 176 tag = ""; 177 178 /* XXX: This needs to go! */ 179 if ((bufID != LOG_ID_RADIO) && 180 (!strcmp(tag, "HTC_RIL") || 181 !strncmp(tag, "RIL", 3) || /* Any log tag with "RIL" as the prefix */ 182 !strncmp(tag, "IMS", 3) || /* Any log tag with "IMS" as the prefix */ 183 !strcmp(tag, "AT") || 184 !strcmp(tag, "GSM") || 185 !strcmp(tag, "STK") || 186 !strcmp(tag, "CDMA") || 187 !strcmp(tag, "PHONE") || 188 !strcmp(tag, "SMS"))) { 189 bufID = LOG_ID_RADIO; 190 // Inform third party apps/ril/radio.. to use Rlog or RLOG 191 snprintf(tmp_tag, sizeof(tmp_tag), "use-Rlog/RLOG-%s", tag); 192 tag = tmp_tag; 193 } 194 195 vec[0].iov_base = (unsigned char *) &prio; 196 vec[0].iov_len = 1; 197 vec[1].iov_base = (void *) tag; 198 vec[1].iov_len = strlen(tag) + 1; 199 vec[2].iov_base = (void *) msg; 200 vec[2].iov_len = strlen(msg) + 1; 201 202 return write_to_log(bufID, vec, 3); 203 } 204 205 int __android_log_vprint(int prio, const char *tag, const char *fmt, va_list ap) 206 { 207 char buf[LOG_BUF_SIZE]; 208 209 vsnprintf(buf, LOG_BUF_SIZE, fmt, ap); 210 211 return __android_log_write(prio, tag, buf); 212 } 213 214 int __android_log_print(int prio, const char *tag, const char *fmt, ...) 215 { 216 va_list ap; 217 char buf[LOG_BUF_SIZE]; 218 219 va_start(ap, fmt); 220 vsnprintf(buf, LOG_BUF_SIZE, fmt, ap); 221 va_end(ap); 222 223 return __android_log_write(prio, tag, buf); 224 } 225 226 int __android_log_buf_print(int bufID, int prio, const char *tag, const char *fmt, ...) 227 { 228 va_list ap; 229 char buf[LOG_BUF_SIZE]; 230 231 va_start(ap, fmt); 232 vsnprintf(buf, LOG_BUF_SIZE, fmt, ap); 233 va_end(ap); 234 235 return __android_log_buf_write(bufID, prio, tag, buf); 236 } 237 238 void __android_log_assert(const char *cond, const char *tag, 239 const char *fmt, ...) 240 { 241 char buf[LOG_BUF_SIZE]; 242 243 if (fmt) { 244 va_list ap; 245 va_start(ap, fmt); 246 vsnprintf(buf, LOG_BUF_SIZE, fmt, ap); 247 va_end(ap); 248 } else { 249 /* Msg not provided, log condition. N.B. Do not use cond directly as 250 * format string as it could contain spurious '%' syntax (e.g. 251 * "%d" in "blocks%devs == 0"). 252 */ 253 if (cond) 254 snprintf(buf, LOG_BUF_SIZE, "Assertion failed: %s", cond); 255 else 256 strcpy(buf, "Unspecified assertion failed"); 257 } 258 259 __android_log_write(ANDROID_LOG_FATAL, tag, buf); 260 261 __builtin_trap(); /* trap so we have a chance to debug the situation */ 262 } 263 264 int __android_log_bwrite(int32_t tag, const void *payload, size_t len) 265 { 266 struct iovec vec[2]; 267 268 vec[0].iov_base = &tag; 269 vec[0].iov_len = sizeof(tag); 270 vec[1].iov_base = (void*)payload; 271 vec[1].iov_len = len; 272 273 return write_to_log(LOG_ID_EVENTS, vec, 2); 274 } 275 276 /* 277 * Like __android_log_bwrite, but takes the type as well. Doesn't work 278 * for the general case where we're generating lists of stuff, but very 279 * handy if we just want to dump an integer into the log. 280 */ 281 int __android_log_btwrite(int32_t tag, char type, const void *payload, 282 size_t len) 283 { 284 struct iovec vec[3]; 285 286 vec[0].iov_base = &tag; 287 vec[0].iov_len = sizeof(tag); 288 vec[1].iov_base = &type; 289 vec[1].iov_len = sizeof(type); 290 vec[2].iov_base = (void*)payload; 291 vec[2].iov_len = len; 292 293 return write_to_log(LOG_ID_EVENTS, vec, 3); 294 } 295
