logger.h revision e9c4196980208124066fb45fa03bfb85fe1d8581 
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 _UTILS_LOGGER_H
11#define _UTILS_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};
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
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};
50
51/*
52 * The maximum size of the log entry payload that can be
53 * written to the kernel logger driver. An attempt to write
54 * more than this amount to /dev/log/* will result in a
55 * truncated log entry.
56 */
57#define LOGGER_ENTRY_MAX_PAYLOAD	4076
58
59/*
60 * The maximum size of a log entry which can be read from the
61 * kernel logger driver. An attempt to read less than this amount
62 * may result in read() returning EINVAL.
63 */
64#define LOGGER_ENTRY_MAX_LEN		(5*1024)
65
66#define NS_PER_SEC 1000000000ULL
67
68struct log_msg {
69    union {
70        unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1];
71        struct logger_entry_v2 entry;
72        struct logger_entry_v2 entry_v2;
73        struct logger_entry    entry_v1;
74        struct {
75            unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1];
76            log_id_t id;
77        } extra;
78    } __attribute__((aligned(4)));
79#ifdef __cplusplus
80    /* Matching log_time_t operators */
81    bool operator== (log_msg &T)
82    {
83        return (entry.sec == T.entry.sec) && (entry.nsec == T.entry.nsec);
84    }
85    bool operator!= (log_msg &T)
86    {
87        return !(*this == T);
88    }
89    bool operator< (log_msg &T)
90    {
91        return (entry.sec < T.entry.sec)
92            || ((entry.sec == T.entry.sec)
93             && (entry.nsec < T.entry.nsec));
94    }
95    bool operator>= (log_msg &T)
96    {
97        return !(*this < T);
98    }
99    bool operator> (log_msg &T)
100    {
101        return (entry.sec > T.entry.sec)
102            || ((entry.sec == T.entry.sec)
103             && (entry.nsec > T.entry.nsec));
104    }
105    bool operator<= (log_msg &T)
106    {
107        return !(*this > T);
108    }
109    uint64_t nsec(void)
110    {
111        return static_cast<uint64_t>(entry.sec) * NS_PER_SEC + entry.nsec;
112    }
113
114    /* packet methods */
115    log_id_t id(void)
116    {
117        return extra.id;
118    }
119    char *msg(void)
120    {
121        return entry.hdr_size ? (char *) buf + entry.hdr_size : entry_v1.msg;
122    }
123    unsigned int len(void)
124    {
125        return (entry.hdr_size ? entry.hdr_size : sizeof(entry_v1)) + entry.len;
126    }
127#endif
128};
129
130struct logger;
131
132log_id_t android_logger_get_id(struct logger *logger);
133
134int android_logger_clear(struct logger *logger);
135int android_logger_get_log_size(struct logger *logger);
136int android_logger_get_log_readable_size(struct logger *logger);
137int android_logger_get_log_version(struct logger *logger);
138
139struct logger_list;
140
141struct logger_list *android_logger_list_alloc(int mode,
142                                              unsigned int tail,
143                                              pid_t pid);
144void android_logger_list_free(struct logger_list *logger_list);
145/* In the purest sense, the following two are orthogonal interfaces */
146int android_logger_list_read(struct logger_list *logger_list,
147                             struct log_msg *log_msg);
148
149/* Multiple log_id_t opens */
150struct logger *android_logger_open(struct logger_list *logger_list,
151                                   log_id_t id);
152#define android_logger_close android_logger_free
153/* Single log_id_t open */
154struct logger_list *android_logger_list_open(log_id_t id,
155                                             int mode,
156                                             unsigned int tail,
157                                             pid_t pid);
158#define android_logger_list_close android_logger_list_free
159
160/*
161 * log_id_t helpers
162 */
163log_id_t android_name_to_log_id(const char *logName);
164const char *android_log_id_to_name(log_id_t log_id);
165
166#ifdef HAVE_IOCTL
167
168#include <sys/ioctl.h>
169
170#define __LOGGERIO	0xAE
171
172#define LOGGER_GET_LOG_BUF_SIZE		_IO(__LOGGERIO, 1) /* size of log */
173#define LOGGER_GET_LOG_LEN		_IO(__LOGGERIO, 2) /* used log len */
174#define LOGGER_GET_NEXT_ENTRY_LEN	_IO(__LOGGERIO, 3) /* next entry len */
175#define LOGGER_FLUSH_LOG		_IO(__LOGGERIO, 4) /* flush log */
176#define LOGGER_GET_VERSION		_IO(__LOGGERIO, 5) /* abi version */
177#define LOGGER_SET_VERSION		_IO(__LOGGERIO, 6) /* abi version */
178
179#endif // HAVE_IOCTL
180
181#ifdef __cplusplus
182}
183#endif
184
185#endif /* _UTILS_LOGGER_H */
186