1 /*
2  * Copyright (C) 2016 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 #pragma once
17 
18 #ifndef SECTIONS_H
19 #define SECTIONS_H
20 
21 #include "Reporter.h"
22 
23 #include <stdarg.h>
24 #include <map>
25 
26 #include <utils/String16.h>
27 #include <utils/String8.h>
28 #include <utils/Vector.h>
29 
30 namespace android {
31 namespace os {
32 namespace incidentd {
33 
34 const int64_t REMOTE_CALL_TIMEOUT_MS = 30 * 1000;  // 30 seconds
35 
36 /**
37  * Base class for sections
38  */
39 class Section {
40 public:
41     const int id;
42     const int64_t timeoutMs;  // each section must have a timeout
43     String8 name;
44 
45     Section(int id, int64_t timeoutMs = REMOTE_CALL_TIMEOUT_MS);
46     virtual ~Section();
47 
48     virtual status_t Execute(ReportWriter* writer) const = 0;
49 };
50 
51 /**
52  * Section that reads in a file.
53  */
54 class FileSection : public Section {
55 public:
56     FileSection(int id, const char* filename,
57                 int64_t timeoutMs = 5000 /* 5 seconds */);
58     virtual ~FileSection();
59 
60     virtual status_t Execute(ReportWriter* writer) const;
61 
62 private:
63     const char* mFilename;
64     bool mIsSysfs;  // sysfs files are pollable but return POLLERR by default, handle it separately
65 };
66 
67 /**
68  * Section that reads in a file and gzips the content.
69  */
70 class GZipSection : public Section {
71 public:
72     GZipSection(int id, const char* filename, ...);
73     virtual ~GZipSection();
74 
75     virtual status_t Execute(ReportWriter* writer) const;
76 
77 private:
78     // It looks up the content from multiple files and stops when the first one is available.
79     const char** mFilenames;
80 };
81 
82 /**
83  * Base class for sections that call a command that might need a timeout.
84  */
85 class WorkerThreadSection : public Section {
86 public:
87     WorkerThreadSection(int id, int64_t timeoutMs = REMOTE_CALL_TIMEOUT_MS);
88     virtual ~WorkerThreadSection();
89 
90     virtual status_t Execute(ReportWriter* writer) const;
91 
92     virtual status_t BlockingCall(int pipeWriteFd) const = 0;
93 };
94 
95 /**
96  * Section that forks and execs a command, and puts stdout as the section.
97  */
98 class CommandSection : public Section {
99 public:
100     CommandSection(int id, int64_t timeoutMs, const char* command, ...);
101 
102     CommandSection(int id, const char* command, ...);
103 
104     virtual ~CommandSection();
105 
106     virtual status_t Execute(ReportWriter* writer) const;
107 
108 private:
109     const char** mCommand;
110 };
111 
112 /**
113  * Section that calls dumpsys on a system service.
114  */
115 class DumpsysSection : public WorkerThreadSection {
116 public:
117     DumpsysSection(int id, const char* service, ...);
118     virtual ~DumpsysSection();
119 
120     virtual status_t BlockingCall(int pipeWriteFd) const;
121 
122 private:
123     String16 mService;
124     Vector<String16> mArgs;
125 };
126 
127 /**
128  * Section that calls dumpsys on a system service.
129  */
130 class SystemPropertyDumpsysSection : public WorkerThreadSection {
131 public:
132     SystemPropertyDumpsysSection(int id, const char* service, ...);
133     virtual ~SystemPropertyDumpsysSection();
134 
135     virtual status_t BlockingCall(int pipeWriteFd) const;
136 
137 private:
138     String16 mService;
139     Vector<String16> mArgs;
140 };
141 
142 /**
143  * Section that reads from logd.
144  */
145 class LogSection : public WorkerThreadSection {
146     // global last log retrieved timestamp for each log_id_t.
147     static map<log_id_t, log_time> gLastLogsRetrieved;
148 
149 public:
150     LogSection(int id, log_id_t logID);
151     virtual ~LogSection();
152 
153     virtual status_t BlockingCall(int pipeWriteFd) const;
154 
155 private:
156     log_id_t mLogID;
157     bool mBinary;
158 };
159 
160 /**
161  * Section that gets data from tombstoned.
162  */
163 class TombstoneSection : public WorkerThreadSection {
164 public:
165     TombstoneSection(int id, const char* type, int64_t timeoutMs = 120000 /* 2 minutes */);
166     virtual ~TombstoneSection();
167 
168     virtual status_t BlockingCall(int pipeWriteFd) const;
169 
170 private:
171     std::string mType;
172 };
173 
174 
175 /**
176  * These sections will not be generated when doing an 'all' report, either
177  * for size, speed of collection, or privacy.
178  */
179 bool section_requires_specific_mention(int sectionId);
180 
181 }  // namespace incidentd
182 }  // namespace os
183 }  // namespace android
184 
185 #endif  // SECTIONS_H
186