logger.h revision 17947103154ad16a47333655b02546df306e819a 
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};
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};
50
51struct logger_entry_v3 {
52    uint16_t    len;       /* length of the payload */
53    uint16_t    hdr_size;  /* sizeof(struct logger_entry_v2) */
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};
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);
143int android_logger_get_log_size(struct logger *logger);
144int android_logger_get_log_readable_size(struct logger *logger);
145int android_logger_get_log_version(struct logger *logger);
146
147struct logger_list;
148
149struct logger_list *android_logger_list_alloc(int mode,
150                                              unsigned int tail,
151                                              pid_t pid);
152void android_logger_list_free(struct logger_list *logger_list);
153/* In the purest sense, the following two are orthogonal interfaces */
154int android_logger_list_read(struct logger_list *logger_list,
155                             struct log_msg *log_msg);
156
157/* Multiple log_id_t opens */
158struct logger *android_logger_open(struct logger_list *logger_list,
159                                   log_id_t id);
160#define android_logger_close android_logger_free
161/* Single log_id_t open */
162struct logger_list *android_logger_list_open(log_id_t id,
163                                             int mode,
164                                             unsigned int tail,
165                                             pid_t pid);
166#define android_logger_list_close android_logger_list_free
167
168/*
169 * log_id_t helpers
170 */
171log_id_t android_name_to_log_id(const char *logName);
172const char *android_log_id_to_name(log_id_t log_id);
173
174#ifdef __cplusplus
175}
176#endif
177
178#endif /* _LIBS_LOG_LOGGER_H */
179