1 /*
2 ** Copyright 2013-2014, 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 #include <errno.h>
18 #include <fcntl.h>
19 #include <pthread.h>
20 #include <sched.h>
21 #include <stddef.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <unistd.h>
25
26 #include <cutils/list.h>
27 #include <log/log.h>
28 #include <log/logger.h>
29 #include <private/android_filesystem_config.h>
30
31 #include "config_read.h"
32 #include "log_portability.h"
33 #include "logger.h"
34
35 /* android_logger_alloc unimplemented, no use case */
36 /* android_logger_free not exported */
android_logger_free(struct logger * logger)37 static void android_logger_free(struct logger *logger)
38 {
39 struct android_log_logger *logger_internal =
40 (struct android_log_logger *)logger;
41
42 if (!logger_internal) {
43 return;
44 }
45
46 list_remove(&logger_internal->node);
47
48 free(logger_internal);
49 }
50
51 /* android_logger_alloc unimplemented, no use case */
52
53 /* method for getting the associated sublog id */
android_logger_get_id(struct logger * logger)54 LIBLOG_ABI_PUBLIC log_id_t android_logger_get_id(struct logger *logger)
55 {
56 return ((struct android_log_logger *)logger)->logId;
57 }
58
init_transport_context(struct android_log_logger_list * logger_list)59 static int init_transport_context(struct android_log_logger_list *logger_list)
60 {
61 struct android_log_transport_read *transport;
62 struct listnode *node;
63
64 if (!logger_list) {
65 return -EINVAL;
66 }
67
68 if (list_empty(&logger_list->logger)) {
69 return -EINVAL;
70 }
71
72 if (!list_empty(&logger_list->transport)) {
73 return 0;
74 }
75
76 __android_log_lock();
77 /* mini __write_to_log_initialize() to populate transports */
78 if (list_empty(&__android_log_transport_read) &&
79 list_empty(&__android_log_persist_read)) {
80 __android_log_config_read();
81 }
82 __android_log_unlock();
83
84 node = (logger_list->mode & ANDROID_LOG_PSTORE) ?
85 &__android_log_persist_read : &__android_log_transport_read;
86
87 read_transport_for_each(transport, node) {
88 struct android_log_transport_context *transp;
89 struct android_log_logger *logger;
90 unsigned logMask = 0;
91
92 logger_for_each(logger, logger_list) {
93 log_id_t logId = logger->logId;
94
95 if ((logId == LOG_ID_SECURITY) &&
96 (__android_log_uid() != AID_SYSTEM)) {
97 continue;
98 }
99 if (transport->read &&
100 (!transport->available ||
101 (transport->available(logId) >= 0))) {
102 logMask |= 1 << logId;
103 }
104 }
105 if (!logMask) {
106 continue;
107 }
108 transp = calloc(1, sizeof(*transp));
109 if (!transp) {
110 return -ENOMEM;
111 }
112 transp->parent = logger_list;
113 transp->transport = transport;
114 transp->logMask = logMask;
115 transp->ret = 1;
116 list_add_tail(&logger_list->transport, &transp->node);
117 }
118 if (list_empty(&logger_list->transport)) {
119 return -ENODEV;
120 }
121 return 0;
122 }
123
124 #define LOGGER_FUNCTION(logger, def, func, args...) \
125 ssize_t ret = -EINVAL; \
126 struct android_log_transport_context *transp; \
127 struct android_log_logger *logger_internal = \
128 (struct android_log_logger *)logger; \
129 \
130 if (!logger_internal) { \
131 return ret; \
132 } \
133 ret = init_transport_context(logger_internal->parent); \
134 if (ret < 0) { \
135 return ret; \
136 } \
137 \
138 ret = (def); \
139 transport_context_for_each(transp, logger_internal->parent) { \
140 if ((transp->logMask & (1 << logger_internal->logId)) && \
141 transp->transport && transp->transport->func) { \
142 ssize_t retval = (transp->transport->func)(logger_internal, \
143 transp, ## args); \
144 if ((ret >= 0) || (ret == (def))) { \
145 ret = retval; \
146 } \
147 } \
148 } \
149 return ret
150
android_logger_clear(struct logger * logger)151 LIBLOG_ABI_PUBLIC int android_logger_clear(struct logger *logger)
152 {
153 LOGGER_FUNCTION(logger, -ENODEV, clear);
154 }
155
156 /* returns the total size of the log's ring buffer */
android_logger_get_log_size(struct logger * logger)157 LIBLOG_ABI_PUBLIC long android_logger_get_log_size(struct logger *logger)
158 {
159 LOGGER_FUNCTION(logger, -ENODEV, getSize);
160 }
161
android_logger_set_log_size(struct logger * logger,unsigned long size)162 LIBLOG_ABI_PUBLIC int android_logger_set_log_size(struct logger *logger,
163 unsigned long size)
164 {
165 LOGGER_FUNCTION(logger, -ENODEV, setSize, size);
166 }
167
168 /*
169 * returns the readable size of the log's ring buffer (that is, amount of the
170 * log consumed)
171 */
android_logger_get_log_readable_size(struct logger * logger)172 LIBLOG_ABI_PUBLIC long android_logger_get_log_readable_size(
173 struct logger *logger)
174 {
175 LOGGER_FUNCTION(logger, -ENODEV, getReadableSize);
176 }
177
178 /*
179 * returns the logger version
180 */
android_logger_get_log_version(struct logger * logger)181 LIBLOG_ABI_PUBLIC int android_logger_get_log_version(struct logger *logger)
182 {
183 LOGGER_FUNCTION(logger, 4, version);
184 }
185
186 #define LOGGER_LIST_FUNCTION(logger_list, def, func, args...) \
187 struct android_log_transport_context *transp; \
188 struct android_log_logger_list *logger_list_internal = \
189 (struct android_log_logger_list *)logger_list; \
190 \
191 ssize_t ret = init_transport_context(logger_list_internal); \
192 if (ret < 0) { \
193 return ret; \
194 } \
195 \
196 ret = (def); \
197 transport_context_for_each(transp, logger_list_internal) { \
198 if (transp->transport && (transp->transport->func)) { \
199 ssize_t retval = (transp->transport->func)(logger_list_internal, \
200 transp, ## args); \
201 if ((ret >= 0) || (ret == (def))) { \
202 ret = retval; \
203 } \
204 } \
205 } \
206 return ret
207
208 /*
209 * returns statistics
210 */
android_logger_get_statistics(struct logger_list * logger_list,char * buf,size_t len)211 LIBLOG_ABI_PUBLIC ssize_t android_logger_get_statistics(
212 struct logger_list *logger_list,
213 char *buf, size_t len)
214 {
215 LOGGER_LIST_FUNCTION(logger_list, -ENODEV, getStats, buf, len);
216 }
217
android_logger_get_prune_list(struct logger_list * logger_list,char * buf,size_t len)218 LIBLOG_ABI_PUBLIC ssize_t android_logger_get_prune_list(
219 struct logger_list *logger_list,
220 char *buf, size_t len)
221 {
222 LOGGER_LIST_FUNCTION(logger_list, -ENODEV, getPrune, buf, len);
223 }
224
android_logger_set_prune_list(struct logger_list * logger_list,char * buf,size_t len)225 LIBLOG_ABI_PUBLIC int android_logger_set_prune_list(
226 struct logger_list *logger_list,
227 char *buf, size_t len)
228 {
229 LOGGER_LIST_FUNCTION(logger_list, -ENODEV, setPrune, buf, len);
230 }
231
android_logger_list_alloc(int mode,unsigned int tail,pid_t pid)232 LIBLOG_ABI_PUBLIC struct logger_list *android_logger_list_alloc(
233 int mode,
234 unsigned int tail,
235 pid_t pid)
236 {
237 struct android_log_logger_list *logger_list;
238
239 logger_list = calloc(1, sizeof(*logger_list));
240 if (!logger_list) {
241 return NULL;
242 }
243
244 list_init(&logger_list->logger);
245 list_init(&logger_list->transport);
246 logger_list->mode = mode;
247 logger_list->tail = tail;
248 logger_list->pid = pid;
249
250 return (struct logger_list *)logger_list;
251 }
252
android_logger_list_alloc_time(int mode,log_time start,pid_t pid)253 LIBLOG_ABI_PUBLIC struct logger_list *android_logger_list_alloc_time(
254 int mode,
255 log_time start,
256 pid_t pid)
257 {
258 struct android_log_logger_list *logger_list;
259
260 logger_list = calloc(1, sizeof(*logger_list));
261 if (!logger_list) {
262 return NULL;
263 }
264
265 list_init(&logger_list->logger);
266 list_init(&logger_list->transport);
267 logger_list->mode = mode;
268 logger_list->start = start;
269 logger_list->pid = pid;
270
271 return (struct logger_list *)logger_list;
272 }
273
274 /* android_logger_list_register unimplemented, no use case */
275 /* android_logger_list_unregister unimplemented, no use case */
276
277 /* Open the named log and add it to the logger list */
android_logger_open(struct logger_list * logger_list,log_id_t logId)278 LIBLOG_ABI_PUBLIC struct logger *android_logger_open(
279 struct logger_list *logger_list,
280 log_id_t logId)
281 {
282 struct android_log_logger_list *logger_list_internal =
283 (struct android_log_logger_list *)logger_list;
284 struct android_log_logger *logger;
285
286 if (!logger_list_internal || (logId >= LOG_ID_MAX)) {
287 goto err;
288 }
289
290 logger_for_each(logger, logger_list_internal) {
291 if (logger->logId == logId) {
292 goto ok;
293 }
294 }
295
296 logger = calloc(1, sizeof(*logger));
297 if (!logger) {
298 goto err;
299 }
300
301 logger->logId = logId;
302 list_add_tail(&logger_list_internal->logger, &logger->node);
303 logger->parent = logger_list_internal;
304
305 /* Reset known transports to re-evaluate, we just added one */
306 while (!list_empty(&logger_list_internal->transport)) {
307 struct listnode *node = list_head(&logger_list_internal->transport);
308 struct android_log_transport_context *transp =
309 node_to_item(node, struct android_log_transport_context, node);
310
311 list_remove(&transp->node);
312 free(transp);
313 }
314 goto ok;
315
316 err:
317 logger = NULL;
318 ok:
319 return (struct logger *)logger;
320 }
321
322 /* Open the single named log and make it part of a new logger list */
android_logger_list_open(log_id_t logId,int mode,unsigned int tail,pid_t pid)323 LIBLOG_ABI_PUBLIC struct logger_list *android_logger_list_open(
324 log_id_t logId,
325 int mode,
326 unsigned int tail,
327 pid_t pid)
328 {
329 struct logger_list *logger_list =
330 android_logger_list_alloc(mode, tail, pid);
331
332 if (!logger_list) {
333 return NULL;
334 }
335
336 if (!android_logger_open(logger_list, logId)) {
337 android_logger_list_free(logger_list);
338 return NULL;
339 }
340
341 return logger_list;
342 }
343
344 /* Read from the selected logs */
android_logger_list_read(struct logger_list * logger_list,struct log_msg * log_msg)345 LIBLOG_ABI_PUBLIC int android_logger_list_read(struct logger_list *logger_list,
346 struct log_msg *log_msg)
347 {
348 struct android_log_transport_context *transp;
349 struct android_log_logger_list *logger_list_internal =
350 (struct android_log_logger_list *)logger_list;
351
352 int ret = init_transport_context(logger_list_internal);
353 if (ret < 0) {
354 return ret;
355 }
356
357 /* at least one transport */
358 transp = node_to_item(logger_list_internal->transport.next,
359 struct android_log_transport_context, node);
360
361 /* more than one transport? */
362 if (transp->node.next != &logger_list_internal->transport) {
363 /* Poll and merge sort the entries if from multiple transports */
364 struct android_log_transport_context *oldest = NULL;
365 int ret;
366 int polled = 0;
367 do {
368 if (polled) {
369 sched_yield();
370 }
371 ret = -1000;
372 polled = 0;
373 do {
374 int retval = transp->ret;
375 if ((retval > 0) && !transp->logMsg.entry.len) {
376 if (!transp->transport->read) {
377 retval = transp->ret = 0;
378 } else if ((logger_list_internal->mode &
379 ANDROID_LOG_NONBLOCK) ||
380 !transp->transport->poll) {
381 retval = transp->ret = (*transp->transport->read)(
382 logger_list_internal,
383 transp,
384 &transp->logMsg);
385 } else {
386 int pollval = (*transp->transport->poll)(
387 logger_list_internal, transp);
388 if (pollval <= 0) {
389 sched_yield();
390 pollval = (*transp->transport->poll)(
391 logger_list_internal, transp);
392 }
393 polled = 1;
394 if (pollval < 0) {
395 if ((pollval == -EINTR) || (pollval == -EAGAIN)) {
396 return -EAGAIN;
397 }
398 retval = transp->ret = pollval;
399 } else if (pollval > 0) {
400 retval = transp->ret = (*transp->transport->read)(
401 logger_list_internal,
402 transp,
403 &transp->logMsg);
404 }
405 }
406 }
407 if (ret < retval) {
408 ret = retval;
409 }
410 if ((transp->ret > 0) && transp->logMsg.entry.len &&
411 (!oldest ||
412 (oldest->logMsg.entry.sec >
413 transp->logMsg.entry.sec) ||
414 ((oldest->logMsg.entry.sec ==
415 transp->logMsg.entry.sec) &&
416 (oldest->logMsg.entry.nsec >
417 transp->logMsg.entry.nsec)))) {
418 oldest = transp;
419 }
420 transp = node_to_item(transp->node.next,
421 struct android_log_transport_context,
422 node);
423 } while (transp != node_to_item(
424 &logger_list_internal->transport,
425 struct android_log_transport_context,
426 node));
427 if (!oldest &&
428 (logger_list_internal->mode & ANDROID_LOG_NONBLOCK)) {
429 return (ret < 0) ? ret : -EAGAIN;
430 }
431 transp = node_to_item(logger_list_internal->transport.next,
432 struct android_log_transport_context, node);
433 } while (!oldest && (ret > 0));
434 if (!oldest) {
435 return ret;
436 }
437 memcpy(log_msg, &oldest->logMsg, oldest->logMsg.entry.len +
438 (oldest->logMsg.entry.hdr_size ?
439 oldest->logMsg.entry.hdr_size :
440 sizeof(struct logger_entry)));
441 oldest->logMsg.entry.len = 0; /* Mark it as copied */
442 return oldest->ret;
443 }
444
445 /* if only one, no need to copy into transport_context and merge-sort */
446 return (transp->transport->read)(logger_list_internal, transp, log_msg);
447 }
448
449 /* Close all the logs */
android_logger_list_free(struct logger_list * logger_list)450 LIBLOG_ABI_PUBLIC void android_logger_list_free(struct logger_list *logger_list)
451 {
452 struct android_log_logger_list *logger_list_internal =
453 (struct android_log_logger_list *)logger_list;
454
455 if (logger_list_internal == NULL) {
456 return;
457 }
458
459 while (!list_empty(&logger_list_internal->transport)) {
460 struct listnode *node = list_head(&logger_list_internal->transport);
461 struct android_log_transport_context *transp =
462 node_to_item(node, struct android_log_transport_context, node);
463
464 if (transp->transport && transp->transport->close) {
465 (*transp->transport->close)(logger_list_internal, transp);
466 }
467 list_remove(&transp->node);
468 free(transp);
469 }
470
471 while (!list_empty(&logger_list_internal->logger)) {
472 struct listnode *node = list_head(&logger_list_internal->logger);
473 struct android_log_logger *logger =
474 node_to_item(node, struct android_log_logger, node);
475 android_logger_free((struct logger *)logger);
476 }
477
478 free(logger_list_internal);
479 }
480