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