1 /* 2 * Copyright (C) 2005-2017 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 #pragma once 18 19 #include <stdint.h> 20 #include <sys/types.h> 21 22 #include <android/log.h> 23 #include <log/log_time.h> 24 25 #ifdef __cplusplus 26 extern "C" { 27 #endif 28 29 #define ANDROID_LOG_WRAP_DEFAULT_TIMEOUT 7200 /* 2 hour default */ 30 31 /* 32 * Native log reading interface section. See logcat for sample code. 33 * 34 * The preferred API is an exec of logcat. Likely uses of this interface 35 * are if native code suffers from exec or filtration being too costly, 36 * access to raw information, or parsing is an issue. 37 */ 38 39 struct logger_entry { 40 uint16_t len; /* length of the payload */ 41 uint16_t hdr_size; /* sizeof(struct logger_entry) */ 42 int32_t pid; /* generating process's pid */ 43 uint32_t tid; /* generating process's tid */ 44 uint32_t sec; /* seconds since Epoch */ 45 uint32_t nsec; /* nanoseconds */ 46 uint32_t lid; /* log id of the payload, bottom 4 bits currently */ 47 uint32_t uid; /* generating process's uid */ 48 }; 49 50 /* 51 * The maximum size of a log entry which can be read. 52 * An attempt to read less than this amount may result 53 * in read() returning EINVAL. 54 */ 55 #define LOGGER_ENTRY_MAX_LEN (5 * 1024) 56 57 struct log_msg { 58 union { 59 unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1]; 60 struct logger_entry entry; 61 } __attribute__((aligned(4))); 62 #ifdef __cplusplus nseclog_msg63 uint64_t nsec() const { 64 return static_cast<uint64_t>(entry.sec) * NS_PER_SEC + entry.nsec; 65 } idlog_msg66 log_id_t id() { 67 return static_cast<log_id_t>(entry.lid); 68 } msglog_msg69 char* msg() { 70 unsigned short hdr_size = entry.hdr_size; 71 if (hdr_size >= sizeof(struct log_msg) - sizeof(entry)) { 72 return nullptr; 73 } 74 return reinterpret_cast<char*>(buf) + hdr_size; 75 } lenlog_msg76 unsigned int len() { return entry.hdr_size + entry.len; } 77 #endif 78 }; 79 80 struct logger; 81 82 log_id_t android_logger_get_id(struct logger* logger); 83 84 /* Clears the given log buffer. */ 85 int android_logger_clear(struct logger* logger); 86 /* Return the allotted size for the given log buffer. */ 87 long android_logger_get_log_size(struct logger* logger); 88 /* Set the allotted size for the given log buffer. */ 89 int android_logger_set_log_size(struct logger* logger, unsigned long size); 90 /* Return the actual, uncompressed size that can be read from the given log buffer. */ 91 long android_logger_get_log_readable_size(struct logger* logger); 92 /* Return the actual, compressed size that the given log buffer is consuming. */ 93 long android_logger_get_log_consumed_size(struct logger* logger); 94 /* Deprecated. Always returns '4' regardless of input. */ 95 int android_logger_get_log_version(struct logger* logger); 96 97 struct logger_list; 98 99 ssize_t android_logger_get_statistics(struct logger_list* logger_list, 100 char* buf, size_t len); 101 ssize_t android_logger_get_prune_list(struct logger_list* logger_list, 102 char* buf, size_t len); 103 int android_logger_set_prune_list(struct logger_list* logger_list, const char* buf, size_t len); 104 105 /* The below values are used for the `mode` argument of the below functions. */ 106 /* Note that 0x00000003 were previously used and should be considered reserved. */ 107 #define ANDROID_LOG_NONBLOCK 0x00000800 108 #define ANDROID_LOG_WRAP 0x40000000 /* Block until buffer about to wrap */ 109 #define ANDROID_LOG_PSTORE 0x80000000 110 111 struct logger_list* android_logger_list_alloc(int mode, unsigned int tail, 112 pid_t pid); 113 struct logger_list* android_logger_list_alloc_time(int mode, log_time start, 114 pid_t pid); 115 void android_logger_list_free(struct logger_list* logger_list); 116 /* In the purest sense, the following two are orthogonal interfaces */ 117 int android_logger_list_read(struct logger_list* logger_list, 118 struct log_msg* log_msg); 119 120 /* Multiple log_id_t opens */ 121 struct logger* android_logger_open(struct logger_list* logger_list, log_id_t id); 122 /* Single log_id_t open */ 123 struct logger_list* android_logger_list_open(log_id_t id, int mode, 124 unsigned int tail, pid_t pid); 125 #define android_logger_list_close android_logger_list_free 126 127 #ifdef __cplusplus 128 } 129 #endif 130