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#ifndef _LOGD_LOG_TIMES_H__
18#define _LOGD_LOG_TIMES_H__
19
20#include <pthread.h>
21#include <time.h>
22#include <sys/types.h>
23#include <sysutils/SocketClient.h>
24#include <utils/List.h>
25#include <log/log.h>
26
27class LogReader;
28
29class LogTimeEntry {
30    static pthread_mutex_t timesLock;
31    unsigned int mRefCount;
32    bool mRelease;
33    bool mError;
34    bool threadRunning;
35    bool leadingDropped;
36    pthread_cond_t threadTriggeredCondition;
37    pthread_t mThread;
38    LogReader &mReader;
39    static void *threadStart(void *me);
40    static void threadStop(void *me);
41    const unsigned int mLogMask;
42    const pid_t mPid;
43    unsigned int skipAhead[LOG_ID_MAX];
44    unsigned long mCount;
45    unsigned long mTail;
46    unsigned long mIndex;
47
48public:
49    LogTimeEntry(LogReader &reader, SocketClient *client, bool nonBlock,
50                 unsigned long tail, unsigned int logMask, pid_t pid,
51                 uint64_t start);
52
53    SocketClient *mClient;
54    uint64_t mStart;
55    const bool mNonBlock;
56    const uint64_t mEnd; // only relevant if mNonBlock
57
58    // Protect List manipulations
59    static void lock(void) { pthread_mutex_lock(&timesLock); }
60    static void unlock(void) { pthread_mutex_unlock(&timesLock); }
61
62    void startReader_Locked(void);
63
64    bool runningReader_Locked(void) const {
65        return threadRunning || mRelease || mError || mNonBlock;
66    }
67    void triggerReader_Locked(void) {
68        pthread_cond_signal(&threadTriggeredCondition);
69    }
70
71    void triggerSkip_Locked(log_id_t id, unsigned int skip) { skipAhead[id] = skip; }
72    void cleanSkip_Locked(void);
73
74    // Called after LogTimeEntry removed from list, lock implicitly held
75    void release_Locked(void) {
76        mRelease = true;
77        pthread_cond_signal(&threadTriggeredCondition);
78        if (mRefCount || threadRunning) {
79            return;
80        }
81        // No one else is holding a reference to this
82        delete this;
83    }
84
85    // Called to mark socket in jeopardy
86    void error_Locked(void) { mError = true; }
87    void error(void) { lock(); error_Locked(); unlock(); }
88
89    bool isError_Locked(void) const { return mRelease || mError; }
90
91    // Mark Used
92    //  Locking implied, grabbed when protection around loop iteration
93    void incRef_Locked(void) { ++mRefCount; }
94
95    bool owned_Locked(void) const { return mRefCount != 0; }
96
97    void decRef_Locked(void) {
98        if ((mRefCount && --mRefCount) || !mRelease || threadRunning) {
99            return;
100        }
101        // No one else is holding a reference to this
102        delete this;
103    }
104    bool isWatching(log_id_t id) { return (mLogMask & (1<<id)) != 0; }
105    // flushTo filter callbacks
106    static int FilterFirstPass(const LogBufferElement *element, void *me);
107    static int FilterSecondPass(const LogBufferElement *element, void *me);
108};
109
110typedef android::List<LogTimeEntry *> LastLogTimes;
111
112#endif
113