| /* | |
| * Copyright (C) 2018, The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| #include "include/stats_event_list.h" | |
| #include <string.h> | |
| #include <sys/time.h> | |
| #include "statsd_writer.h" | |
| #define MAX_EVENT_PAYLOAD (LOGGER_ENTRY_MAX_PAYLOAD - sizeof(int32_t)) | |
| typedef struct { | |
| uint32_t tag; | |
| unsigned pos; /* Read/write position into buffer */ | |
| unsigned count[ANDROID_MAX_LIST_NEST_DEPTH + 1]; /* Number of elements */ | |
| unsigned list[ANDROID_MAX_LIST_NEST_DEPTH + 1]; /* pos for list counter */ | |
| unsigned list_nest_depth; | |
| unsigned len; /* Length or raw buffer. */ | |
| bool overflow; | |
| bool list_stop; /* next call decrement list_nest_depth and issue a stop */ | |
| enum { | |
| kAndroidLoggerRead = 1, | |
| kAndroidLoggerWrite = 2, | |
| } read_write_flag; | |
| uint8_t storage[LOGGER_ENTRY_MAX_PAYLOAD]; | |
| } android_log_context_internal; | |
| extern struct android_log_transport_write statsdLoggerWrite; | |
| static int __write_to_statsd_init(struct iovec* vec, size_t nr); | |
| int (*write_to_statsd)(struct iovec* vec, size_t nr) = __write_to_statsd_init; | |
| // Similar to create_android_logger(), but instead of allocation a new buffer, | |
| // this function resets the buffer for resuse. | |
| void reset_log_context(android_log_context ctx) { | |
| if (!ctx) { | |
| return; | |
| } | |
| android_log_context_internal* context = (android_log_context_internal*)(ctx); | |
| uint32_t tag = context->tag; | |
| memset(context, 0, sizeof(android_log_context_internal)); | |
| context->tag = tag; | |
| context->read_write_flag = kAndroidLoggerWrite; | |
| size_t needed = sizeof(uint8_t) + sizeof(uint8_t); | |
| if ((context->pos + needed) > MAX_EVENT_PAYLOAD) { | |
| context->overflow = true; | |
| } | |
| /* Everything is a list */ | |
| context->storage[context->pos + 0] = EVENT_TYPE_LIST; | |
| context->list[0] = context->pos + 1; | |
| context->pos += needed; | |
| } | |
| int stats_write_list(android_log_context ctx) { | |
| android_log_context_internal* context; | |
| const char* msg; | |
| ssize_t len; | |
| context = (android_log_context_internal*)(ctx); | |
| if (!context || (kAndroidLoggerWrite != context->read_write_flag)) { | |
| return -EBADF; | |
| } | |
| if (context->list_nest_depth) { | |
| return -EIO; | |
| } | |
| /* NB: if there was overflow, then log is truncated. Nothing reported */ | |
| context->storage[1] = context->count[0]; | |
| len = context->len = context->pos; | |
| msg = (const char*)context->storage; | |
| /* it's not a list */ | |
| if (context->count[0] <= 1) { | |
| len -= sizeof(uint8_t) + sizeof(uint8_t); | |
| if (len < 0) { | |
| len = 0; | |
| } | |
| msg += sizeof(uint8_t) + sizeof(uint8_t); | |
| } | |
| struct iovec vec[2]; | |
| vec[0].iov_base = &context->tag; | |
| vec[0].iov_len = sizeof(context->tag); | |
| vec[1].iov_base = (void*)msg; | |
| vec[1].iov_len = len; | |
| return write_to_statsd(vec, 2); | |
| } | |
| int write_to_logger(android_log_context ctx, log_id_t id) { | |
| int retValue = 0; | |
| if (WRITE_TO_LOGD) { | |
| retValue = android_log_write_list(ctx, id); | |
| } | |
| if (WRITE_TO_STATSD) { | |
| // log_event_list's cast operator is overloaded. | |
| int ret = stats_write_list(ctx); | |
| // In debugging phase, we may write to both logd and statsd. Prefer to | |
| // return statsd socket write error code here. | |
| if (ret < 0) { | |
| retValue = ret; | |
| } | |
| } | |
| return retValue; | |
| } | |
| void note_log_drop(int error, int tag) { | |
| statsdLoggerWrite.noteDrop(error, tag); | |
| } | |
| void stats_log_close() { | |
| statsd_writer_init_lock(); | |
| write_to_statsd = __write_to_statsd_init; | |
| if (statsdLoggerWrite.close) { | |
| (*statsdLoggerWrite.close)(); | |
| } | |
| statsd_writer_init_unlock(); | |
| } | |
| /* log_init_lock assumed */ | |
| static int __write_to_statsd_initialize_locked() { | |
| if (!statsdLoggerWrite.open || ((*statsdLoggerWrite.open)() < 0)) { | |
| if (statsdLoggerWrite.close) { | |
| (*statsdLoggerWrite.close)(); | |
| return -ENODEV; | |
| } | |
| } | |
| return 1; | |
| } | |
| static int __write_to_stats_daemon(struct iovec* vec, size_t nr) { | |
| int save_errno; | |
| struct timespec ts; | |
| size_t len, i; | |
| for (len = i = 0; i < nr; ++i) { | |
| len += vec[i].iov_len; | |
| } | |
| if (!len) { | |
| return -EINVAL; | |
| } | |
| save_errno = errno; | |
| #if defined(__ANDROID__) | |
| clock_gettime(CLOCK_REALTIME, &ts); | |
| #else | |
| struct timeval tv; | |
| gettimeofday(&tv, NULL); | |
| ts.tv_sec = tv.tv_sec; | |
| ts.tv_nsec = tv.tv_usec * 1000; | |
| #endif | |
| int ret = (int)(*statsdLoggerWrite.write)(&ts, vec, nr); | |
| errno = save_errno; | |
| return ret; | |
| } | |
| static int __write_to_statsd_init(struct iovec* vec, size_t nr) { | |
| int ret, save_errno = errno; | |
| statsd_writer_init_lock(); | |
| if (write_to_statsd == __write_to_statsd_init) { | |
| ret = __write_to_statsd_initialize_locked(); | |
| if (ret < 0) { | |
| statsd_writer_init_unlock(); | |
| errno = save_errno; | |
| return ret; | |
| } | |
| write_to_statsd = __write_to_stats_daemon; | |
| } | |
| statsd_writer_init_unlock(); | |
| ret = write_to_statsd(vec, nr); | |
| errno = save_errno; | |
| return ret; | |
| } | |
| static inline void copy4LE(uint8_t* buf, uint32_t val) { | |
| buf[0] = val & 0xFF; | |
| buf[1] = (val >> 8) & 0xFF; | |
| buf[2] = (val >> 16) & 0xFF; | |
| buf[3] = (val >> 24) & 0xFF; | |
| } | |
| // Note: this function differs from android_log_write_string8_len in that the length passed in | |
| // should be treated as actual length and not max length. | |
| int android_log_write_char_array(android_log_context ctx, const char* value, size_t actual_len) { | |
| size_t needed; | |
| ssize_t len = actual_len; | |
| android_log_context_internal* context; | |
| context = (android_log_context_internal*)ctx; | |
| if (!context || (kAndroidLoggerWrite != context->read_write_flag)) { | |
| return -EBADF; | |
| } | |
| if (context->overflow) { | |
| return -EIO; | |
| } | |
| if (!value) { | |
| value = ""; | |
| len = 0; | |
| } | |
| needed = sizeof(uint8_t) + sizeof(int32_t) + len; | |
| if ((context->pos + needed) > MAX_EVENT_PAYLOAD) { | |
| /* Truncate string for delivery */ | |
| len = MAX_EVENT_PAYLOAD - context->pos - 1 - sizeof(int32_t); | |
| if (len <= 0) { | |
| context->overflow = true; | |
| return -EIO; | |
| } | |
| } | |
| context->count[context->list_nest_depth]++; | |
| context->storage[context->pos + 0] = EVENT_TYPE_STRING; | |
| copy4LE(&context->storage[context->pos + 1], len); | |
| if (len) { | |
| memcpy(&context->storage[context->pos + 5], value, len); | |
| } | |
| context->pos += needed; | |
| return len; | |
| } |