Home | History | Annotate | Download | only in src 
      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