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