Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012-2013 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 | |
Mark Salyzyn | fa3716b | 2014-02-14 16:05:05 -0800 | [diff] [blame] | 17 | #include <ctype.h> |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 18 | #include <poll.h> |
Mark Salyzyn | 8daa9af | 2014-04-28 14:07:23 -0700 | [diff] [blame] | 19 | #include <sys/prctl.h> |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 20 | #include <sys/socket.h> |
Mark Salyzyn | dfc47e8 | 2014-03-24 10:26:47 -0700 | [diff] [blame] | 21 | |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 22 | #include <cutils/sockets.h> |
| 23 | |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 24 | #include "FlushCommand.h" |
Mark Salyzyn | 2ad0bd0 | 2016-02-23 08:55:43 -0800 | [diff] [blame^] | 25 | #include "LogBuffer.h" |
| 26 | #include "LogBufferElement.h" |
| 27 | #include "LogReader.h" |
| 28 | #include "LogUtils.h" |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 29 | |
Mark Salyzyn | 7718778 | 2015-05-12 15:21:31 -0700 | [diff] [blame] | 30 | LogReader::LogReader(LogBuffer *logbuf) : |
| 31 | SocketListener(getLogSocket(), true), |
| 32 | mLogbuf(*logbuf) { |
| 33 | } |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 34 | |
| 35 | // When we are notified a new log entry is available, inform |
| 36 | // all of our listening sockets. |
| 37 | void LogReader::notifyNewLog() { |
| 38 | FlushCommand command(*this); |
| 39 | runOnEachSocket(&command); |
| 40 | } |
| 41 | |
| 42 | bool LogReader::onDataAvailable(SocketClient *cli) { |
Mark Salyzyn | e3aeeee | 2015-03-17 07:56:32 -0700 | [diff] [blame] | 43 | static bool name_set; |
| 44 | if (!name_set) { |
| 45 | prctl(PR_SET_NAME, "logd.reader"); |
| 46 | name_set = true; |
| 47 | } |
Mark Salyzyn | 8daa9af | 2014-04-28 14:07:23 -0700 | [diff] [blame] | 48 | |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 49 | char buffer[255]; |
| 50 | |
| 51 | int len = read(cli->getSocket(), buffer, sizeof(buffer) - 1); |
| 52 | if (len <= 0) { |
| 53 | doSocketDelete(cli); |
| 54 | return false; |
| 55 | } |
| 56 | buffer[len] = '\0'; |
| 57 | |
| 58 | unsigned long tail = 0; |
| 59 | static const char _tail[] = " tail="; |
| 60 | char *cp = strstr(buffer, _tail); |
| 61 | if (cp) { |
| 62 | tail = atol(cp + sizeof(_tail) - 1); |
| 63 | } |
| 64 | |
Mark Salyzyn | fa3716b | 2014-02-14 16:05:05 -0800 | [diff] [blame] | 65 | log_time start(log_time::EPOCH); |
| 66 | static const char _start[] = " start="; |
| 67 | cp = strstr(buffer, _start); |
| 68 | if (cp) { |
| 69 | // Parse errors will result in current time |
| 70 | start.strptime(cp + sizeof(_start) - 1, "%s.%q"); |
| 71 | } |
| 72 | |
Mark Salyzyn | b75cce0 | 2015-11-30 11:35:56 -0800 | [diff] [blame] | 73 | uint64_t timeout = 0; |
| 74 | static const char _timeout[] = " timeout="; |
| 75 | cp = strstr(buffer, _timeout); |
| 76 | if (cp) { |
| 77 | timeout = atol(cp + sizeof(_timeout) - 1) * NS_PER_SEC + |
| 78 | log_time(CLOCK_REALTIME).nsec(); |
| 79 | } |
| 80 | |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 81 | unsigned int logMask = -1; |
| 82 | static const char _logIds[] = " lids="; |
| 83 | cp = strstr(buffer, _logIds); |
| 84 | if (cp) { |
| 85 | logMask = 0; |
| 86 | cp += sizeof(_logIds) - 1; |
| 87 | while (*cp && *cp != '\0') { |
| 88 | int val = 0; |
Mark Salyzyn | fa3716b | 2014-02-14 16:05:05 -0800 | [diff] [blame] | 89 | while (isdigit(*cp)) { |
| 90 | val = val * 10 + *cp - '0'; |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 91 | ++cp; |
| 92 | } |
| 93 | logMask |= 1 << val; |
| 94 | if (*cp != ',') { |
| 95 | break; |
| 96 | } |
| 97 | ++cp; |
| 98 | } |
| 99 | } |
| 100 | |
| 101 | pid_t pid = 0; |
| 102 | static const char _pid[] = " pid="; |
| 103 | cp = strstr(buffer, _pid); |
| 104 | if (cp) { |
| 105 | pid = atol(cp + sizeof(_pid) - 1); |
| 106 | } |
| 107 | |
| 108 | bool nonBlock = false; |
Mark Salyzyn | ddda212 | 2015-10-02 09:22:52 -0700 | [diff] [blame] | 109 | if (!fast<strncmp>(buffer, "dumpAndClose", 12)) { |
Mark Salyzyn | f669acb | 2014-09-16 09:19:47 -0700 | [diff] [blame] | 110 | // Allow writer to get some cycles, and wait for pending notifications |
| 111 | sched_yield(); |
| 112 | LogTimeEntry::lock(); |
| 113 | LogTimeEntry::unlock(); |
| 114 | sched_yield(); |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 115 | nonBlock = true; |
| 116 | } |
| 117 | |
Mark Salyzyn | f7c0f75 | 2015-03-03 13:39:37 -0800 | [diff] [blame] | 118 | uint64_t sequence = 1; |
| 119 | // Convert realtime to sequence number |
| 120 | if (start != log_time::EPOCH) { |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 121 | class LogFindStart { |
| 122 | const pid_t mPid; |
| 123 | const unsigned mLogMask; |
| 124 | bool startTimeSet; |
| 125 | log_time &start; |
Mark Salyzyn | f7c0f75 | 2015-03-03 13:39:37 -0800 | [diff] [blame] | 126 | uint64_t &sequence; |
| 127 | uint64_t last; |
Mark Salyzyn | b6bee33 | 2015-09-08 08:56:32 -0700 | [diff] [blame] | 128 | bool isMonotonic; |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 129 | |
| 130 | public: |
Mark Salyzyn | b6bee33 | 2015-09-08 08:56:32 -0700 | [diff] [blame] | 131 | LogFindStart(unsigned logMask, pid_t pid, log_time &start, uint64_t &sequence, bool isMonotonic) : |
Mark Salyzyn | 7718778 | 2015-05-12 15:21:31 -0700 | [diff] [blame] | 132 | mPid(pid), |
| 133 | mLogMask(logMask), |
| 134 | startTimeSet(false), |
| 135 | start(start), |
| 136 | sequence(sequence), |
Mark Salyzyn | b6bee33 | 2015-09-08 08:56:32 -0700 | [diff] [blame] | 137 | last(sequence), |
| 138 | isMonotonic(isMonotonic) { |
Mark Salyzyn | 7718778 | 2015-05-12 15:21:31 -0700 | [diff] [blame] | 139 | } |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 140 | |
Mark Salyzyn | f7c0f75 | 2015-03-03 13:39:37 -0800 | [diff] [blame] | 141 | static int callback(const LogBufferElement *element, void *obj) { |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 142 | LogFindStart *me = reinterpret_cast<LogFindStart *>(obj); |
Mark Salyzyn | f7c0f75 | 2015-03-03 13:39:37 -0800 | [diff] [blame] | 143 | if ((!me->mPid || (me->mPid == element->getPid())) |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 144 | && (me->mLogMask & (1 << element->getLogId()))) { |
| 145 | if (me->start == element->getRealTime()) { |
Mark Salyzyn | f7c0f75 | 2015-03-03 13:39:37 -0800 | [diff] [blame] | 146 | me->sequence = element->getSequence(); |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 147 | me->startTimeSet = true; |
Mark Salyzyn | f7c0f75 | 2015-03-03 13:39:37 -0800 | [diff] [blame] | 148 | return -1; |
Mark Salyzyn | b6bee33 | 2015-09-08 08:56:32 -0700 | [diff] [blame] | 149 | } else if (!me->isMonotonic || |
| 150 | android::isMonotonic(element->getRealTime())) { |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 151 | if (me->start < element->getRealTime()) { |
Mark Salyzyn | f7c0f75 | 2015-03-03 13:39:37 -0800 | [diff] [blame] | 152 | me->sequence = me->last; |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 153 | me->startTimeSet = true; |
Mark Salyzyn | f7c0f75 | 2015-03-03 13:39:37 -0800 | [diff] [blame] | 154 | return -1; |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 155 | } |
Mark Salyzyn | f7c0f75 | 2015-03-03 13:39:37 -0800 | [diff] [blame] | 156 | me->last = element->getSequence(); |
Mark Salyzyn | b6bee33 | 2015-09-08 08:56:32 -0700 | [diff] [blame] | 157 | } else { |
| 158 | me->last = element->getSequence(); |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 159 | } |
| 160 | } |
| 161 | return false; |
| 162 | } |
| 163 | |
| 164 | bool found() { return startTimeSet; } |
Mark Salyzyn | b6bee33 | 2015-09-08 08:56:32 -0700 | [diff] [blame] | 165 | } logFindStart(logMask, pid, start, sequence, |
| 166 | logbuf().isMonotonic() && android::isMonotonic(start)); |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 167 | |
Mark Salyzyn | f7c0f75 | 2015-03-03 13:39:37 -0800 | [diff] [blame] | 168 | logbuf().flushTo(cli, sequence, FlushCommand::hasReadLogs(cli), |
Mark Salyzyn | 8fa8896 | 2016-01-26 14:32:35 -0800 | [diff] [blame] | 169 | FlushCommand::hasSecurityLogs(cli), |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 170 | logFindStart.callback, &logFindStart); |
| 171 | |
| 172 | if (!logFindStart.found()) { |
| 173 | if (nonBlock) { |
| 174 | doSocketDelete(cli); |
| 175 | return false; |
| 176 | } |
Mark Salyzyn | f7c0f75 | 2015-03-03 13:39:37 -0800 | [diff] [blame] | 177 | sequence = LogBufferElement::getCurrentSequence(); |
Mark Salyzyn | a1c60cf | 2014-02-19 07:33:12 -0800 | [diff] [blame] | 178 | } |
Mark Salyzyn | fa3716b | 2014-02-14 16:05:05 -0800 | [diff] [blame] | 179 | } |
| 180 | |
Mark Salyzyn | b75cce0 | 2015-11-30 11:35:56 -0800 | [diff] [blame] | 181 | FlushCommand command(*this, nonBlock, tail, logMask, pid, sequence, timeout); |
Mark Salyzyn | 0175b07 | 2014-02-26 09:50:16 -0800 | [diff] [blame] | 182 | command.runSocketCommand(cli); |
| 183 | return true; |
| 184 | } |
| 185 | |
| 186 | void LogReader::doSocketDelete(SocketClient *cli) { |
| 187 | LastLogTimes × = mLogbuf.mTimes; |
| 188 | LogTimeEntry::lock(); |
| 189 | LastLogTimes::iterator it = times.begin(); |
| 190 | while(it != times.end()) { |
| 191 | LogTimeEntry *entry = (*it); |
| 192 | if (entry->mClient == cli) { |
| 193 | times.erase(it); |
| 194 | entry->release_Locked(); |
| 195 | break; |
| 196 | } |
| 197 | it++; |
| 198 | } |
| 199 | LogTimeEntry::unlock(); |
| 200 | } |
Mark Salyzyn | dfc47e8 | 2014-03-24 10:26:47 -0700 | [diff] [blame] | 201 | |
| 202 | int LogReader::getLogSocket() { |
| 203 | static const char socketName[] = "logdr"; |
| 204 | int sock = android_get_control_socket(socketName); |
| 205 | |
| 206 | if (sock < 0) { |
| 207 | sock = socket_local_server(socketName, |
| 208 | ANDROID_SOCKET_NAMESPACE_RESERVED, |
| 209 | SOCK_SEQPACKET); |
| 210 | } |
| 211 | |
| 212 | return sock; |
| 213 | } |