Home | History | Annotate | Download | only in liblog
      1 /*
      2  * Copyright (C) 2007-2016 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 
     17 #include <errno.h>
     18 #include <stdatomic.h>
     19 #include <stdlib.h>
     20 #include <string.h>
     21 #include <sys/time.h>
     22 
     23 #ifdef __BIONIC__
     24 #include <android/set_abort_message.h>
     25 #endif
     26 
     27 #include <log/event_tag_map.h>
     28 #include <log/log_transport.h>
     29 #include <private/android_filesystem_config.h>
     30 #include <private/android_logger.h>
     31 
     32 #include "config_read.h" /* __android_log_config_read_close() definition */
     33 #include "config_write.h"
     34 #include "log_portability.h"
     35 #include "logger.h"
     36 
     37 #define LOG_BUF_SIZE 1024
     38 
     39 static int __write_to_log_init(log_id_t, struct iovec* vec, size_t nr);
     40 static int (*write_to_log)(log_id_t, struct iovec* vec,
     41                            size_t nr) = __write_to_log_init;
     42 
     43 /*
     44  * This is used by the C++ code to decide if it should write logs through
     45  * the C code.  Basically, if /dev/socket/logd is available, we're running in
     46  * the simulator rather than a desktop tool and want to use the device.
     47  */
     48 static enum {
     49   kLogUninitialized,
     50   kLogNotAvailable,
     51   kLogAvailable
     52 } g_log_status = kLogUninitialized;
     53 
     54 static int check_log_uid_permissions() {
     55 #if defined(__ANDROID__)
     56   uid_t uid = __android_log_uid();
     57 
     58   /* Matches clientHasLogCredentials() in logd */
     59   if ((uid != AID_SYSTEM) && (uid != AID_ROOT) && (uid != AID_LOG)) {
     60     uid = geteuid();
     61     if ((uid != AID_SYSTEM) && (uid != AID_ROOT) && (uid != AID_LOG)) {
     62       gid_t gid = getgid();
     63       if ((gid != AID_SYSTEM) && (gid != AID_ROOT) && (gid != AID_LOG)) {
     64         gid = getegid();
     65         if ((gid != AID_SYSTEM) && (gid != AID_ROOT) && (gid != AID_LOG)) {
     66           int num_groups;
     67           gid_t* groups;
     68 
     69           num_groups = getgroups(0, NULL);
     70           if (num_groups <= 0) {
     71             return -EPERM;
     72           }
     73           groups = calloc(num_groups, sizeof(gid_t));
     74           if (!groups) {
     75             return -ENOMEM;
     76           }
     77           num_groups = getgroups(num_groups, groups);
     78           while (num_groups > 0) {
     79             if (groups[num_groups - 1] == AID_LOG) {
     80               break;
     81             }
     82             --num_groups;
     83           }
     84           free(groups);
     85           if (num_groups <= 0) {
     86             return -EPERM;
     87           }
     88         }
     89       }
     90     }
     91   }
     92 #endif
     93   return 0;
     94 }
     95 
     96 static void __android_log_cache_available(
     97     struct android_log_transport_write* node) {
     98   size_t i;
     99 
    100   if (node->logMask) {
    101     return;
    102   }
    103 
    104   for (i = LOG_ID_MIN; i < LOG_ID_MAX; ++i) {
    105     if (node->write && (i != LOG_ID_KERNEL) &&
    106         ((i != LOG_ID_SECURITY) || (check_log_uid_permissions() == 0)) &&
    107         (!node->available || ((*node->available)(i) >= 0))) {
    108       node->logMask |= 1 << i;
    109     }
    110   }
    111 }
    112 
    113 LIBLOG_ABI_PUBLIC int __android_log_dev_available() {
    114   struct android_log_transport_write* node;
    115 
    116   if (list_empty(&__android_log_transport_write)) {
    117     return kLogUninitialized;
    118   }
    119 
    120   write_transport_for_each(node, &__android_log_transport_write) {
    121     __android_log_cache_available(node);
    122     if (node->logMask) {
    123       return kLogAvailable;
    124     }
    125   }
    126   return kLogNotAvailable;
    127 }
    128 
    129 #if defined(__ANDROID__)
    130 static atomic_uintptr_t tagMap;
    131 #endif
    132 
    133 /*
    134  * Release any logger resources. A new log write will immediately re-acquire.
    135  */
    136 LIBLOG_ABI_PUBLIC void __android_log_close() {
    137   struct android_log_transport_write* transport;
    138 #if defined(__ANDROID__)
    139   EventTagMap* m;
    140 #endif
    141 
    142   __android_log_lock();
    143 
    144   write_to_log = __write_to_log_init;
    145 
    146   /*
    147    * Threads that are actively writing at this point are not held back
    148    * by a lock and are at risk of dropping the messages with a return code
    149    * -EBADF. Prefer to return error code than add the overhead of a lock to
    150    * each log writing call to guarantee delivery. In addition, anyone
    151    * calling this is doing so to release the logging resources and shut down,
    152    * for them to do so with outstanding log requests in other threads is a
    153    * disengenuous use of this function.
    154    */
    155 
    156   write_transport_for_each(transport, &__android_log_persist_write) {
    157     if (transport->close) {
    158       (*transport->close)();
    159     }
    160   }
    161 
    162   write_transport_for_each(transport, &__android_log_transport_write) {
    163     if (transport->close) {
    164       (*transport->close)();
    165     }
    166   }
    167 
    168   __android_log_config_write_close();
    169 
    170 #if defined(__ANDROID__)
    171   /*
    172    * Additional risk here somewhat mitigated by immediately unlock flushing
    173    * the processor cache. The multi-threaded race that we choose to accept,
    174    * to minimize locking, is an atomic_load in a writer picking up a value
    175    * just prior to entering this routine. There will be an use after free.
    176    *
    177    * Again, anyone calling this is doing so to release the logging resources
    178    * is most probably going to quiesce then shut down; or to restart after
    179    * a fork so the risk should be non-existent. For this reason we
    180    * choose a mitigation stance for efficiency instead of incuring the cost
    181    * of a lock for every log write.
    182    */
    183   m = (EventTagMap*)atomic_exchange(&tagMap, (uintptr_t)0);
    184 #endif
    185 
    186   __android_log_unlock();
    187 
    188 #if defined(__ANDROID__)
    189   if (m != (EventTagMap*)(uintptr_t)-1LL) android_closeEventTagMap(m);
    190 #endif
    191 }
    192 
    193 /* log_init_lock assumed */
    194 static int __write_to_log_initialize() {
    195   struct android_log_transport_write* transport;
    196   struct listnode* n;
    197   int i = 0, ret = 0;
    198 
    199   __android_log_config_write();
    200   write_transport_for_each_safe(transport, n, &__android_log_transport_write) {
    201     __android_log_cache_available(transport);
    202     if (!transport->logMask) {
    203       list_remove(&transport->node);
    204       continue;
    205     }
    206     if (!transport->open || ((*transport->open)() < 0)) {
    207       if (transport->close) {
    208         (*transport->close)();
    209       }
    210       list_remove(&transport->node);
    211       continue;
    212     }
    213     ++ret;
    214   }
    215   write_transport_for_each_safe(transport, n, &__android_log_persist_write) {
    216     __android_log_cache_available(transport);
    217     if (!transport->logMask) {
    218       list_remove(&transport->node);
    219       continue;
    220     }
    221     if (!transport->open || ((*transport->open)() < 0)) {
    222       if (transport->close) {
    223         (*transport->close)();
    224       }
    225       list_remove(&transport->node);
    226       continue;
    227     }
    228     ++i;
    229   }
    230   if (!ret && !i) {
    231     return -ENODEV;
    232   }
    233 
    234   return ret;
    235 }
    236 
    237 /*
    238  * Extract a 4-byte value from a byte stream. le32toh open coded
    239  */
    240 static inline uint32_t get4LE(const uint8_t* src) {
    241   return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
    242 }
    243 
    244 static int __write_to_log_daemon(log_id_t log_id, struct iovec* vec, size_t nr) {
    245   struct android_log_transport_write* node;
    246   int ret;
    247   struct timespec ts;
    248   size_t len, i;
    249 
    250   for (len = i = 0; i < nr; ++i) {
    251     len += vec[i].iov_len;
    252   }
    253   if (!len) {
    254     return -EINVAL;
    255   }
    256 
    257 #if defined(__ANDROID__)
    258   clock_gettime(android_log_clockid(), &ts);
    259 
    260   if (log_id == LOG_ID_SECURITY) {
    261     if (vec[0].iov_len < 4) {
    262       return -EINVAL;
    263     }
    264 
    265     ret = check_log_uid_permissions();
    266     if (ret < 0) {
    267       return ret;
    268     }
    269     if (!__android_log_security()) {
    270       /* If only we could reset downstream logd counter */
    271       return -EPERM;
    272     }
    273   } else if (log_id == LOG_ID_EVENTS) {
    274     const char* tag;
    275     size_t len;
    276     EventTagMap *m, *f;
    277 
    278     if (vec[0].iov_len < 4) {
    279       return -EINVAL;
    280     }
    281 
    282     tag = NULL;
    283     len = 0;
    284     f = NULL;
    285     m = (EventTagMap*)atomic_load(&tagMap);
    286 
    287     if (!m) {
    288       ret = __android_log_trylock();
    289       m = (EventTagMap*)atomic_load(&tagMap); /* trylock flush cache */
    290       if (!m) {
    291         m = android_openEventTagMap(NULL);
    292         if (ret) { /* trylock failed, use local copy, mark for close */
    293           f = m;
    294         } else {
    295           if (!m) { /* One chance to open map file */
    296             m = (EventTagMap*)(uintptr_t)-1LL;
    297           }
    298           atomic_store(&tagMap, (uintptr_t)m);
    299         }
    300       }
    301       if (!ret) { /* trylock succeeded, unlock */
    302         __android_log_unlock();
    303       }
    304     }
    305     if (m && (m != (EventTagMap*)(uintptr_t)-1LL)) {
    306       tag = android_lookupEventTag_len(m, &len, get4LE(vec[0].iov_base));
    307     }
    308     ret = __android_log_is_loggable_len(ANDROID_LOG_INFO, tag, len,
    309                                         ANDROID_LOG_VERBOSE);
    310     if (f) { /* local copy marked for close */
    311       android_closeEventTagMap(f);
    312     }
    313     if (!ret) {
    314       return -EPERM;
    315     }
    316   } else {
    317     /* Validate the incoming tag, tag content can not split across iovec */
    318     char prio = ANDROID_LOG_VERBOSE;
    319     const char* tag = vec[0].iov_base;
    320     size_t len = vec[0].iov_len;
    321     if (!tag) {
    322       len = 0;
    323     }
    324     if (len > 0) {
    325       prio = *tag;
    326       if (len > 1) {
    327         --len;
    328         ++tag;
    329       } else {
    330         len = vec[1].iov_len;
    331         tag = ((const char*)vec[1].iov_base);
    332         if (!tag) {
    333           len = 0;
    334         }
    335       }
    336     }
    337     /* tag must be nul terminated */
    338     if (tag && strnlen(tag, len) >= len) {
    339       tag = NULL;
    340     }
    341 
    342     if (!__android_log_is_loggable_len(prio, tag, len - 1, ANDROID_LOG_VERBOSE)) {
    343       return -EPERM;
    344     }
    345   }
    346 #else
    347   /* simulate clock_gettime(CLOCK_REALTIME, &ts); */
    348   {
    349     struct timeval tv;
    350     gettimeofday(&tv, NULL);
    351     ts.tv_sec = tv.tv_sec;
    352     ts.tv_nsec = tv.tv_usec * 1000;
    353   }
    354 #endif
    355 
    356   ret = 0;
    357   i = 1 << log_id;
    358   write_transport_for_each(node, &__android_log_transport_write) {
    359     if (node->logMask & i) {
    360       ssize_t retval;
    361       retval = (*node->write)(log_id, &ts, vec, nr);
    362       if (ret >= 0) {
    363         ret = retval;
    364       }
    365     }
    366   }
    367 
    368   write_transport_for_each(node, &__android_log_persist_write) {
    369     if (node->logMask & i) {
    370       (void)(*node->write)(log_id, &ts, vec, nr);
    371     }
    372   }
    373 
    374   return ret;
    375 }
    376 
    377 static int __write_to_log_init(log_id_t log_id, struct iovec* vec, size_t nr) {
    378   __android_log_lock();
    379 
    380   if (write_to_log == __write_to_log_init) {
    381     int ret;
    382 
    383     ret = __write_to_log_initialize();
    384     if (ret < 0) {
    385       __android_log_unlock();
    386       if (!list_empty(&__android_log_persist_write)) {
    387         __write_to_log_daemon(log_id, vec, nr);
    388       }
    389       return ret;
    390     }
    391 
    392     write_to_log = __write_to_log_daemon;
    393   }
    394 
    395   __android_log_unlock();
    396 
    397   return write_to_log(log_id, vec, nr);
    398 }
    399 
    400 LIBLOG_ABI_PUBLIC int __android_log_write(int prio, const char* tag,
    401                                           const char* msg) {
    402   return __android_log_buf_write(LOG_ID_MAIN, prio, tag, msg);
    403 }
    404 
    405 LIBLOG_ABI_PUBLIC int __android_log_buf_write(int bufID, int prio,
    406                                               const char* tag, const char* msg) {
    407   struct iovec vec[3];
    408   char tmp_tag[32];
    409 
    410   if (!tag) tag = "";
    411 
    412   /* XXX: This needs to go! */
    413   if ((bufID != LOG_ID_RADIO) &&
    414       (!strcmp(tag, "HTC_RIL") ||
    415        !strncmp(tag, "RIL", 3) || /* Any log tag with "RIL" as the prefix */
    416        !strncmp(tag, "IMS", 3) || /* Any log tag with "IMS" as the prefix */
    417        !strcmp(tag, "AT") || !strcmp(tag, "GSM") || !strcmp(tag, "STK") ||
    418        !strcmp(tag, "CDMA") || !strcmp(tag, "PHONE") || !strcmp(tag, "SMS"))) {
    419     bufID = LOG_ID_RADIO;
    420     /* Inform third party apps/ril/radio.. to use Rlog or RLOG */
    421     snprintf(tmp_tag, sizeof(tmp_tag), "use-Rlog/RLOG-%s", tag);
    422     tag = tmp_tag;
    423   }
    424 
    425 #if __BIONIC__
    426   if (prio == ANDROID_LOG_FATAL) {
    427     android_set_abort_message(msg);
    428   }
    429 #endif
    430 
    431   vec[0].iov_base = (unsigned char*)&prio;
    432   vec[0].iov_len = 1;
    433   vec[1].iov_base = (void*)tag;
    434   vec[1].iov_len = strlen(tag) + 1;
    435   vec[2].iov_base = (void*)msg;
    436   vec[2].iov_len = strlen(msg) + 1;
    437 
    438   return write_to_log(bufID, vec, 3);
    439 }
    440 
    441 LIBLOG_ABI_PUBLIC int __android_log_vprint(int prio, const char* tag,
    442                                            const char* fmt, va_list ap) {
    443   char buf[LOG_BUF_SIZE];
    444 
    445   vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
    446 
    447   return __android_log_write(prio, tag, buf);
    448 }
    449 
    450 LIBLOG_ABI_PUBLIC int __android_log_print(int prio, const char* tag,
    451                                           const char* fmt, ...) {
    452   va_list ap;
    453   char buf[LOG_BUF_SIZE];
    454 
    455   va_start(ap, fmt);
    456   vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
    457   va_end(ap);
    458 
    459   return __android_log_write(prio, tag, buf);
    460 }
    461 
    462 LIBLOG_ABI_PUBLIC int __android_log_buf_print(int bufID, int prio,
    463                                               const char* tag, const char* fmt,
    464                                               ...) {
    465   va_list ap;
    466   char buf[LOG_BUF_SIZE];
    467 
    468   va_start(ap, fmt);
    469   vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
    470   va_end(ap);
    471 
    472   return __android_log_buf_write(bufID, prio, tag, buf);
    473 }
    474 
    475 LIBLOG_ABI_PUBLIC void __android_log_assert(const char* cond, const char* tag,
    476                                             const char* fmt, ...) {
    477   char buf[LOG_BUF_SIZE];
    478 
    479   if (fmt) {
    480     va_list ap;
    481     va_start(ap, fmt);
    482     vsnprintf(buf, LOG_BUF_SIZE, fmt, ap);
    483     va_end(ap);
    484   } else {
    485     /* Msg not provided, log condition.  N.B. Do not use cond directly as
    486      * format string as it could contain spurious '%' syntax (e.g.
    487      * "%d" in "blocks%devs == 0").
    488      */
    489     if (cond)
    490       snprintf(buf, LOG_BUF_SIZE, "Assertion failed: %s", cond);
    491     else
    492       strcpy(buf, "Unspecified assertion failed");
    493   }
    494 
    495   // Log assertion failures to stderr for the benefit of "adb shell" users
    496   // and gtests (http://b/23675822).
    497   struct iovec iov[2] = {
    498     { buf, strlen(buf) }, { (char*)"\n", 1 },
    499   };
    500   TEMP_FAILURE_RETRY(writev(2, iov, 2));
    501 
    502   __android_log_write(ANDROID_LOG_FATAL, tag, buf);
    503   abort(); /* abort so we have a chance to debug the situation */
    504            /* NOTREACHED */
    505 }
    506 
    507 LIBLOG_ABI_PUBLIC int __android_log_bwrite(int32_t tag, const void* payload,
    508                                            size_t len) {
    509   struct iovec vec[2];
    510 
    511   vec[0].iov_base = &tag;
    512   vec[0].iov_len = sizeof(tag);
    513   vec[1].iov_base = (void*)payload;
    514   vec[1].iov_len = len;
    515 
    516   return write_to_log(LOG_ID_EVENTS, vec, 2);
    517 }
    518 
    519 LIBLOG_ABI_PUBLIC int __android_log_security_bwrite(int32_t tag,
    520                                                     const void* payload,
    521                                                     size_t len) {
    522   struct iovec vec[2];
    523 
    524   vec[0].iov_base = &tag;
    525   vec[0].iov_len = sizeof(tag);
    526   vec[1].iov_base = (void*)payload;
    527   vec[1].iov_len = len;
    528 
    529   return write_to_log(LOG_ID_SECURITY, vec, 2);
    530 }
    531 
    532 /*
    533  * Like __android_log_bwrite, but takes the type as well.  Doesn't work
    534  * for the general case where we're generating lists of stuff, but very
    535  * handy if we just want to dump an integer into the log.
    536  */
    537 LIBLOG_ABI_PUBLIC int __android_log_btwrite(int32_t tag, char type,
    538                                             const void* payload, size_t len) {
    539   struct iovec vec[3];
    540 
    541   vec[0].iov_base = &tag;
    542   vec[0].iov_len = sizeof(tag);
    543   vec[1].iov_base = &type;
    544   vec[1].iov_len = sizeof(type);
    545   vec[2].iov_base = (void*)payload;
    546   vec[2].iov_len = len;
    547 
    548   return write_to_log(LOG_ID_EVENTS, vec, 3);
    549 }
    550 
    551 /*
    552  * Like __android_log_bwrite, but used for writing strings to the
    553  * event log.
    554  */
    555 LIBLOG_ABI_PUBLIC int __android_log_bswrite(int32_t tag, const char* payload) {
    556   struct iovec vec[4];
    557   char type = EVENT_TYPE_STRING;
    558   uint32_t len = strlen(payload);
    559 
    560   vec[0].iov_base = &tag;
    561   vec[0].iov_len = sizeof(tag);
    562   vec[1].iov_base = &type;
    563   vec[1].iov_len = sizeof(type);
    564   vec[2].iov_base = &len;
    565   vec[2].iov_len = sizeof(len);
    566   vec[3].iov_base = (void*)payload;
    567   vec[3].iov_len = len;
    568 
    569   return write_to_log(LOG_ID_EVENTS, vec, 4);
    570 }
    571 
    572 /*
    573  * Like __android_log_security_bwrite, but used for writing strings to the
    574  * security log.
    575  */
    576 LIBLOG_ABI_PUBLIC int __android_log_security_bswrite(int32_t tag,
    577                                                      const char* payload) {
    578   struct iovec vec[4];
    579   char type = EVENT_TYPE_STRING;
    580   uint32_t len = strlen(payload);
    581 
    582   vec[0].iov_base = &tag;
    583   vec[0].iov_len = sizeof(tag);
    584   vec[1].iov_base = &type;
    585   vec[1].iov_len = sizeof(type);
    586   vec[2].iov_base = &len;
    587   vec[2].iov_len = sizeof(len);
    588   vec[3].iov_base = (void*)payload;
    589   vec[3].iov_len = len;
    590 
    591   return write_to_log(LOG_ID_SECURITY, vec, 4);
    592 }
    593 
    594 static int __write_to_log_null(log_id_t log_id, struct iovec* vec, size_t nr) {
    595   size_t len, i;
    596 
    597   if ((log_id < LOG_ID_MIN) || (log_id >= LOG_ID_MAX)) {
    598     return -EINVAL;
    599   }
    600 
    601   for (len = i = 0; i < nr; ++i) {
    602     len += vec[i].iov_len;
    603   }
    604   if (!len) {
    605     return -EINVAL;
    606   }
    607   return len;
    608 }
    609 
    610 /* Following functions need access to our internal write_to_log status */
    611 
    612 LIBLOG_HIDDEN int __android_log_transport;
    613 
    614 LIBLOG_ABI_PUBLIC int android_set_log_transport(int transport_flag) {
    615   int retval;
    616 
    617   if (transport_flag < 0) {
    618     return -EINVAL;
    619   }
    620 
    621   retval = LOGGER_NULL;
    622 
    623   __android_log_lock();
    624 
    625   if (transport_flag & LOGGER_NULL) {
    626     write_to_log = __write_to_log_null;
    627 
    628     __android_log_unlock();
    629 
    630     return retval;
    631   }
    632 
    633   __android_log_transport &= LOGGER_LOCAL | LOGGER_LOGD | LOGGER_STDERR;
    634 
    635   transport_flag &= LOGGER_LOCAL | LOGGER_LOGD | LOGGER_STDERR;
    636 
    637   if (__android_log_transport != transport_flag) {
    638     __android_log_transport = transport_flag;
    639     __android_log_config_write_close();
    640     __android_log_config_read_close();
    641 
    642     write_to_log = __write_to_log_init;
    643     /* generically we only expect these two values for write_to_log */
    644   } else if ((write_to_log != __write_to_log_init) &&
    645              (write_to_log != __write_to_log_daemon)) {
    646     write_to_log = __write_to_log_init;
    647   }
    648 
    649   retval = __android_log_transport;
    650 
    651   __android_log_unlock();
    652 
    653   return retval;
    654 }
    655 
    656 LIBLOG_ABI_PUBLIC int android_get_log_transport() {
    657   int ret = LOGGER_DEFAULT;
    658 
    659   __android_log_lock();
    660   if (write_to_log == __write_to_log_null) {
    661     ret = LOGGER_NULL;
    662   } else {
    663     __android_log_transport &= LOGGER_LOCAL | LOGGER_LOGD | LOGGER_STDERR;
    664     ret = __android_log_transport;
    665     if ((write_to_log != __write_to_log_init) &&
    666         (write_to_log != __write_to_log_daemon)) {
    667       ret = -EINVAL;
    668     }
    669   }
    670   __android_log_unlock();
    671 
    672   return ret;
    673 }
    674