logger.h revision 18a5432158ad43b8faefe4950b30e760200ce0b4
1/* 2** 3** Copyright 2007-2014, The Android Open Source Project 4** 5** This file is dual licensed. It may be redistributed and/or modified 6** under the terms of the Apache 2.0 License OR version 2 of the GNU 7** General Public License. 8*/ 9 10#ifndef _LIBS_LOG_LOGGER_H 11#define _LIBS_LOG_LOGGER_H 12 13#include <stdint.h> 14#include <log/log.h> 15 16#ifdef __cplusplus 17extern "C" { 18#endif 19 20/* 21 * The userspace structure for version 1 of the logger_entry ABI. 22 * This structure is returned to userspace by the kernel logger 23 * driver unless an upgrade to a newer ABI version is requested. 24 */ 25struct logger_entry { 26 uint16_t len; /* length of the payload */ 27 uint16_t __pad; /* no matter what, we get 2 bytes of padding */ 28 int32_t pid; /* generating process's pid */ 29 int32_t tid; /* generating process's tid */ 30 int32_t sec; /* seconds since Epoch */ 31 int32_t nsec; /* nanoseconds */ 32 char msg[0]; /* the entry's payload */ 33} __attribute__((__packed__)); 34 35/* 36 * The userspace structure for version 2 of the logger_entry ABI. 37 * This structure is returned to userspace if ioctl(LOGGER_SET_VERSION) 38 * is called with version==2; or used with the user space log daemon. 39 */ 40struct logger_entry_v2 { 41 uint16_t len; /* length of the payload */ 42 uint16_t hdr_size; /* sizeof(struct logger_entry_v2) */ 43 int32_t pid; /* generating process's pid */ 44 int32_t tid; /* generating process's tid */ 45 int32_t sec; /* seconds since Epoch */ 46 int32_t nsec; /* nanoseconds */ 47 uint32_t euid; /* effective UID of logger */ 48 char msg[0]; /* the entry's payload */ 49} __attribute__((__packed__)); 50 51struct logger_entry_v3 { 52 uint16_t len; /* length of the payload */ 53 uint16_t hdr_size; /* sizeof(struct logger_entry_v3) */ 54 int32_t pid; /* generating process's pid */ 55 int32_t tid; /* generating process's tid */ 56 int32_t sec; /* seconds since Epoch */ 57 int32_t nsec; /* nanoseconds */ 58 uint32_t lid; /* log id of the payload */ 59 char msg[0]; /* the entry's payload */ 60} __attribute__((__packed__)); 61 62/* 63 * The maximum size of the log entry payload that can be 64 * written to the kernel logger driver. An attempt to write 65 * more than this amount to /dev/log/* will result in a 66 * truncated log entry. 67 */ 68#define LOGGER_ENTRY_MAX_PAYLOAD 4076 69 70/* 71 * The maximum size of a log entry which can be read from the 72 * kernel logger driver. An attempt to read less than this amount 73 * may result in read() returning EINVAL. 74 */ 75#define LOGGER_ENTRY_MAX_LEN (5*1024) 76 77#define NS_PER_SEC 1000000000ULL 78 79struct log_msg { 80 union { 81 unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1]; 82 struct logger_entry_v3 entry; 83 struct logger_entry_v3 entry_v3; 84 struct logger_entry_v2 entry_v2; 85 struct logger_entry entry_v1; 86 } __attribute__((aligned(4))); 87#ifdef __cplusplus 88 /* Matching log_time operators */ 89 bool operator== (const log_msg &T) const 90 { 91 return (entry.sec == T.entry.sec) && (entry.nsec == T.entry.nsec); 92 } 93 bool operator!= (const log_msg &T) const 94 { 95 return !(*this == T); 96 } 97 bool operator< (const log_msg &T) const 98 { 99 return (entry.sec < T.entry.sec) 100 || ((entry.sec == T.entry.sec) 101 && (entry.nsec < T.entry.nsec)); 102 } 103 bool operator>= (const log_msg &T) const 104 { 105 return !(*this < T); 106 } 107 bool operator> (const log_msg &T) const 108 { 109 return (entry.sec > T.entry.sec) 110 || ((entry.sec == T.entry.sec) 111 && (entry.nsec > T.entry.nsec)); 112 } 113 bool operator<= (const log_msg &T) const 114 { 115 return !(*this > T); 116 } 117 uint64_t nsec() const 118 { 119 return static_cast<uint64_t>(entry.sec) * NS_PER_SEC + entry.nsec; 120 } 121 122 /* packet methods */ 123 log_id_t id() 124 { 125 return (log_id_t) entry.lid; 126 } 127 char *msg() 128 { 129 return entry.hdr_size ? (char *) buf + entry.hdr_size : entry_v1.msg; 130 } 131 unsigned int len() 132 { 133 return (entry.hdr_size ? entry.hdr_size : sizeof(entry_v1)) + entry.len; 134 } 135#endif 136}; 137 138struct logger; 139 140log_id_t android_logger_get_id(struct logger *logger); 141 142int android_logger_clear(struct logger *logger); 143long android_logger_get_log_size(struct logger *logger); 144#ifdef USERDEBUG_BUILD 145int android_logger_set_log_size(struct logger *logger, unsigned long size); 146#endif 147long android_logger_get_log_readable_size(struct logger *logger); 148int android_logger_get_log_version(struct logger *logger); 149 150struct logger_list; 151 152ssize_t android_logger_get_statistics(struct logger_list *logger_list, 153 char *buf, size_t len); 154#ifdef USERDEBUG_BUILD 155ssize_t android_logger_get_prune_list(struct logger_list *logger_list, 156 char *buf, size_t len); 157int android_logger_set_prune_list(struct logger_list *logger_list, 158 char *buf, size_t len); 159#endif 160 161struct logger_list *android_logger_list_alloc(int mode, 162 unsigned int tail, 163 pid_t pid); 164void android_logger_list_free(struct logger_list *logger_list); 165/* In the purest sense, the following two are orthogonal interfaces */ 166int android_logger_list_read(struct logger_list *logger_list, 167 struct log_msg *log_msg); 168 169/* Multiple log_id_t opens */ 170struct logger *android_logger_open(struct logger_list *logger_list, 171 log_id_t id); 172#define android_logger_close android_logger_free 173/* Single log_id_t open */ 174struct logger_list *android_logger_list_open(log_id_t id, 175 int mode, 176 unsigned int tail, 177 pid_t pid); 178#define android_logger_list_close android_logger_list_free 179 180/* 181 * log_id_t helpers 182 */ 183log_id_t android_name_to_log_id(const char *logName); 184const char *android_log_id_to_name(log_id_t log_id); 185 186#ifdef __cplusplus 187} 188#endif 189 190#endif /* _LIBS_LOG_LOGGER_H */ 191