/* * Copyright (C) 2012-2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include "FlushCommand.h" #include "LogBuffer.h" #include "LogBufferElement.h" #include "LogReader.h" #include "LogUtils.h" LogReader::LogReader(LogBuffer* logbuf) : SocketListener(getLogSocket(), true), mLogbuf(*logbuf) { } // When we are notified a new log entry is available, inform // listening sockets who are watching this entry's log id. void LogReader::notifyNewLog(log_mask_t logMask) { FlushCommand command(*this, logMask); runOnEachSocket(&command); } // Note returning false will release the SocketClient instance. bool LogReader::onDataAvailable(SocketClient* cli) { static bool name_set; if (!name_set) { prctl(PR_SET_NAME, "logd.reader"); name_set = true; } char buffer[255]; int len = read(cli->getSocket(), buffer, sizeof(buffer) - 1); if (len <= 0) { doSocketDelete(cli); return false; } buffer[len] = '\0'; // Clients are only allowed to send one command, disconnect them if they // send another. LogTimeEntry::wrlock(); for (const auto& entry : mLogbuf.mTimes) { if (entry->mClient == cli) { entry->release_Locked(); LogTimeEntry::unlock(); return false; } } LogTimeEntry::unlock(); unsigned long tail = 0; static const char _tail[] = " tail="; char* cp = strstr(buffer, _tail); if (cp) { tail = atol(cp + sizeof(_tail) - 1); } log_time start(log_time::EPOCH); static const char _start[] = " start="; cp = strstr(buffer, _start); if (cp) { // Parse errors will result in current time start.strptime(cp + sizeof(_start) - 1, "%s.%q"); } uint64_t timeout = 0; static const char _timeout[] = " timeout="; cp = strstr(buffer, _timeout); if (cp) { timeout = atol(cp + sizeof(_timeout) - 1) * NS_PER_SEC + log_time(CLOCK_REALTIME).nsec(); } unsigned int logMask = -1; static const char _logIds[] = " lids="; cp = strstr(buffer, _logIds); if (cp) { logMask = 0; cp += sizeof(_logIds) - 1; while (*cp && *cp != '\0') { int val = 0; while (isdigit(*cp)) { val = val * 10 + *cp - '0'; ++cp; } logMask |= 1 << val; if (*cp != ',') { break; } ++cp; } } pid_t pid = 0; static const char _pid[] = " pid="; cp = strstr(buffer, _pid); if (cp) { pid = atol(cp + sizeof(_pid) - 1); } bool nonBlock = false; if (!fastcmp(buffer, "dumpAndClose", 12)) { // Allow writer to get some cycles, and wait for pending notifications sched_yield(); LogTimeEntry::wrlock(); LogTimeEntry::unlock(); sched_yield(); nonBlock = true; } log_time sequence = start; // // This somewhat expensive data validation operation is required // for non-blocking, with timeout. The incoming timestamp must be // in range of the list, if not, return immediately. This is // used to prevent us from from getting stuck in timeout processing // with an invalid time. // // Find if time is really present in the logs, monotonic or real, implicit // conversion from monotonic or real as necessary to perform the check. // Exit in the check loop ASAP as you find a transition from older to // newer, but use the last entry found to ensure overlap. // if (nonBlock && (sequence != log_time::EPOCH) && timeout) { class LogFindStart { // A lambda by another name private: const pid_t mPid; const unsigned mLogMask; bool mStartTimeSet; log_time mStart; log_time& mSequence; log_time mLast; bool mIsMonotonic; public: LogFindStart(pid_t pid, unsigned logMask, log_time& sequence, bool isMonotonic) : mPid(pid), mLogMask(logMask), mStartTimeSet(false), mStart(sequence), mSequence(sequence), mLast(sequence), mIsMonotonic(isMonotonic) { } static int callback(const LogBufferElement* element, void* obj) { LogFindStart* me = reinterpret_cast(obj); if ((!me->mPid || (me->mPid == element->getPid())) && (me->mLogMask & (1 << element->getLogId()))) { log_time real = element->getRealTime(); if (me->mStart == real) { me->mSequence = real; me->mStartTimeSet = true; return -1; } else if (!me->mIsMonotonic || android::isMonotonic(real)) { if (me->mStart < real) { me->mSequence = me->mLast; me->mStartTimeSet = true; return -1; } me->mLast = real; } else { me->mLast = real; } } return false; } bool found() { return mStartTimeSet; } } logFindStart(pid, logMask, sequence, logbuf().isMonotonic() && android::isMonotonic(start)); logbuf().flushTo(cli, sequence, nullptr, FlushCommand::hasReadLogs(cli), FlushCommand::hasSecurityLogs(cli), logFindStart.callback, &logFindStart); if (!logFindStart.found()) { doSocketDelete(cli); return false; } } android::prdebug( "logdr: UID=%d GID=%d PID=%d %c tail=%lu logMask=%x pid=%d " "start=%" PRIu64 "ns timeout=%" PRIu64 "ns\n", cli->getUid(), cli->getGid(), cli->getPid(), nonBlock ? 'n' : 'b', tail, logMask, (int)pid, sequence.nsec(), timeout); LogTimeEntry::wrlock(); auto entry = std::make_unique( *this, cli, nonBlock, tail, logMask, pid, sequence, timeout); if (!entry->startReader_Locked()) { LogTimeEntry::unlock(); return false; } // release client and entry reference counts once done cli->incRef(); mLogbuf.mTimes.emplace_front(std::move(entry)); // Set acceptable upper limit to wait for slow reader processing b/27242723 struct timeval t = { LOGD_SNDTIMEO, 0 }; setsockopt(cli->getSocket(), SOL_SOCKET, SO_SNDTIMEO, (const char*)&t, sizeof(t)); LogTimeEntry::unlock(); return true; } void LogReader::doSocketDelete(SocketClient* cli) { LastLogTimes& times = mLogbuf.mTimes; LogTimeEntry::wrlock(); LastLogTimes::iterator it = times.begin(); while (it != times.end()) { LogTimeEntry* entry = it->get(); if (entry->mClient == cli) { entry->release_Locked(); break; } it++; } LogTimeEntry::unlock(); } int LogReader::getLogSocket() { static const char socketName[] = "logdr"; int sock = android_get_control_socket(socketName); if (sock < 0) { sock = socket_local_server( socketName, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_SEQPACKET); } return sock; }