1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
12 * the documentation and/or other materials provided with the
13 * distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <assert.h>
30 #include <ctype.h>
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <pthread.h>
34 #include <stdarg.h>
35 #include <stddef.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <sys/mman.h>
39 #include <sys/socket.h>
40 #include <sys/types.h>
41 #include <sys/uio.h>
42 #include <sys/un.h>
43 #include <time.h>
44 #include <unistd.h>
45
46 #include <android/set_abort_message.h>
47 #include <async_safe/log.h>
48
49 #include "private/CachedProperty.h"
50 #include "private/ScopedPthreadMutexLocker.h"
51
52 // Must be kept in sync with frameworks/base/core/java/android/util/EventLog.java.
53 enum AndroidEventLogType {
54 EVENT_TYPE_INT = 0,
55 EVENT_TYPE_LONG = 1,
56 EVENT_TYPE_STRING = 2,
57 EVENT_TYPE_LIST = 3,
58 EVENT_TYPE_FLOAT = 4,
59 };
60
61 struct BufferOutputStream {
62 public:
BufferOutputStreamBufferOutputStream63 BufferOutputStream(char* buffer, size_t size) : total(0) {
64 buffer_ = buffer;
65 end_ = buffer + size - 1;
66 pos_ = buffer_;
67 pos_[0] = '\0';
68 }
69
~BufferOutputStreamBufferOutputStream70 ~BufferOutputStream() {}
71
SendBufferOutputStream72 void Send(const char* data, int len) {
73 if (len < 0) {
74 len = strlen(data);
75 }
76
77 total += len;
78
79 while (len > 0) {
80 int avail = end_ - pos_;
81 if (avail == 0) {
82 return;
83 }
84 if (avail > len) {
85 avail = len;
86 }
87 memcpy(pos_, data, avail);
88 pos_ += avail;
89 pos_[0] = '\0';
90 len -= avail;
91 }
92 }
93
94 size_t total;
95
96 private:
97 char* buffer_;
98 char* pos_;
99 char* end_;
100 };
101
102 struct FdOutputStream {
103 public:
FdOutputStreamFdOutputStream104 explicit FdOutputStream(int fd) : total(0), fd_(fd) {}
105
SendFdOutputStream106 void Send(const char* data, int len) {
107 if (len < 0) {
108 len = strlen(data);
109 }
110
111 total += len;
112
113 while (len > 0) {
114 int rc = TEMP_FAILURE_RETRY(write(fd_, data, len));
115 if (rc == -1) {
116 return;
117 }
118 data += rc;
119 len -= rc;
120 }
121 }
122
123 size_t total;
124
125 private:
126 int fd_;
127 };
128
129 /*** formatted output implementation
130 ***/
131
132 /* Parse a decimal string from 'format + *ppos',
133 * return the value, and writes the new position past
134 * the decimal string in '*ppos' on exit.
135 *
136 * NOTE: Does *not* handle a sign prefix.
137 */
parse_decimal(const char * format,int * ppos)138 static unsigned parse_decimal(const char* format, int* ppos) {
139 const char* p = format + *ppos;
140 unsigned result = 0;
141
142 for (;;) {
143 int ch = *p;
144 unsigned d = static_cast<unsigned>(ch - '0');
145
146 if (d >= 10U) {
147 break;
148 }
149
150 result = result * 10 + d;
151 p++;
152 }
153 *ppos = p - format;
154 return result;
155 }
156
157 // Writes number 'value' in base 'base' into buffer 'buf' of size 'buf_size' bytes.
158 // Assumes that buf_size > 0.
format_unsigned(char * buf,size_t buf_size,uint64_t value,int base,bool caps)159 static void format_unsigned(char* buf, size_t buf_size, uint64_t value, int base, bool caps) {
160 char* p = buf;
161 char* end = buf + buf_size - 1;
162
163 // Generate digit string in reverse order.
164 while (value) {
165 unsigned d = value % base;
166 value /= base;
167 if (p != end) {
168 char ch;
169 if (d < 10) {
170 ch = '0' + d;
171 } else {
172 ch = (caps ? 'A' : 'a') + (d - 10);
173 }
174 *p++ = ch;
175 }
176 }
177
178 // Special case for 0.
179 if (p == buf) {
180 if (p != end) {
181 *p++ = '0';
182 }
183 }
184 *p = '\0';
185
186 // Reverse digit string in-place.
187 size_t length = p - buf;
188 for (size_t i = 0, j = length - 1; i < j; ++i, --j) {
189 char ch = buf[i];
190 buf[i] = buf[j];
191 buf[j] = ch;
192 }
193 }
194
format_integer(char * buf,size_t buf_size,uint64_t value,char conversion)195 static void format_integer(char* buf, size_t buf_size, uint64_t value, char conversion) {
196 // Decode the conversion specifier.
197 int is_signed = (conversion == 'd' || conversion == 'i' || conversion == 'o');
198 int base = 10;
199 if (conversion == 'x' || conversion == 'X') {
200 base = 16;
201 } else if (conversion == 'o') {
202 base = 8;
203 }
204 bool caps = (conversion == 'X');
205
206 if (is_signed && static_cast<int64_t>(value) < 0) {
207 buf[0] = '-';
208 buf += 1;
209 buf_size -= 1;
210 value = static_cast<uint64_t>(-static_cast<int64_t>(value));
211 }
212 format_unsigned(buf, buf_size, value, base, caps);
213 }
214
215 template <typename Out>
SendRepeat(Out & o,char ch,int count)216 static void SendRepeat(Out& o, char ch, int count) {
217 char pad[8];
218 memset(pad, ch, sizeof(pad));
219
220 const int pad_size = static_cast<int>(sizeof(pad));
221 while (count > 0) {
222 int avail = count;
223 if (avail > pad_size) {
224 avail = pad_size;
225 }
226 o.Send(pad, avail);
227 count -= avail;
228 }
229 }
230
231 /* Perform formatted output to an output target 'o' */
232 template <typename Out>
out_vformat(Out & o,const char * format,va_list args)233 static void out_vformat(Out& o, const char* format, va_list args) {
234 int nn = 0;
235
236 for (;;) {
237 int mm;
238 int padZero = 0;
239 int padLeft = 0;
240 char sign = '\0';
241 int width = -1;
242 int prec = -1;
243 size_t bytelen = sizeof(int);
244 int slen;
245 char buffer[32]; /* temporary buffer used to format numbers */
246
247 char c;
248
249 /* first, find all characters that are not 0 or '%' */
250 /* then send them to the output directly */
251 mm = nn;
252 do {
253 c = format[mm];
254 if (c == '\0' || c == '%') break;
255 mm++;
256 } while (1);
257
258 if (mm > nn) {
259 o.Send(format + nn, mm - nn);
260 nn = mm;
261 }
262
263 /* is this it ? then exit */
264 if (c == '\0') break;
265
266 /* nope, we are at a '%' modifier */
267 nn++; // skip it
268
269 /* parse flags */
270 for (;;) {
271 c = format[nn++];
272 if (c == '\0') { /* single trailing '%' ? */
273 c = '%';
274 o.Send(&c, 1);
275 return;
276 } else if (c == '0') {
277 padZero = 1;
278 continue;
279 } else if (c == '-') {
280 padLeft = 1;
281 continue;
282 } else if (c == ' ' || c == '+') {
283 sign = c;
284 continue;
285 }
286 break;
287 }
288
289 /* parse field width */
290 if ((c >= '0' && c <= '9')) {
291 nn--;
292 width = static_cast<int>(parse_decimal(format, &nn));
293 c = format[nn++];
294 }
295
296 /* parse precision */
297 if (c == '.') {
298 prec = static_cast<int>(parse_decimal(format, &nn));
299 c = format[nn++];
300 }
301
302 /* length modifier */
303 switch (c) {
304 case 'h':
305 bytelen = sizeof(short);
306 if (format[nn] == 'h') {
307 bytelen = sizeof(char);
308 nn += 1;
309 }
310 c = format[nn++];
311 break;
312 case 'l':
313 bytelen = sizeof(long);
314 if (format[nn] == 'l') {
315 bytelen = sizeof(long long);
316 nn += 1;
317 }
318 c = format[nn++];
319 break;
320 case 'z':
321 bytelen = sizeof(size_t);
322 c = format[nn++];
323 break;
324 case 't':
325 bytelen = sizeof(ptrdiff_t);
326 c = format[nn++];
327 break;
328 default:;
329 }
330
331 /* conversion specifier */
332 const char* str = buffer;
333 if (c == 's') {
334 /* string */
335 str = va_arg(args, const char*);
336 if (str == NULL) {
337 str = "(null)";
338 }
339 } else if (c == 'c') {
340 /* character */
341 /* NOTE: char is promoted to int when passed through the stack */
342 buffer[0] = static_cast<char>(va_arg(args, int));
343 buffer[1] = '\0';
344 } else if (c == 'p') {
345 uint64_t value = reinterpret_cast<uintptr_t>(va_arg(args, void*));
346 buffer[0] = '0';
347 buffer[1] = 'x';
348 format_integer(buffer + 2, sizeof(buffer) - 2, value, 'x');
349 } else if (c == 'd' || c == 'i' || c == 'o' || c == 'u' || c == 'x' || c == 'X') {
350 /* integers - first read value from stack */
351 uint64_t value;
352 int is_signed = (c == 'd' || c == 'i' || c == 'o');
353
354 /* NOTE: int8_t and int16_t are promoted to int when passed
355 * through the stack
356 */
357 switch (bytelen) {
358 case 1:
359 value = static_cast<uint8_t>(va_arg(args, int));
360 break;
361 case 2:
362 value = static_cast<uint16_t>(va_arg(args, int));
363 break;
364 case 4:
365 value = va_arg(args, uint32_t);
366 break;
367 case 8:
368 value = va_arg(args, uint64_t);
369 break;
370 default:
371 return; /* should not happen */
372 }
373
374 /* sign extension, if needed */
375 if (is_signed) {
376 int shift = 64 - 8 * bytelen;
377 value = static_cast<uint64_t>((static_cast<int64_t>(value << shift)) >> shift);
378 }
379
380 /* format the number properly into our buffer */
381 format_integer(buffer, sizeof(buffer), value, c);
382 } else if (c == '%') {
383 buffer[0] = '%';
384 buffer[1] = '\0';
385 } else {
386 __assert(__FILE__, __LINE__, "conversion specifier unsupported");
387 }
388
389 /* if we are here, 'str' points to the content that must be
390 * outputted. handle padding and alignment now */
391
392 slen = strlen(str);
393
394 if (sign != '\0' || prec != -1) {
395 __assert(__FILE__, __LINE__, "sign/precision unsupported");
396 }
397
398 if (slen < width && !padLeft) {
399 char padChar = padZero ? '0' : ' ';
400 SendRepeat(o, padChar, width - slen);
401 }
402
403 o.Send(str, slen);
404
405 if (slen < width && padLeft) {
406 char padChar = padZero ? '0' : ' ';
407 SendRepeat(o, padChar, width - slen);
408 }
409 }
410 }
411
async_safe_format_buffer(char * buffer,size_t buffer_size,const char * format,...)412 int async_safe_format_buffer(char* buffer, size_t buffer_size, const char* format, ...) {
413 BufferOutputStream os(buffer, buffer_size);
414 va_list args;
415 va_start(args, format);
416 out_vformat(os, format, args);
417 va_end(args);
418 return os.total;
419 }
420
async_safe_format_buffer_va_list(char * buffer,size_t buffer_size,const char * format,va_list args)421 int async_safe_format_buffer_va_list(char* buffer, size_t buffer_size, const char* format,
422 va_list args) {
423 BufferOutputStream os(buffer, buffer_size);
424 out_vformat(os, format, args);
425 return os.total;
426 }
427
async_safe_format_fd(int fd,const char * format,...)428 int async_safe_format_fd(int fd, const char* format, ...) {
429 FdOutputStream os(fd);
430 va_list args;
431 va_start(args, format);
432 out_vformat(os, format, args);
433 va_end(args);
434 return os.total;
435 }
436
write_stderr(const char * tag,const char * msg)437 static int write_stderr(const char* tag, const char* msg) {
438 iovec vec[4];
439 vec[0].iov_base = const_cast<char*>(tag);
440 vec[0].iov_len = strlen(tag);
441 vec[1].iov_base = const_cast<char*>(": ");
442 vec[1].iov_len = 2;
443 vec[2].iov_base = const_cast<char*>(msg);
444 vec[2].iov_len = strlen(msg);
445 vec[3].iov_base = const_cast<char*>("\n");
446 vec[3].iov_len = 1;
447
448 int result = TEMP_FAILURE_RETRY(writev(STDERR_FILENO, vec, 4));
449 return result;
450 }
451
open_log_socket()452 static int open_log_socket() {
453 // ToDo: Ideally we want this to fail if the gid of the current
454 // process is AID_LOGD, but will have to wait until we have
455 // registered this in private/android_filesystem_config.h. We have
456 // found that all logd crashes thus far have had no problem stuffing
457 // the UNIX domain socket and moving on so not critical *today*.
458
459 int log_fd = TEMP_FAILURE_RETRY(socket(PF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0));
460 if (log_fd == -1) {
461 return -1;
462 }
463
464 union {
465 struct sockaddr addr;
466 struct sockaddr_un addrUn;
467 } u;
468 memset(&u, 0, sizeof(u));
469 u.addrUn.sun_family = AF_UNIX;
470 strlcpy(u.addrUn.sun_path, "/dev/socket/logdw", sizeof(u.addrUn.sun_path));
471
472 if (TEMP_FAILURE_RETRY(connect(log_fd, &u.addr, sizeof(u.addrUn))) != 0) {
473 close(log_fd);
474 return -1;
475 }
476
477 return log_fd;
478 }
479
480 struct log_time { // Wire format
481 uint32_t tv_sec;
482 uint32_t tv_nsec;
483 };
484
async_safe_write_log(int priority,const char * tag,const char * msg)485 int async_safe_write_log(int priority, const char* tag, const char* msg) {
486 int main_log_fd = open_log_socket();
487 if (main_log_fd == -1) {
488 // Try stderr instead.
489 return write_stderr(tag, msg);
490 }
491
492 iovec vec[6];
493 char log_id = (priority == ANDROID_LOG_FATAL) ? LOG_ID_CRASH : LOG_ID_MAIN;
494 vec[0].iov_base = &log_id;
495 vec[0].iov_len = sizeof(log_id);
496 uint16_t tid = gettid();
497 vec[1].iov_base = &tid;
498 vec[1].iov_len = sizeof(tid);
499 timespec ts;
500 clock_gettime(CLOCK_REALTIME, &ts);
501 log_time realtime_ts;
502 realtime_ts.tv_sec = ts.tv_sec;
503 realtime_ts.tv_nsec = ts.tv_nsec;
504 vec[2].iov_base = &realtime_ts;
505 vec[2].iov_len = sizeof(realtime_ts);
506
507 vec[3].iov_base = &priority;
508 vec[3].iov_len = 1;
509 vec[4].iov_base = const_cast<char*>(tag);
510 vec[4].iov_len = strlen(tag) + 1;
511 vec[5].iov_base = const_cast<char*>(msg);
512 vec[5].iov_len = strlen(msg) + 1;
513
514 int result = TEMP_FAILURE_RETRY(writev(main_log_fd, vec, sizeof(vec) / sizeof(vec[0])));
515 close(main_log_fd);
516 return result;
517 }
518
async_safe_format_log_va_list(int priority,const char * tag,const char * format,va_list args)519 int async_safe_format_log_va_list(int priority, const char* tag, const char* format, va_list args) {
520 char buffer[1024];
521 BufferOutputStream os(buffer, sizeof(buffer));
522 out_vformat(os, format, args);
523 return async_safe_write_log(priority, tag, buffer);
524 }
525
async_safe_format_log(int priority,const char * tag,const char * format,...)526 int async_safe_format_log(int priority, const char* tag, const char* format, ...) {
527 va_list args;
528 va_start(args, format);
529 int result = async_safe_format_log_va_list(priority, tag, format, args);
530 va_end(args);
531 return result;
532 }
533
async_safe_fatal_va_list(const char * prefix,const char * format,va_list args)534 void async_safe_fatal_va_list(const char* prefix, const char* format, va_list args) {
535 char msg[1024];
536 BufferOutputStream os(msg, sizeof(msg));
537
538 if (prefix) {
539 os.Send(prefix, strlen(prefix));
540 os.Send(": ", 2);
541 }
542
543 out_vformat(os, format, args);
544
545 // Log to stderr for the benefit of "adb shell" users and gtests.
546 struct iovec iov[2] = {
547 {msg, os.total}, {const_cast<char*>("\n"), 1},
548 };
549 TEMP_FAILURE_RETRY(writev(2, iov, 2));
550
551 // Log to the log for the benefit of regular app developers (whose stdout and stderr are closed).
552 async_safe_write_log(ANDROID_LOG_FATAL, "libc", msg);
553
554 android_set_abort_message(msg);
555 }
556
async_safe_fatal_no_abort(const char * fmt,...)557 void async_safe_fatal_no_abort(const char* fmt, ...) {
558 va_list args;
559 va_start(args, fmt);
560 async_safe_fatal_va_list(nullptr, fmt, args);
561 va_end(args);
562 }
563