1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "trace_streamer_selector.h"
17 #include <algorithm>
18 #include <chrono>
19 #include <functional>
20 #include "args_filter.h"
21 #include "binder_filter.h"
22 #include "clock_filter.h"
23 #include "cpu_filter.h"
24 #include "file.h"
25 #include "filter_filter.h"
26 #include "irq_filter.h"
27 #include "measure_filter.h"
28 #include "parser/bytrace_parser/bytrace_parser.h"
29 #include "parser/htrace_parser/htrace_parser.h"
30 #include "process_filter.h"
31 #include "slice_filter.h"
32 #include "stat_filter.h"
33 #include "symbols_filter.h"
34 #include "system_event_measure_filter.h"
35
36 using namespace SysTuning::base;
37 namespace SysTuning {
38 namespace TraceStreamer {
39 namespace {
GuessFileType(const uint8_t * data,size_t size)40 TraceFileType GuessFileType(const uint8_t* data, size_t size)
41 {
42 if (size == 0) {
43 return TRACE_FILETYPE_UN_KNOW;
44 }
45 std::string start(reinterpret_cast<const char*>(data), std::min<size_t>(size, 20));
46 if (start.find("# tracer") != std::string::npos) {
47 return TRACE_FILETYPE_BY_TRACE;
48 }
49 if (start.find("# TRACE") != std::string::npos) {
50 return TRACE_FILETYPE_BY_TRACE;
51 }
52 if ((start.compare(0, std::string("<!DOCTYPE html>").length(), "<!DOCTYPE html>") == 0) ||
53 (start.compare(0, std::string("<html>").length(), "<html>") == 0)) {
54 return TRACE_FILETYPE_BY_TRACE;
55 }
56 if (start.compare(0, std::string("\x0a").length(), "\x0a") == 0) {
57 return TRACE_FILETYPE_UN_KNOW;
58 }
59 if (start.compare(0, std::string("OHOSPROF").length(), "OHOSPROF") == 0) {
60 return TRACE_FILETYPE_H_TRACE;
61 }
62 if (start.compare(0, std::string("\x0a").length(), "\x0a") == 0) {
63 return TRACE_FILETYPE_UN_KNOW;
64 }
65 return TRACE_FILETYPE_UN_KNOW;
66 }
67 } // namespace
68
TraceStreamerSelector()69 TraceStreamerSelector::TraceStreamerSelector()
70 : fileType_(TRACE_FILETYPE_UN_KNOW), bytraceParser_(nullptr), htraceParser_(nullptr)
71 {
72 InitFilter();
73 InitParser();
74 }
~TraceStreamerSelector()75 TraceStreamerSelector::~TraceStreamerSelector() {}
76
InitFilter()77 void TraceStreamerSelector::InitFilter()
78 {
79 streamFilters_ = std::make_unique<TraceStreamerFilters>();
80 traceDataCache_ = std::make_unique<TraceDataCache>();
81 streamFilters_->cpuFilter_ = std::make_unique<CpuFilter>(traceDataCache_.get(), streamFilters_.get());
82 streamFilters_->sliceFilter_ = std::make_unique<SliceFilter>(traceDataCache_.get(), streamFilters_.get());
83
84 streamFilters_->processFilter_ = std::make_unique<ProcessFilter>(traceDataCache_.get(), streamFilters_.get());
85 streamFilters_->clockFilter_ = std::make_unique<ClockFilter>(traceDataCache_.get(), streamFilters_.get());
86 streamFilters_->filterFilter_ = std::make_unique<FilterFilter>(traceDataCache_.get(), streamFilters_.get());
87
88 streamFilters_->threadMeasureFilter_ =
89 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_THREADMEASURE_FILTER);
90 streamFilters_->threadFilter_ =
91 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_THREAD_FILTER);
92 streamFilters_->cpuMeasureFilter_ =
93 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CPU_MEASURE_FILTER);
94 streamFilters_->processMeasureFilter_ =
95 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_PROCESS_MEASURE_FILTER);
96 streamFilters_->processFilterFilter_ =
97 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_PROCESS_FILTER_FILTER);
98 streamFilters_->symbolsFilter_ = std::make_unique<SymbolsFilter>(traceDataCache_.get(), streamFilters_.get());
99 streamFilters_->statFilter_ = std::make_unique<StatFilter>(traceDataCache_.get(), streamFilters_.get());
100 streamFilters_->binderFilter_ = std::make_unique<BinderFilter>(traceDataCache_.get(), streamFilters_.get());
101 streamFilters_->argsFilter_ = std::make_unique<ArgsFilter>(traceDataCache_.get(), streamFilters_.get());
102 streamFilters_->irqFilter_ = std::make_unique<IrqFilter>(traceDataCache_.get(), streamFilters_.get());
103 streamFilters_->clockRateFilter_ =
104 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLOCK_RATE_FILTER);
105 streamFilters_->clockEnableFilter_ =
106 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLOCK_ENABLE_FILTER);
107 streamFilters_->clockDisableFilter_ =
108 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLOCK_DISABLE_FILTER);
109 streamFilters_->clkRateFilter_ =
110 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLK_RATE_FILTER);
111 streamFilters_->clkEnableFilter_ =
112 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLK_ENABLE_FILTER);
113 streamFilters_->clkDisableFilter_ =
114 std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLK_DISABLE_FILTER);
115 streamFilters_->sysEventMemMeasureFilter_ =
116 std::make_unique<SystemEventMeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_SYS_MEMORY_FILTER);
117 streamFilters_->sysEventVMemMeasureFilter_ = std::make_unique<SystemEventMeasureFilter>(
118 traceDataCache_.get(), streamFilters_.get(), E_SYS_VIRTUAL_MEMORY_FILTER);
119 }
InitParser()120 void TraceStreamerSelector::InitParser()
121 {
122 bytraceParser_ = std::make_unique<BytraceParser>(traceDataCache_.get(), streamFilters_.get());
123 htraceParser_ = std::make_unique<HtraceParser>(traceDataCache_.get(), streamFilters_.get());
124 }
125
WaitForParserEnd()126 void TraceStreamerSelector::WaitForParserEnd()
127 {
128 if (fileType_ == TRACE_FILETYPE_H_TRACE) {
129 htraceParser_->WaitForParserEnd();
130 }
131 if (fileType_ == TRACE_FILETYPE_BY_TRACE) {
132 bytraceParser_->WaitForParserEnd();
133 }
134 }
135
GetMetaData()136 MetaData* TraceStreamerSelector::GetMetaData()
137 {
138 return traceDataCache_->GetMetaData();
139 }
ParseTraceDataSegment(std::unique_ptr<uint8_t[]> data,size_t size)140 bool TraceStreamerSelector::ParseTraceDataSegment(std::unique_ptr<uint8_t[]> data, size_t size)
141 {
142 if (size == 0) {
143 return true;
144 }
145 if (fileType_ == TRACE_FILETYPE_UN_KNOW) {
146 fileType_ = GuessFileType(data.get(), size);
147 if (fileType_ == TRACE_FILETYPE_UN_KNOW) {
148 SetAnalysisResult(TRACE_PARSER_FILE_TYPE_ERROR);
149 TS_LOGI(
150 "File type is not supported!,\nthe head content is:%s\n ---waring!!!---\n"
151 "File type is not supported!,\n",
152 data.get());
153 return false;
154 }
155 }
156 if (fileType_ == TRACE_FILETYPE_H_TRACE) {
157 htraceParser_->ParseTraceDataSegment(std::move(data), size);
158 }
159 if (fileType_ == TRACE_FILETYPE_BY_TRACE) {
160 bytraceParser_->ParseTraceDataSegment(std::move(data), size);
161 }
162 SetAnalysisResult(TRACE_PARSER_NORMAL);
163 return true;
164 }
EnableMetaTable(bool enabled)165 void TraceStreamerSelector::EnableMetaTable(bool enabled)
166 {
167 traceDataCache_->EnableMetaTable(enabled);
168 }
169
SetCleanMode(bool cleanMode)170 void TraceStreamerSelector::SetCleanMode(bool cleanMode)
171 {
172 g_cleanMode = true;
173 }
ExportDatabase(const std::string & outputName) const174 int TraceStreamerSelector::ExportDatabase(const std::string& outputName) const
175 {
176 traceDataCache_->UpdateTraceRange();
177 return traceDataCache_->ExportDatabase(outputName);
178 }
SearchData(const std::string & outputName)179 int TraceStreamerSelector::SearchData(const std::string& outputName)
180 {
181 return traceDataCache_->SearchData(outputName);
182 }
183 } // namespace TraceStreamer
184 } // namespace SysTuning
185