bool LogKlog::onDataAvailable(SocketClient *cli) { if (!initialized) { prctl(PR_SET_NAME, "logd.klogd"); initialized = true; enableLogging = false; } char buffer[LOGGER_ENTRY_MAX_PAYLOAD]; size_t len = 0; for(;;) { ssize_t retval = 0; if ((sizeof(buffer) - 1 - len) > 0) { retval = read(cli->getSocket(), buffer + len, sizeof(buffer) - 1 - len); } if ((retval == 0) && (len == 0)) { break; } if (retval < 0) { return false; } len += retval; bool full = len == (sizeof(buffer) - 1); char *ep = buffer + len; *ep = '\0'; len = 0; for(char *ptr = NULL, *tok = buffer; ((tok = log_strtok_r(tok, &ptr))); tok = NULL) { if (((tok + strlen(tok)) == ep) && (retval != 0) && full) { len = strlen(tok); memmove(buffer, tok, len); break; } if (*tok) { log(tok); } } } return true; }
static void readDmesg(LogAudit *al, LogKlog *kl) { if (!al && !kl) { return; } int len = klogctl(KLOG_SIZE_BUFFER, NULL, 0); if (len <= 0) { return; } len += 1024; // Margin for additional input race or trailing nul std::unique_ptr<char []> buf(new char[len]); int rc = klogctl(KLOG_READ_ALL, buf.get(), len); if (rc <= 0) { return; } if (rc < len) { len = rc + 1; } buf[len - 1] = '\0'; if (kl) { kl->synchronize(buf.get()); } for (char *ptr = NULL, *tok = buf.get(); (rc >= 0) && ((tok = log_strtok_r(tok, &ptr))); tok = NULL) { if (al) { rc = al->log(tok); } if (kl) { rc = kl->log(tok); } } }
// Foreground waits for exit of the main persistent threads // that are started here. The threads are created to manage // UNIX domain client sockets for writing, reading and // controlling the user space logger, and for any additional // logging plugins like auditd and restart control. Additional // transitory per-client threads are created for each reader. int main(int argc, char *argv[]) { int fdPmesg = -1; bool klogd = property_get_bool_svelte("logd.klogd"); if (klogd) { fdPmesg = open("/proc/kmsg", O_RDONLY | O_NDELAY); } fdDmesg = open("/dev/kmsg", O_WRONLY); // issue reinit command. KISS argument parsing. if ((argc > 1) && argv[1] && !strcmp(argv[1], "--reinit")) { int sock = TEMP_FAILURE_RETRY( socket_local_client("logd", ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM)); if (sock < 0) { return -errno; } static const char reinit[] = "reinit"; ssize_t ret = TEMP_FAILURE_RETRY(write(sock, reinit, sizeof(reinit))); if (ret < 0) { return -errno; } struct pollfd p; memset(&p, 0, sizeof(p)); p.fd = sock; p.events = POLLIN; ret = TEMP_FAILURE_RETRY(poll(&p, 1, 100)); if (ret < 0) { return -errno; } if ((ret == 0) || !(p.revents & POLLIN)) { return -ETIME; } static const char success[] = "success"; char buffer[sizeof(success) - 1]; memset(buffer, 0, sizeof(buffer)); ret = TEMP_FAILURE_RETRY(read(sock, buffer, sizeof(buffer))); if (ret < 0) { return -errno; } return strncmp(buffer, success, sizeof(success) - 1) != 0; } // Reinit Thread sem_init(&reinit, 0, 0); sem_init(&uidName, 0, 0); sem_init(&sem_name, 0, 1); pthread_attr_t attr; if (!pthread_attr_init(&attr)) { struct sched_param param; memset(¶m, 0, sizeof(param)); pthread_attr_setschedparam(&attr, ¶m); pthread_attr_setschedpolicy(&attr, SCHED_BATCH); if (!pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)) { pthread_t thread; reinit_running = true; if (pthread_create(&thread, &attr, reinit_thread_start, NULL)) { reinit_running = false; } } pthread_attr_destroy(&attr); } if (drop_privs() != 0) { return -1; } // Serves the purpose of managing the last logs times read on a // socket connection, and as a reader lock on a range of log // entries. LastLogTimes *times = new LastLogTimes(); // LogBuffer is the object which is responsible for holding all // log entries. logBuf = new LogBuffer(times); signal(SIGHUP, reinit_signal_handler); if (property_get_bool_svelte("logd.statistics")) { logBuf->enableStatistics(); } // LogReader listens on /dev/socket/logdr. When a client // connects, log entries in the LogBuffer are written to the client. LogReader *reader = new LogReader(logBuf); if (reader->startListener()) { exit(1); } // LogListener listens on /dev/socket/logdw for client // initiated log messages. New log entries are added to LogBuffer // and LogReader is notified to send updates to connected clients. LogListener *swl = new LogListener(logBuf, reader); // Backlog and /proc/sys/net/unix/max_dgram_qlen set to large value if (swl->startListener(300)) { exit(1); } // Command listener listens on /dev/socket/logd for incoming logd // administrative commands. CommandListener *cl = new CommandListener(logBuf, reader, swl); if (cl->startListener()) { exit(1); } // LogAudit listens on NETLINK_AUDIT socket for selinux // initiated log messages. New log entries are added to LogBuffer // and LogReader is notified to send updates to connected clients. bool auditd = property_get_bool("logd.auditd", true); LogAudit *al = NULL; if (auditd) { bool dmesg = property_get_bool("logd.auditd.dmesg", true); al = new LogAudit(logBuf, reader, dmesg ? fdDmesg : -1); } LogKlog *kl = NULL; if (klogd) { kl = new LogKlog(logBuf, reader, fdDmesg, fdPmesg, al != NULL); } if (al || kl) { int len = klogctl(KLOG_SIZE_BUFFER, NULL, 0); if (len > 0) { len++; char buf[len]; int rc = klogctl(KLOG_READ_ALL, buf, len); buf[len - 1] = '\0'; if ((rc >= 0) && kl) { kl->synchronize(buf); } for (char *ptr = NULL, *tok = buf; (rc >= 0) && ((tok = log_strtok_r(tok, &ptr))); tok = NULL) { if (al) { rc = al->log(tok); } if (kl) { rc = kl->log(tok); } } } // failure is an option ... messages are in dmesg (required by standard) if (kl && kl->startListener()) { delete kl; } if (al && al->startListener()) { delete al; } } TEMP_FAILURE_RETRY(pause()); exit(0); }