logcat.cpp revision ce6d46c69aad22b0e05cb4a6e130da340c06629a
1// Copyright 2006-2014 The Android Open Source Project 2 3#include <assert.h> 4#include <ctype.h> 5#include <errno.h> 6#include <fcntl.h> 7#include <stdio.h> 8#include <stdlib.h> 9#include <stdarg.h> 10#include <string.h> 11#include <signal.h> 12#include <time.h> 13#include <unistd.h> 14#include <sys/socket.h> 15#include <sys/stat.h> 16#include <arpa/inet.h> 17 18#include <cutils/sockets.h> 19#include <log/log.h> 20#include <log/log_read.h> 21#include <log/logger.h> 22#include <log/logd.h> 23#include <log/logprint.h> 24#include <log/event_tag_map.h> 25 26#define DEFAULT_LOG_ROTATE_SIZE_KBYTES 16 27#define DEFAULT_MAX_ROTATED_LOGS 4 28 29static AndroidLogFormat * g_logformat; 30 31/* logd prefixes records with a length field */ 32#define RECORD_LENGTH_FIELD_SIZE_BYTES sizeof(uint32_t) 33 34struct log_device_t { 35 const char* device; 36 bool binary; 37 struct logger *logger; 38 struct logger_list *logger_list; 39 bool printed; 40 char label; 41 42 log_device_t* next; 43 44 log_device_t(const char* d, bool b, char l) { 45 device = d; 46 binary = b; 47 label = l; 48 next = NULL; 49 printed = false; 50 } 51}; 52 53namespace android { 54 55/* Global Variables */ 56 57static const char * g_outputFileName = NULL; 58static int g_logRotateSizeKBytes = 0; // 0 means "no log rotation" 59static int g_maxRotatedLogs = DEFAULT_MAX_ROTATED_LOGS; // 0 means "unbounded" 60static int g_outFD = -1; 61static off_t g_outByteCount = 0; 62static int g_printBinary = 0; 63static int g_devCount = 0; 64 65static EventTagMap* g_eventTagMap = NULL; 66 67static int openLogFile (const char *pathname) 68{ 69 return open(pathname, O_WRONLY | O_APPEND | O_CREAT, S_IRUSR | S_IWUSR); 70} 71 72static void rotateLogs() 73{ 74 int err; 75 76 // Can't rotate logs if we're not outputting to a file 77 if (g_outputFileName == NULL) { 78 return; 79 } 80 81 close(g_outFD); 82 83 for (int i = g_maxRotatedLogs ; i > 0 ; i--) { 84 char *file0, *file1; 85 86 asprintf(&file1, "%s.%d", g_outputFileName, i); 87 88 if (i - 1 == 0) { 89 asprintf(&file0, "%s", g_outputFileName); 90 } else { 91 asprintf(&file0, "%s.%d", g_outputFileName, i - 1); 92 } 93 94 err = rename (file0, file1); 95 96 if (err < 0 && errno != ENOENT) { 97 perror("while rotating log files"); 98 } 99 100 free(file1); 101 free(file0); 102 } 103 104 g_outFD = openLogFile (g_outputFileName); 105 106 if (g_outFD < 0) { 107 perror ("couldn't open output file"); 108 exit(-1); 109 } 110 111 g_outByteCount = 0; 112 113} 114 115void printBinary(struct log_msg *buf) 116{ 117 size_t size = buf->len(); 118 119 TEMP_FAILURE_RETRY(write(g_outFD, buf, size)); 120} 121 122static void processBuffer(log_device_t* dev, struct log_msg *buf) 123{ 124 int bytesWritten = 0; 125 int err; 126 AndroidLogEntry entry; 127 char binaryMsgBuf[1024]; 128 129 if (dev->binary) { 130 err = android_log_processBinaryLogBuffer(&buf->entry_v1, &entry, 131 g_eventTagMap, 132 binaryMsgBuf, 133 sizeof(binaryMsgBuf)); 134 //printf(">>> pri=%d len=%d msg='%s'\n", 135 // entry.priority, entry.messageLen, entry.message); 136 } else { 137 err = android_log_processLogBuffer(&buf->entry_v1, &entry); 138 } 139 if (err < 0) { 140 goto error; 141 } 142 143 if (android_log_shouldPrintLine(g_logformat, entry.tag, entry.priority)) { 144 if (false && g_devCount > 1) { 145 binaryMsgBuf[0] = dev->label; 146 binaryMsgBuf[1] = ' '; 147 bytesWritten = write(g_outFD, binaryMsgBuf, 2); 148 if (bytesWritten < 0) { 149 perror("output error"); 150 exit(-1); 151 } 152 } 153 154 bytesWritten = android_log_printLogLine(g_logformat, g_outFD, &entry); 155 156 if (bytesWritten < 0) { 157 perror("output error"); 158 exit(-1); 159 } 160 } 161 162 g_outByteCount += bytesWritten; 163 164 if (g_logRotateSizeKBytes > 0 165 && (g_outByteCount / 1024) >= g_logRotateSizeKBytes 166 ) { 167 rotateLogs(); 168 } 169 170error: 171 //fprintf (stderr, "Error processing record\n"); 172 return; 173} 174 175static void maybePrintStart(log_device_t* dev) { 176 if (!dev->printed) { 177 dev->printed = true; 178 if (g_devCount > 1 && !g_printBinary) { 179 char buf[1024]; 180 snprintf(buf, sizeof(buf), "--------- beginning of %s\n", 181 dev->device); 182 if (write(g_outFD, buf, strlen(buf)) < 0) { 183 perror("output error"); 184 exit(-1); 185 } 186 } 187 } 188} 189 190static void setupOutput() 191{ 192 193 if (g_outputFileName == NULL) { 194 g_outFD = STDOUT_FILENO; 195 196 } else { 197 struct stat statbuf; 198 199 g_outFD = openLogFile (g_outputFileName); 200 201 if (g_outFD < 0) { 202 perror ("couldn't open output file"); 203 exit(-1); 204 } 205 206 fstat(g_outFD, &statbuf); 207 208 g_outByteCount = statbuf.st_size; 209 } 210} 211 212static void show_help(const char *cmd) 213{ 214 fprintf(stderr,"Usage: %s [options] [filterspecs]\n", cmd); 215 216 fprintf(stderr, "options include:\n" 217 " -s Set default filter to silent.\n" 218 " Like specifying filterspec '*:s'\n" 219 " -f <filename> Log to file. Default to stdout\n" 220 " -r [<kbytes>] Rotate log every kbytes. (16 if unspecified). Requires -f\n" 221 " -n <count> Sets max number of rotated logs to <count>, default 4\n" 222 " -v <format> Sets the log print format, where <format> is one of:\n\n" 223 " brief process tag thread raw time threadtime long\n\n" 224 " -c clear (flush) the entire log and exit\n" 225 " -d dump the log and then exit (don't block)\n" 226 " -t <count> print only the most recent <count> lines (implies -d)\n" 227 " -T <count> print only the most recent <count> lines (does not imply -d)\n" 228 " -g get the size of the log's ring buffer and exit\n" 229 " -b <buffer> Request alternate ring buffer, 'main', 'system', 'radio',\n" 230 " 'events', 'crash' or 'all'. Multiple -b parameters are\n" 231 " allowed and results are interleaved. The default is\n" 232 " -b main -b system -b crash.\n" 233 " -B output the log in binary.\n" 234 " -S output statistics.\n" 235 " -G <size> set size of log ring buffer, may suffix with K or M.\n" 236 " -p print prune white and ~black list. Service is specified as\n" 237 " UID, UID/PID or /PID. Weighed for quicker pruning if prefix\n" 238 " with ~, otherwise weighed for longevity if unadorned. All\n" 239 " other pruning activity is oldest first. Special case ~!\n" 240 " represents an automatic quicker pruning for the noisiest\n" 241 " UID as determined by the current statistics.\n" 242 " -P '<list> ...' set prune white and ~black list, using same format as\n" 243 " printed above. Must be quoted.\n"); 244 245 fprintf(stderr,"\nfilterspecs are a series of \n" 246 " <tag>[:priority]\n\n" 247 "where <tag> is a log component tag (or * for all) and priority is:\n" 248 " V Verbose\n" 249 " D Debug\n" 250 " I Info\n" 251 " W Warn\n" 252 " E Error\n" 253 " F Fatal\n" 254 " S Silent (supress all output)\n" 255 "\n'*' means '*:d' and <tag> by itself means <tag>:v\n" 256 "\nIf not specified on the commandline, filterspec is set from ANDROID_LOG_TAGS.\n" 257 "If no filterspec is found, filter defaults to '*:I'\n" 258 "\nIf not specified with -v, format is set from ANDROID_PRINTF_LOG\n" 259 "or defaults to \"brief\"\n\n"); 260 261 262 263} 264 265 266} /* namespace android */ 267 268static int setLogFormat(const char * formatString) 269{ 270 static AndroidLogPrintFormat format; 271 272 format = android_log_formatFromString(formatString); 273 274 if (format == FORMAT_OFF) { 275 // FORMAT_OFF means invalid string 276 return -1; 277 } 278 279 android_log_setPrintFormat(g_logformat, format); 280 281 return 0; 282} 283 284static const char multipliers[][2] = { 285 { "" }, 286 { "K" }, 287 { "M" }, 288 { "G" } 289}; 290 291static unsigned long value_of_size(unsigned long value) 292{ 293 for (unsigned i = 0; 294 (i < sizeof(multipliers)/sizeof(multipliers[0])) && (value >= 1024); 295 value /= 1024, ++i) ; 296 return value; 297} 298 299static const char *multiplier_of_size(unsigned long value) 300{ 301 unsigned i; 302 for (i = 0; 303 (i < sizeof(multipliers)/sizeof(multipliers[0])) && (value >= 1024); 304 value /= 1024, ++i) ; 305 return multipliers[i]; 306} 307 308int main(int argc, char **argv) 309{ 310 int err; 311 int hasSetLogFormat = 0; 312 int clearLog = 0; 313 int getLogSize = 0; 314 unsigned long setLogSize = 0; 315 int getPruneList = 0; 316 char *setPruneList = NULL; 317 int printStatistics = 0; 318 int mode = O_RDONLY; 319 const char *forceFilters = NULL; 320 log_device_t* devices = NULL; 321 log_device_t* dev; 322 bool needBinary = false; 323 struct logger_list *logger_list; 324 unsigned int tail_lines = 0; 325 log_time tail_time(log_time::EPOCH); 326 327 signal(SIGPIPE, exit); 328 329 g_logformat = android_log_format_new(); 330 331 if (argc == 2 && 0 == strcmp(argv[1], "--help")) { 332 android::show_help(argv[0]); 333 exit(0); 334 } 335 336 for (;;) { 337 int ret; 338 339 ret = getopt(argc, argv, "cdt:T:gG:sQf:r::n:v:b:BSpP:"); 340 341 if (ret < 0) { 342 break; 343 } 344 345 switch(ret) { 346 case 's': 347 // default to all silent 348 android_log_addFilterRule(g_logformat, "*:s"); 349 break; 350 351 case 'c': 352 clearLog = 1; 353 mode = O_WRONLY; 354 break; 355 356 case 'd': 357 mode = O_RDONLY | O_NDELAY; 358 break; 359 360 case 't': 361 mode = O_RDONLY | O_NDELAY; 362 /* FALLTHRU */ 363 case 'T': 364 if (strspn(optarg, "0123456789") != strlen(optarg)) { 365 char *cp = tail_time.strptime(optarg, 366 log_time::default_format); 367 if (!cp) { 368 fprintf(stderr, 369 "ERROR: -%c \"%s\" not in \"%s\" time format\n", 370 ret, optarg, log_time::default_format); 371 exit(1); 372 } 373 if (*cp) { 374 char c = *cp; 375 *cp = '\0'; 376 fprintf(stderr, 377 "WARNING: -%c \"%s\"\"%c%s\" time truncated\n", 378 ret, optarg, c, cp + 1); 379 *cp = c; 380 } 381 } else { 382 tail_lines = atoi(optarg); 383 if (!tail_lines) { 384 fprintf(stderr, 385 "WARNING: -%c %s invalid, setting to 1\n", 386 ret, optarg); 387 tail_lines = 1; 388 } 389 } 390 break; 391 392 case 'g': 393 getLogSize = 1; 394 break; 395 396 case 'G': { 397 // would use atol if not for the multiplier 398 char *cp = optarg; 399 setLogSize = 0; 400 while (('0' <= *cp) && (*cp <= '9')) { 401 setLogSize *= 10; 402 setLogSize += *cp - '0'; 403 ++cp; 404 } 405 406 switch(*cp) { 407 case 'g': 408 case 'G': 409 setLogSize *= 1024; 410 /* FALLTHRU */ 411 case 'm': 412 case 'M': 413 setLogSize *= 1024; 414 /* FALLTHRU */ 415 case 'k': 416 case 'K': 417 setLogSize *= 1024; 418 /* FALLTHRU */ 419 case '\0': 420 break; 421 422 default: 423 setLogSize = 0; 424 } 425 426 if (!setLogSize) { 427 fprintf(stderr, "ERROR: -G <num><multiplier>\n"); 428 exit(1); 429 } 430 } 431 break; 432 433 case 'p': 434 getPruneList = 1; 435 break; 436 437 case 'P': 438 setPruneList = optarg; 439 break; 440 441 case 'b': { 442 if (strcmp(optarg, "all") == 0) { 443 while (devices) { 444 dev = devices; 445 devices = dev->next; 446 delete dev; 447 } 448 449 dev = devices = new log_device_t("main", false, 'm'); 450 android::g_devCount = 1; 451 if (android_name_to_log_id("system") == LOG_ID_SYSTEM) { 452 dev->next = new log_device_t("system", false, 's'); 453 if (dev->next) { 454 dev = dev->next; 455 android::g_devCount++; 456 } 457 } 458 if (android_name_to_log_id("radio") == LOG_ID_RADIO) { 459 dev->next = new log_device_t("radio", false, 'r'); 460 if (dev->next) { 461 dev = dev->next; 462 android::g_devCount++; 463 } 464 } 465 if (android_name_to_log_id("events") == LOG_ID_EVENTS) { 466 dev->next = new log_device_t("events", true, 'e'); 467 if (dev->next) { 468 dev = dev->next; 469 android::g_devCount++; 470 needBinary = true; 471 } 472 } 473 if (android_name_to_log_id("crash") == LOG_ID_CRASH) { 474 dev->next = new log_device_t("crash", false, 'c'); 475 if (dev->next) { 476 android::g_devCount++; 477 } 478 } 479 break; 480 } 481 482 bool binary = strcmp(optarg, "events") == 0; 483 if (binary) { 484 needBinary = true; 485 } 486 487 if (devices) { 488 dev = devices; 489 while (dev->next) { 490 dev = dev->next; 491 } 492 dev->next = new log_device_t(optarg, binary, optarg[0]); 493 } else { 494 devices = new log_device_t(optarg, binary, optarg[0]); 495 } 496 android::g_devCount++; 497 } 498 break; 499 500 case 'B': 501 android::g_printBinary = 1; 502 break; 503 504 case 'f': 505 // redirect output to a file 506 507 android::g_outputFileName = optarg; 508 509 break; 510 511 case 'r': 512 if (optarg == NULL) { 513 android::g_logRotateSizeKBytes 514 = DEFAULT_LOG_ROTATE_SIZE_KBYTES; 515 } else { 516 if (!isdigit(optarg[0])) { 517 fprintf(stderr,"Invalid parameter to -r\n"); 518 android::show_help(argv[0]); 519 exit(-1); 520 } 521 android::g_logRotateSizeKBytes = atoi(optarg); 522 } 523 break; 524 525 case 'n': 526 if (!isdigit(optarg[0])) { 527 fprintf(stderr,"Invalid parameter to -r\n"); 528 android::show_help(argv[0]); 529 exit(-1); 530 } 531 532 android::g_maxRotatedLogs = atoi(optarg); 533 break; 534 535 case 'v': 536 err = setLogFormat (optarg); 537 if (err < 0) { 538 fprintf(stderr,"Invalid parameter to -v\n"); 539 android::show_help(argv[0]); 540 exit(-1); 541 } 542 543 hasSetLogFormat = 1; 544 break; 545 546 case 'Q': 547 /* this is a *hidden* option used to start a version of logcat */ 548 /* in an emulated device only. it basically looks for androidboot.logcat= */ 549 /* on the kernel command line. If something is found, it extracts a log filter */ 550 /* and uses it to run the program. If nothing is found, the program should */ 551 /* quit immediately */ 552#define KERNEL_OPTION "androidboot.logcat=" 553#define CONSOLE_OPTION "androidboot.console=" 554 { 555 int fd; 556 char* logcat; 557 char* console; 558 int force_exit = 1; 559 static char cmdline[1024]; 560 561 fd = open("/proc/cmdline", O_RDONLY); 562 if (fd >= 0) { 563 int n = read(fd, cmdline, sizeof(cmdline)-1 ); 564 if (n < 0) n = 0; 565 cmdline[n] = 0; 566 close(fd); 567 } else { 568 cmdline[0] = 0; 569 } 570 571 logcat = strstr( cmdline, KERNEL_OPTION ); 572 console = strstr( cmdline, CONSOLE_OPTION ); 573 if (logcat != NULL) { 574 char* p = logcat + sizeof(KERNEL_OPTION)-1;; 575 char* q = strpbrk( p, " \t\n\r" );; 576 577 if (q != NULL) 578 *q = 0; 579 580 forceFilters = p; 581 force_exit = 0; 582 } 583 /* if nothing found or invalid filters, exit quietly */ 584 if (force_exit) 585 exit(0); 586 587 /* redirect our output to the emulator console */ 588 if (console) { 589 char* p = console + sizeof(CONSOLE_OPTION)-1; 590 char* q = strpbrk( p, " \t\n\r" ); 591 char devname[64]; 592 int len; 593 594 if (q != NULL) { 595 len = q - p; 596 } else 597 len = strlen(p); 598 599 len = snprintf( devname, sizeof(devname), "/dev/%.*s", len, p ); 600 fprintf(stderr, "logcat using %s (%d)\n", devname, len); 601 if (len < (int)sizeof(devname)) { 602 fd = open( devname, O_WRONLY ); 603 if (fd >= 0) { 604 dup2(fd, 1); 605 dup2(fd, 2); 606 close(fd); 607 } 608 } 609 } 610 } 611 break; 612 613 case 'S': 614 printStatistics = 1; 615 break; 616 617 default: 618 fprintf(stderr,"Unrecognized Option\n"); 619 android::show_help(argv[0]); 620 exit(-1); 621 break; 622 } 623 } 624 625 if (!devices) { 626 devices = new log_device_t("main", false, 'm'); 627 android::g_devCount = 1; 628 if (android_name_to_log_id("system") == LOG_ID_SYSTEM) { 629 devices->next = new log_device_t("system", false, 's'); 630 android::g_devCount++; 631 } 632 if (android_name_to_log_id("crash") == LOG_ID_CRASH) { 633 if (devices->next) { 634 devices->next->next = new log_device_t("crash", false, 'c'); 635 } else { 636 devices->next = new log_device_t("crash", false, 'c'); 637 } 638 android::g_devCount++; 639 } 640 } 641 642 if (android::g_logRotateSizeKBytes != 0 643 && android::g_outputFileName == NULL 644 ) { 645 fprintf(stderr,"-r requires -f as well\n"); 646 android::show_help(argv[0]); 647 exit(-1); 648 } 649 650 android::setupOutput(); 651 652 if (hasSetLogFormat == 0) { 653 const char* logFormat = getenv("ANDROID_PRINTF_LOG"); 654 655 if (logFormat != NULL) { 656 err = setLogFormat(logFormat); 657 658 if (err < 0) { 659 fprintf(stderr, "invalid format in ANDROID_PRINTF_LOG '%s'\n", 660 logFormat); 661 } 662 } 663 } 664 665 if (forceFilters) { 666 err = android_log_addFilterString(g_logformat, forceFilters); 667 if (err < 0) { 668 fprintf (stderr, "Invalid filter expression in -logcat option\n"); 669 exit(0); 670 } 671 } else if (argc == optind) { 672 // Add from environment variable 673 char *env_tags_orig = getenv("ANDROID_LOG_TAGS"); 674 675 if (env_tags_orig != NULL) { 676 err = android_log_addFilterString(g_logformat, env_tags_orig); 677 678 if (err < 0) { 679 fprintf(stderr, "Invalid filter expression in" 680 " ANDROID_LOG_TAGS\n"); 681 android::show_help(argv[0]); 682 exit(-1); 683 } 684 } 685 } else { 686 // Add from commandline 687 for (int i = optind ; i < argc ; i++) { 688 err = android_log_addFilterString(g_logformat, argv[i]); 689 690 if (err < 0) { 691 fprintf (stderr, "Invalid filter expression '%s'\n", argv[i]); 692 android::show_help(argv[0]); 693 exit(-1); 694 } 695 } 696 } 697 698 dev = devices; 699 if (tail_time != log_time::EPOCH) { 700 logger_list = android_logger_list_alloc_time(mode, tail_time, 0); 701 } else { 702 logger_list = android_logger_list_alloc(mode, tail_lines, 0); 703 } 704 while (dev) { 705 dev->logger_list = logger_list; 706 dev->logger = android_logger_open(logger_list, 707 android_name_to_log_id(dev->device)); 708 if (!dev->logger) { 709 fprintf(stderr, "Unable to open log device '%s'\n", dev->device); 710 exit(EXIT_FAILURE); 711 } 712 713 if (clearLog) { 714 int ret; 715 ret = android_logger_clear(dev->logger); 716 if (ret) { 717 perror("failed to clear the log"); 718 exit(EXIT_FAILURE); 719 } 720 } 721 722 if (setLogSize && android_logger_set_log_size(dev->logger, setLogSize)) { 723 perror("failed to set the log size"); 724 exit(EXIT_FAILURE); 725 } 726 727 if (getLogSize) { 728 long size, readable; 729 730 size = android_logger_get_log_size(dev->logger); 731 if (size < 0) { 732 perror("failed to get the log size"); 733 exit(EXIT_FAILURE); 734 } 735 736 readable = android_logger_get_log_readable_size(dev->logger); 737 if (readable < 0) { 738 perror("failed to get the readable log size"); 739 exit(EXIT_FAILURE); 740 } 741 742 printf("%s: ring buffer is %ld%sb (%ld%sb consumed), " 743 "max entry is %db, max payload is %db\n", dev->device, 744 value_of_size(size), multiplier_of_size(size), 745 value_of_size(readable), multiplier_of_size(readable), 746 (int) LOGGER_ENTRY_MAX_LEN, (int) LOGGER_ENTRY_MAX_PAYLOAD); 747 } 748 749 dev = dev->next; 750 } 751 752 if (setPruneList) { 753 size_t len = strlen(setPruneList) + 32; // margin to allow rc 754 char *buf = (char *) malloc(len); 755 756 strcpy(buf, setPruneList); 757 int ret = android_logger_set_prune_list(logger_list, buf, len); 758 free(buf); 759 760 if (ret) { 761 perror("failed to set the prune list"); 762 exit(EXIT_FAILURE); 763 } 764 } 765 766 if (printStatistics || getPruneList) { 767 size_t len = 8192; 768 char *buf; 769 770 for(int retry = 32; 771 (retry >= 0) && ((buf = new char [len])); 772 delete [] buf, --retry) { 773 if (getPruneList) { 774 android_logger_get_prune_list(logger_list, buf, len); 775 } else { 776 android_logger_get_statistics(logger_list, buf, len); 777 } 778 buf[len-1] = '\0'; 779 size_t ret = atol(buf) + 1; 780 if (ret < 4) { 781 delete [] buf; 782 buf = NULL; 783 break; 784 } 785 bool check = ret <= len; 786 len = ret; 787 if (check) { 788 break; 789 } 790 } 791 792 if (!buf) { 793 perror("failed to read data"); 794 exit(EXIT_FAILURE); 795 } 796 797 // remove trailing FF 798 char *cp = buf + len - 1; 799 *cp = '\0'; 800 bool truncated = *--cp != '\f'; 801 if (!truncated) { 802 *cp = '\0'; 803 } 804 805 // squash out the byte count 806 cp = buf; 807 if (!truncated) { 808 while (isdigit(*cp)) { 809 ++cp; 810 } 811 if (*cp == '\n') { 812 ++cp; 813 } 814 } 815 816 printf("%s", cp); 817 delete [] buf; 818 exit(0); 819 } 820 821 822 if (getLogSize) { 823 exit(0); 824 } 825 if (setLogSize || setPruneList) { 826 exit(0); 827 } 828 if (clearLog) { 829 exit(0); 830 } 831 832 //LOG_EVENT_INT(10, 12345); 833 //LOG_EVENT_LONG(11, 0x1122334455667788LL); 834 //LOG_EVENT_STRING(0, "whassup, doc?"); 835 836 if (needBinary) 837 android::g_eventTagMap = android_openEventTagMap(EVENT_TAG_MAP_FILE); 838 839 while (1) { 840 struct log_msg log_msg; 841 int ret = android_logger_list_read(logger_list, &log_msg); 842 843 if (ret == 0) { 844 fprintf(stderr, "read: Unexpected EOF!\n"); 845 exit(EXIT_FAILURE); 846 } 847 848 if (ret < 0) { 849 if (ret == -EAGAIN) { 850 break; 851 } 852 853 if (ret == -EIO) { 854 fprintf(stderr, "read: Unexpected EOF!\n"); 855 exit(EXIT_FAILURE); 856 } 857 if (ret == -EINVAL) { 858 fprintf(stderr, "read: unexpected length.\n"); 859 exit(EXIT_FAILURE); 860 } 861 perror("logcat read failure"); 862 exit(EXIT_FAILURE); 863 } 864 865 for(dev = devices; dev; dev = dev->next) { 866 if (android_name_to_log_id(dev->device) == log_msg.id()) { 867 break; 868 } 869 } 870 if (!dev) { 871 fprintf(stderr, "read: Unexpected log ID!\n"); 872 exit(EXIT_FAILURE); 873 } 874 875 android::maybePrintStart(dev); 876 if (android::g_printBinary) { 877 android::printBinary(&log_msg); 878 } else { 879 android::processBuffer(dev, &log_msg); 880 } 881 } 882 883 android_logger_list_free(logger_list); 884 885 return 0; 886} 887