logger.h revision 1c950479393d42d18829d4009dbdb3a7f03acbb7 
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#include <log/log_read.h>
16
17#ifdef __cplusplus
18extern "C" {
19#endif
20
21/*
22 * The userspace structure for version 1 of the logger_entry ABI.
23 * This structure is returned to userspace by the kernel logger
24 * driver unless an upgrade to a newer ABI version is requested.
25 */
26struct logger_entry {
27    uint16_t    len;    /* length of the payload */
28    uint16_t    __pad;  /* no matter what, we get 2 bytes of padding */
29    int32_t     pid;    /* generating process's pid */
30    int32_t     tid;    /* generating process's tid */
31    int32_t     sec;    /* seconds since Epoch */
32    int32_t     nsec;   /* nanoseconds */
33    char        msg[0]; /* the entry's payload */
34} __attribute__((__packed__));
35
36/*
37 * The userspace structure for version 2 of the logger_entry ABI.
38 * This structure is returned to userspace if ioctl(LOGGER_SET_VERSION)
39 * is called with version==2; or used with the user space log daemon.
40 */
41struct logger_entry_v2 {
42    uint16_t    len;       /* length of the payload */
43    uint16_t    hdr_size;  /* sizeof(struct logger_entry_v2) */
44    int32_t     pid;       /* generating process's pid */
45    int32_t     tid;       /* generating process's tid */
46    int32_t     sec;       /* seconds since Epoch */
47    int32_t     nsec;      /* nanoseconds */
48    uint32_t    euid;      /* effective UID of logger */
49    char        msg[0];    /* the entry's payload */
50} __attribute__((__packed__));
51
52struct logger_entry_v3 {
53    uint16_t    len;       /* length of the payload */
54    uint16_t    hdr_size;  /* sizeof(struct logger_entry_v3) */
55    int32_t     pid;       /* generating process's pid */
56    int32_t     tid;       /* generating process's tid */
57    int32_t     sec;       /* seconds since Epoch */
58    int32_t     nsec;      /* nanoseconds */
59    uint32_t    lid;       /* log id of the payload */
60    char        msg[0];    /* the entry's payload */
61} __attribute__((__packed__));
62
63/*
64 * The maximum size of the log entry payload that can be
65 * written to the kernel logger driver. An attempt to write
66 * more than this amount to /dev/log/* will result in a
67 * truncated log entry.
68 */
69#define LOGGER_ENTRY_MAX_PAYLOAD	4076
70
71/*
72 * The maximum size of a log entry which can be read from the
73 * kernel logger driver. An attempt to read less than this amount
74 * may result in read() returning EINVAL.
75 */
76#define LOGGER_ENTRY_MAX_LEN		(5*1024)
77
78#define NS_PER_SEC 1000000000ULL
79
80struct log_msg {
81    union {
82        unsigned char buf[LOGGER_ENTRY_MAX_LEN + 1];
83        struct logger_entry_v3 entry;
84        struct logger_entry_v3 entry_v3;
85        struct logger_entry_v2 entry_v2;
86        struct logger_entry    entry_v1;
87    } __attribute__((aligned(4)));
88#ifdef __cplusplus
89    /* Matching log_time operators */
90    bool operator== (const log_msg &T) const
91    {
92        return (entry.sec == T.entry.sec) && (entry.nsec == T.entry.nsec);
93    }
94    bool operator!= (const log_msg &T) const
95    {
96        return !(*this == T);
97    }
98    bool operator< (const log_msg &T) const
99    {
100        return (entry.sec < T.entry.sec)
101            || ((entry.sec == T.entry.sec)
102             && (entry.nsec < T.entry.nsec));
103    }
104    bool operator>= (const log_msg &T) const
105    {
106        return !(*this < T);
107    }
108    bool operator> (const log_msg &T) const
109    {
110        return (entry.sec > T.entry.sec)
111            || ((entry.sec == T.entry.sec)
112             && (entry.nsec > T.entry.nsec));
113    }
114    bool operator<= (const log_msg &T) const
115    {
116        return !(*this > T);
117    }
118    uint64_t nsec() const
119    {
120        return static_cast<uint64_t>(entry.sec) * NS_PER_SEC + entry.nsec;
121    }
122
123    /* packet methods */
124    log_id_t id()
125    {
126        return (log_id_t) entry.lid;
127    }
128    char *msg()
129    {
130        return entry.hdr_size ? (char *) buf + entry.hdr_size : entry_v1.msg;
131    }
132    unsigned int len()
133    {
134        return (entry.hdr_size ? entry.hdr_size : sizeof(entry_v1)) + entry.len;
135    }
136#endif
137};
138
139struct logger;
140
141log_id_t android_logger_get_id(struct logger *logger);
142
143int android_logger_clear(struct logger *logger);
144long android_logger_get_log_size(struct logger *logger);
145int android_logger_set_log_size(struct logger *logger, unsigned long size);
146long android_logger_get_log_readable_size(struct logger *logger);
147int android_logger_get_log_version(struct logger *logger);
148
149struct logger_list;
150
151ssize_t android_logger_get_statistics(struct logger_list *logger_list,
152                                      char *buf, size_t len);
153ssize_t android_logger_get_prune_list(struct logger_list *logger_list,
154                                      char *buf, size_t len);
155int android_logger_set_prune_list(struct logger_list *logger_list,
156                                  char *buf, size_t len);
157
158struct logger_list *android_logger_list_alloc(int mode,
159                                              unsigned int tail,
160                                              pid_t pid);
161struct logger_list *android_logger_list_alloc_time(int mode,
162                                                   log_time start,
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