1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
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 "bytrace_event_parser.h"
17 #include "app_start_filter.h"
18 #include "binder_filter.h"
19 #include "cpu_filter.h"
20 #include "filter_filter.h"
21 #include "irq_filter.h"
22 #include "measure_filter.h"
23 #include "parting_string.h"
24 #include "process_filter.h"
25 #include "slice_filter.h"
26 #include "stat_filter.h"
27 #include "string_to_numerical.h"
28 #include "thread_state_flag.h"
29 #include "ts_common.h"
30 namespace SysTuning {
31 namespace TraceStreamer {
32 namespace {
GetFunctionName(const std::string_view & text,const std::string_view & delimiter)33 std::string GetFunctionName(const std::string_view &text, const std::string_view &delimiter)
34 {
35 std::string str("");
36 if (delimiter.empty()) {
37 return str;
38 }
39
40 std::size_t foundIndex = text.find(delimiter);
41 if (foundIndex != std::string::npos) {
42 std::size_t funIndex = foundIndex + delimiter.size();
43 str = std::string(text.substr(funIndex, text.size() - funIndex));
44 }
45 return str;
46 }
47 } // namespace
48
BytraceEventParser(TraceDataCache * dataCache,const TraceStreamerFilters * filter)49 BytraceEventParser::BytraceEventParser(TraceDataCache *dataCache, const TraceStreamerFilters *filter)
50 : EventParserBase(dataCache, filter), printEventParser_(traceDataCache_, streamFilters_)
51 {
52 printEventParser_.SetTraceType(TRACE_FILETYPE_BY_TRACE);
53 eventToFunctionMap_ = {
54 {config_.eventNameMap_.at(TRACE_EVENT_TASK_RENAME),
55 bind(&BytraceEventParser::TaskRenameEvent, this, std::placeholders::_1, std::placeholders::_2)},
56 {config_.eventNameMap_.at(TRACE_EVENT_TASK_NEWTASK),
57 bind(&BytraceEventParser::TaskNewtaskEvent, this, std::placeholders::_1, std::placeholders::_2)},
58 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_SWITCH),
59 bind(&BytraceEventParser::SchedSwitchEvent, this, std::placeholders::_1, std::placeholders::_2)},
60 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_BLOCKED_REASON),
61 bind(&BytraceEventParser::BlockedReason, this, std::placeholders::_1, std::placeholders::_2)},
62 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP),
63 bind(&BytraceEventParser::SchedWakeupEvent, this, std::placeholders::_1, std::placeholders::_2)},
64 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKING),
65 bind(&BytraceEventParser::SchedWakingEvent, this, std::placeholders::_1, std::placeholders::_2)},
66 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP_NEW),
67 bind(&BytraceEventParser::SchedWakeupEvent, this, std::placeholders::_1, std::placeholders::_2)},
68 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_EXIT),
69 bind(&BytraceEventParser::ProcessExitEvent, this, std::placeholders::_1, std::placeholders::_2)},
70 {config_.eventNameMap_.at(TRACE_EVENT_IPI_ENTRY),
71 bind(&BytraceEventParser::IpiEntryEvent, this, std::placeholders::_1, std::placeholders::_2)},
72 {config_.eventNameMap_.at(TRACE_EVENT_IPI_EXIT),
73 bind(&BytraceEventParser::IpiExitEvent, this, std::placeholders::_1, std::placeholders::_2)},
74 };
75 InterruptEventInitialization();
76 ClockEventInitialization();
77 CpuEventInitialization();
78 RegulatorEventInitialization();
79 BinderEventInitialization();
80 StackEventsInitialization();
81 eventList_.reserve(maxBuffSize_);
82 }
83
InterruptEventInitialization()84 void BytraceEventParser::InterruptEventInitialization()
85 {
86 // Interrupt and soft interrupt event initialization
87 eventToFunctionMap_.emplace(
88 config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_ENTRY),
89 bind(&BytraceEventParser::IrqHandlerEntryEvent, this, std::placeholders::_1, std::placeholders::_2));
90 eventToFunctionMap_.emplace(
91 config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_EXIT),
92 bind(&BytraceEventParser::IrqHandlerExitEvent, this, std::placeholders::_1, std::placeholders::_2));
93 eventToFunctionMap_.emplace(
94 config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_RAISE),
95 bind(&BytraceEventParser::SoftIrqRaiseEvent, this, std::placeholders::_1, std::placeholders::_2));
96 eventToFunctionMap_.emplace(
97 config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_ENTRY),
98 bind(&BytraceEventParser::SoftIrqEntryEvent, this, std::placeholders::_1, std::placeholders::_2));
99 eventToFunctionMap_.emplace(
100 config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_EXIT),
101 bind(&BytraceEventParser::SoftIrqExitEvent, this, std::placeholders::_1, std::placeholders::_2));
102 eventToFunctionMap_.emplace(
103 config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_INIT),
104 bind(&BytraceEventParser::DmaFenceEvent, this, std::placeholders::_1, std::placeholders::_2));
105 eventToFunctionMap_.emplace(
106 config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_DESTROY),
107 bind(&BytraceEventParser::DmaFenceEvent, this, std::placeholders::_1, std::placeholders::_2));
108 eventToFunctionMap_.emplace(
109 config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_ENABLE),
110 bind(&BytraceEventParser::DmaFenceEvent, this, std::placeholders::_1, std::placeholders::_2));
111 eventToFunctionMap_.emplace(
112 config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_SIGNALED),
113 bind(&BytraceEventParser::DmaFenceEvent, this, std::placeholders::_1, std::placeholders::_2));
114 }
115
ClockEventInitialization()116 void BytraceEventParser::ClockEventInitialization()
117 {
118 // Clock event initialization
119 eventToFunctionMap_.emplace(
120 config_.eventNameMap_.at(TRACE_EVENT_CLOCK_SET_RATE),
121 bind(&BytraceEventParser::SetRateEvent, this, std::placeholders::_1, std::placeholders::_2));
122 eventToFunctionMap_.emplace(
123 config_.eventNameMap_.at(TRACE_EVENT_CLOCK_ENABLE),
124 bind(&BytraceEventParser::ClockEnableEvent, this, std::placeholders::_1, std::placeholders::_2));
125 eventToFunctionMap_.emplace(
126 config_.eventNameMap_.at(TRACE_EVENT_CLOCK_DISABLE),
127 bind(&BytraceEventParser::ClockDisableEvent, this, std::placeholders::_1, std::placeholders::_2));
128 }
129
CpuEventInitialization()130 void BytraceEventParser::CpuEventInitialization()
131 {
132 eventToFunctionMap_.emplace(
133 config_.eventNameMap_.at(TRACE_EVENT_CPU_IDLE),
134 bind(&BytraceEventParser::CpuIdleEvent, this, std::placeholders::_1, std::placeholders::_2));
135 eventToFunctionMap_.emplace(
136 config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY),
137 bind(&BytraceEventParser::CpuFrequencyEvent, this, std::placeholders::_1, std::placeholders::_2));
138 eventToFunctionMap_.emplace(
139 config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY_LIMITS),
140 bind(&BytraceEventParser::CpuFrequencyLimitsEvent, this, std::placeholders::_1, std::placeholders::_2));
141 }
142
RegulatorEventInitialization()143 void BytraceEventParser::RegulatorEventInitialization()
144 {
145 // Initialize regulator related events
146 eventToFunctionMap_.emplace(
147 config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE),
148 bind(&BytraceEventParser::RegulatorSetVoltageEvent, this, std::placeholders::_1, std::placeholders::_2));
149 eventToFunctionMap_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE),
150 bind(&BytraceEventParser::RegulatorSetVoltageCompleteEvent, this, std::placeholders::_1,
151 std::placeholders::_2));
152 eventToFunctionMap_.emplace(
153 config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE),
154 bind(&BytraceEventParser::RegulatorDisableEvent, this, std::placeholders::_1, std::placeholders::_2));
155 eventToFunctionMap_.emplace(
156 config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE),
157 bind(&BytraceEventParser::RegulatorDisableCompleteEvent, this, std::placeholders::_1, std::placeholders::_2));
158 }
159
BinderEventInitialization()160 void BytraceEventParser::BinderEventInitialization()
161 {
162 // Binder event initialization
163 eventToFunctionMap_.emplace(
164 config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION),
165 bind(&BytraceEventParser::BinderTransaction, this, std::placeholders::_1, std::placeholders::_2));
166 eventToFunctionMap_.emplace(
167 config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED),
168 bind(&BytraceEventParser::BinderTransactionReceived, this, std::placeholders::_1, std::placeholders::_2));
169 eventToFunctionMap_.emplace(
170 config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF),
171 bind(&BytraceEventParser::BinderTransactionAllocBufEvent, this, std::placeholders::_1, std::placeholders::_2));
172 }
173
StackEventsInitialization()174 void BytraceEventParser::StackEventsInitialization()
175 {
176 // Call stack Events
177 eventToFunctionMap_.emplace(
178 config_.eventNameMap_.at(TRACE_EVENT_TRACING_MARK_WRITE),
179 bind(&BytraceEventParser::TracingMarkWriteOrPrintEvent, this, std::placeholders::_1, std::placeholders::_2));
180 eventToFunctionMap_.emplace(
181 config_.eventNameMap_.at(TRACE_EVENT_PRINT),
182 bind(&BytraceEventParser::TracingMarkWriteOrPrintEvent, this, std::placeholders::_1, std::placeholders::_2));
183 eventToFunctionMap_.emplace(
184 config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_START),
185 bind(&BytraceEventParser::WorkqueueExecuteStartEvent, this, std::placeholders::_1, std::placeholders::_2));
186 eventToFunctionMap_.emplace(
187 config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_END),
188 bind(&BytraceEventParser::WorkqueueExecuteEndEvent, this, std::placeholders::_1, std::placeholders::_2));
189 }
190
SchedSwitchEvent(const ArgsMap & args,const BytraceLine & line) const191 bool BytraceEventParser::SchedSwitchEvent(const ArgsMap &args, const BytraceLine &line) const
192 {
193 if (args.empty() || args.size() < MIN_SCHED_SWITCH_ARGS_COUNT) {
194 TS_LOGW("Failed to parse sched_switch event, no args or args size < 6, argsStr=%s.", line.argsStr.data());
195 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_DATA_INVALID);
196 return false;
197 }
198 auto prevCommStr = std::string_view(args.at("prev_comm"));
199 auto nextCommStr = std::string_view(args.at("next_comm"));
200 auto prevPrioValue = base::StrToInt<int32_t>(args.at("prev_prio"));
201 auto nextPrioValue = base::StrToInt<int32_t>(args.at("next_prio"));
202 auto prevPidValue = base::StrToInt<uint32_t>(args.at("prev_pid"));
203 auto nextPidValue = base::StrToInt<uint32_t>(args.at("next_pid"));
204 DataIndex nextInfo = INVALID_DATAINDEX;
205 auto nextInfoIt = args.find("next_info");
206 if (nextInfoIt != args.end()) {
207 nextInfo = traceDataCache_->GetDataIndex(std::string_view(args.at("next_info")));
208 }
209 if (!(prevPidValue.has_value() && prevPrioValue.has_value() && nextPidValue.has_value() &&
210 nextPrioValue.has_value())) {
211 TS_LOGD("Failed to parse sched_switch event");
212 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_DATA_INVALID);
213 return false;
214 }
215 auto prevStateStr = args.at("prev_state");
216 auto threadState = ThreadStateFlag(prevStateStr.c_str());
217 uint64_t prevState = threadState.State();
218 if (threadState.IsInvalid()) {
219 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_DATA_INVALID);
220 }
221 uint32_t nextInternalTid = 0;
222 uint32_t uprevtid = 0;
223 nextInternalTid =
224 streamFilters_->processFilter_->UpdateOrCreateThreadWithName(line.ts, nextPidValue.value(), nextCommStr);
225
226 if (!prevCommStr.empty()) {
227 uprevtid =
228 streamFilters_->processFilter_->UpdateOrCreateThreadWithName(line.ts, prevPidValue.value(), prevCommStr);
229 } else {
230 uprevtid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, prevPidValue.value());
231 }
232 streamFilters_->cpuFilter_->InsertSwitchEvent(line.ts, line.cpu, uprevtid, prevPrioValue.value(), prevState,
233 nextInternalTid, nextPrioValue.value(), nextInfo);
234 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_SWITCH, STAT_EVENT_RECEIVED);
235 return true;
236 }
BlockedReason(const ArgsMap & args,const BytraceLine & line) const237 bool BytraceEventParser::BlockedReason(const ArgsMap &args, const BytraceLine &line) const
238 {
239 if (args.empty() || args.size() < MIN_BLOCKED_REASON_ARGS_COUNT) {
240 TS_LOGD("Failed to parse blocked_reason event, no args or args size < %d", MIN_BLOCKED_REASON_ARGS_COUNT);
241 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_DATA_INVALID);
242 return false;
243 }
244 auto tid = base::StrToInt<int32_t>(args.at("pid"));
245 auto iowaitIt = args.find("iowait");
246 if (iowaitIt == args.end()) {
247 iowaitIt = args.find("io_wait");
248 }
249 auto iowait = base::StrToInt<int32_t>(iowaitIt->second);
250 uint32_t delayValue = INVALID_UINT32;
251 if (args.find("delay") != args.end()) {
252 auto delay = base::StrToInt<int32_t>(args.at("delay"));
253 delayValue = delay.has_value() ? delay.value() : INVALID_UINT32;
254 }
255 auto caller = traceDataCache_->GetDataIndex(std::string_view(args.at("caller")));
256 if (!(tid.has_value() && iowait.has_value())) {
257 TS_LOGD("Failed to parse blocked_reason event");
258 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_DATA_INVALID);
259 return false;
260 }
261 auto iTid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, tid.value());
262 if (streamFilters_->cpuFilter_->InsertBlockedReasonEvent(line.cpu, iTid, iowait.value(), caller, delayValue)) {
263 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_RECEIVED);
264 } else {
265 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_BLOCKED_REASON, STAT_EVENT_NOTMATCH);
266 }
267 return true;
268 }
269
TaskRenameEvent(const ArgsMap & args,const BytraceLine & line) const270 bool BytraceEventParser::TaskRenameEvent(const ArgsMap &args, const BytraceLine &line) const
271 {
272 if (args.empty() || args.size() < MIN_TASK_RENAME_ARGS_COUNT) {
273 TS_LOGD("Failed to parse task_rename event, no args or args size < 2");
274 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_RENAME, STAT_EVENT_DATA_INVALID);
275 return false;
276 }
277 auto prevCommStr = std::string_view(args.at("newcomm"));
278 auto pidValue = base::StrToInt<uint32_t>(args.at("pid"));
279 streamFilters_->processFilter_->UpdateOrCreateThreadWithName(line.ts, pidValue.value(), prevCommStr);
280 return true;
281 }
282
TaskNewtaskEvent(const ArgsMap & args,const BytraceLine & line) const283 bool BytraceEventParser::TaskNewtaskEvent(const ArgsMap &args, const BytraceLine &line) const
284 {
285 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_RECEIVED);
286 // the clone flag from txt trace from kernel original is HEX, but when it is converted from proto
287 // based trace, it will be OCT number, it is not stable, so we decide to ignore it
288 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TASK_NEWTASK, STAT_EVENT_NOTSUPPORTED);
289 return true;
290 }
291
TracingMarkWriteOrPrintEvent(const ArgsMap & args,const BytraceLine & line)292 bool BytraceEventParser::TracingMarkWriteOrPrintEvent(const ArgsMap &args, const BytraceLine &line)
293 {
294 Unused(args);
295 return printEventParser_.ParsePrintEvent(line.task, line.ts, line.pid, line.argsStr.c_str(), line);
296 }
297 // prefer to use waking, unless no waking, can use wakeup
SchedWakeupEvent(const ArgsMap & args,const BytraceLine & line) const298 bool BytraceEventParser::SchedWakeupEvent(const ArgsMap &args, const BytraceLine &line) const
299 {
300 if (args.size() < MIN_SCHED_WAKEUP_ARGS_COUNT) {
301 TS_LOGD("Failed to parse SchedWakeupEvent event, no args or args size < 2");
302 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_DATA_INVALID);
303 return false;
304 }
305 std::optional<uint32_t> wakePidValue = base::StrToInt<uint32_t>(args.at("pid"));
306 if (!wakePidValue.has_value()) {
307 TS_LOGD("Failed to convert wake_pid");
308 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_DATA_INVALID);
309 return false;
310 }
311 auto instants = traceDataCache_->GetInstantsData();
312 InternalTid internalTid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, wakePidValue.value_or(0));
313 streamFilters_->cpuFilter_->InsertWakeupEvent(line.ts, internalTid);
314
315 InternalTid wakeupFromPid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, line.pid);
316
317 instants->AppendInstantEventData(line.ts, schedWakeupName_, internalTid, wakeupFromPid);
318 std::optional<uint32_t> targetCpu = base::StrToInt<uint32_t>(args.at("target_cpu"));
319 if (targetCpu.has_value()) {
320 traceDataCache_->GetRawData()->AppendRawData(line.ts, RAW_SCHED_WAKEUP, targetCpu.value(), wakeupFromPid);
321 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKEUP, STAT_EVENT_RECEIVED);
322 }
323 return true;
324 }
325
SchedWakingEvent(const ArgsMap & args,const BytraceLine & line) const326 bool BytraceEventParser::SchedWakingEvent(const ArgsMap &args, const BytraceLine &line) const
327 {
328 if (args.empty() || args.size() < MIN_SCHED_WAKING_ARGS_COUNT) {
329 TS_LOGD("Failed to parse sched_waking event, no args or args size < 4");
330 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_DATA_INVALID);
331 return false;
332 }
333 std::optional<uint32_t> wakePidValue = base::StrToInt<uint32_t>(args.at("pid"));
334 if (!wakePidValue.has_value()) {
335 TS_LOGD("Failed to convert wake_pid");
336 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_DATA_INVALID);
337 return false;
338 }
339 auto instants = traceDataCache_->GetInstantsData();
340 InternalTid internalTid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, wakePidValue.value());
341 DataIndex wakeByPidStrIndex = traceDataCache_->GetDataIndex(line.task);
342 InternalTid internalTidWakeup =
343 streamFilters_->processFilter_->UpdateOrCreateThreadWithNameIndex(line.ts, line.pid, wakeByPidStrIndex);
344 InternalTid wakeupFromPid = streamFilters_->processFilter_->UpdateOrCreateThread(line.ts, line.pid);
345 streamFilters_->cpuFilter_->InsertWakeupEvent(line.ts, internalTid, true);
346 instants->AppendInstantEventData(line.ts, schedWakingName_, internalTid, wakeupFromPid);
347 std::optional<uint32_t> targetCpu = base::StrToInt<uint32_t>(args.at("target_cpu"));
348 if (targetCpu.has_value()) {
349 traceDataCache_->GetRawData()->AppendRawData(line.ts, RAW_SCHED_WAKING, targetCpu.value(), internalTidWakeup);
350 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SCHED_WAKING, STAT_EVENT_RECEIVED);
351 }
352
353 return true;
354 }
355
CpuIdleEvent(const ArgsMap & args,const BytraceLine & line) const356 bool BytraceEventParser::CpuIdleEvent(const ArgsMap &args, const BytraceLine &line) const
357 {
358 if (args.empty() || args.size() < MIN_CPU_IDLE_ARGS_COUNT) {
359 TS_LOGD("Failed to parse cpu_idle event, no args or args size < 2");
360 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
361 return false;
362 }
363 std::optional<uint32_t> eventCpuValue = base::StrToInt<uint32_t>(args.at("cpu_id"));
364 std::optional<int64_t> newStateValue = base::StrToInt<int64_t>(args.at("state"));
365 if (!eventCpuValue.has_value()) {
366 TS_LOGD("Failed to convert event cpu");
367 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
368 return false;
369 }
370 if (!newStateValue.has_value()) {
371 TS_LOGD("Failed to convert state");
372 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_DATA_INVALID);
373 return false;
374 }
375 // Add cpu_idle event to raw_data_table
376 auto cpuidleNameIndex = traceDataCache_->GetDataIndex(line.eventName.c_str());
377 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue.value(),
378 cpuidleNameIndex, line.ts,
379 config_.GetStateValue(newStateValue.value()));
380 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_RECEIVED);
381 return true;
382 }
383
CpuFrequencyEvent(const ArgsMap & args,const BytraceLine & line) const384 bool BytraceEventParser::CpuFrequencyEvent(const ArgsMap &args, const BytraceLine &line) const
385 {
386 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_RECEIVED);
387 if (args.empty() || args.size() < MIN_CPU_FREQUENCY_ARGS_COUNT) {
388 TS_LOGD("Failed to parse cpu_frequency event, no args or args size < 2");
389 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
390 return false;
391 }
392 std::optional<uint32_t> eventCpuValue = base::StrToInt<uint32_t>(args.at("cpu_id"));
393 std::optional<int64_t> newStateValue = base::StrToInt<int64_t>(args.at("state"));
394
395 if (!newStateValue.has_value()) {
396 TS_LOGD("Failed to convert state");
397 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
398 return false;
399 }
400 if (!eventCpuValue.has_value()) {
401 TS_LOGD("Failed to convert event cpu");
402 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY, STAT_EVENT_DATA_INVALID);
403 return false;
404 }
405
406 auto cpuidleNameIndex = traceDataCache_->GetDataIndex(line.eventName.c_str());
407 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue.value(),
408 cpuidleNameIndex, line.ts, newStateValue.value());
409 return true;
410 }
CpuFrequencyLimitsEvent(const ArgsMap & args,const BytraceLine & line) const411 bool BytraceEventParser::CpuFrequencyLimitsEvent(const ArgsMap &args, const BytraceLine &line) const
412 {
413 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_RECEIVED);
414 if (args.empty() || args.size() < MIN_CPU_FREQUENCY_ARGS_COUNT) {
415 TS_LOGD("Failed to parse cpu_frequency event, no args or args size < 2");
416 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_DATA_INVALID);
417 return false;
418 }
419 std::optional<uint32_t> eventCpuValue = base::StrToInt<uint32_t>(args.at("cpu_id"));
420
421 auto minIt = args.find("min");
422 if (minIt == args.end()) {
423 minIt = args.find("min_freq");
424 }
425 auto maxIt = args.find("max");
426 if (maxIt == args.end()) {
427 maxIt = args.find("max_freq");
428 }
429 std::optional<int64_t> minValue = base::StrToInt<int64_t>(minIt->second);
430 std::optional<int64_t> maxValue = base::StrToInt<int64_t>(maxIt->second);
431
432 if (!minValue.has_value()) {
433 TS_LOGD("Failed to get frequency minValue");
434 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_DATA_INVALID);
435 return false;
436 }
437 if (!maxValue.has_value()) {
438 TS_LOGD("Failed to get frequency maxValue");
439 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_DATA_INVALID);
440 return false;
441 }
442 if (!eventCpuValue.has_value()) {
443 TS_LOGD("Failed to get frequency cpu");
444 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_DATA_INVALID);
445 return false;
446 }
447
448 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue.value(),
449 cpuFrequencyLimitMaxNameId, line.ts, maxValue.value());
450 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue.value(),
451 cpuFrequencyLimitMinNameId, line.ts, minValue.value());
452 return true;
453 }
454
WorkqueueExecuteStartEvent(const ArgsMap & args,const BytraceLine & line) const455 bool BytraceEventParser::WorkqueueExecuteStartEvent(const ArgsMap &args, const BytraceLine &line) const
456 {
457 Unused(args);
458 auto splitStr = GetFunctionName(line.argsStr, "function ");
459 auto splitStrIndex = traceDataCache_->GetDataIndex(splitStr);
460 size_t result =
461 streamFilters_->sliceFilter_->BeginSlice(line.task, line.ts, line.pid, 0, workQueueId_, splitStrIndex);
462 traceDataCache_->GetInternalSlicesData()->AppendDistributeInfo();
463 if (result != INVALID_UINT32) {
464 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_START, STAT_EVENT_RECEIVED);
465 return true;
466 } else {
467 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_START, STAT_EVENT_DATA_LOST);
468 return false;
469 }
470 }
471
WorkqueueExecuteEndEvent(const ArgsMap & args,const BytraceLine & line) const472 bool BytraceEventParser::WorkqueueExecuteEndEvent(const ArgsMap &args, const BytraceLine &line) const
473 {
474 Unused(args);
475 if (streamFilters_->sliceFilter_->EndSlice(line.ts, line.pid, 0, workQueueId_)) {
476 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_RECEIVED);
477 return true;
478 } else {
479 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_WORKQUEUE_EXECUTE_END, STAT_EVENT_NOTMATCH);
480 return false;
481 }
482 }
483
ProcessExitEvent(const ArgsMap & args,const BytraceLine & line) const484 bool BytraceEventParser::ProcessExitEvent(const ArgsMap &args, const BytraceLine &line) const
485 {
486 if (args.empty() || args.size() < MIN_PROCESS_EXIT_ARGS_COUNT) {
487 TS_LOGD("Failed to parse process_exit event, no args or args size < 2");
488 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_DATA_INVALID);
489 return false;
490 }
491 auto comm = std::string_view(args.at("comm"));
492 auto pid = base::StrToInt<uint32_t>(args.at("pid"));
493 if (!pid.has_value()) {
494 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_DATA_INVALID);
495 return false;
496 }
497 auto itid = streamFilters_->processFilter_->UpdateOrCreateThreadWithName(line.ts, pid.value(), comm);
498 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_RECEIVED);
499 if (streamFilters_->cpuFilter_->InsertProcessExitEvent(line.ts, line.cpu, itid)) {
500 return true;
501 } else {
502 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_PROCESS_EXIT, STAT_EVENT_NOTMATCH);
503 return false;
504 }
505 }
506
SetRateEvent(const ArgsMap & args,const BytraceLine & line) const507 bool BytraceEventParser::SetRateEvent(const ArgsMap &args, const BytraceLine &line) const
508 {
509 if (args.empty() || args.size() < MIN_CLOCK_SET_RATE_ARGS_COUNT) {
510 TS_LOGD("Failed to parse clock_set_rate event, no args or args size < 3");
511 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_DATA_INVALID);
512 return false;
513 }
514 auto name = std::string_view(args.at("name"));
515 auto state = base::StrToInt<int64_t>(args.at("state"));
516 uint64_t cpu = 0;
517 DataIndex nameIndex = traceDataCache_->GetDataIndex(name);
518 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_RATE, cpu, nameIndex, line.ts,
519 state.value());
520 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_RECEIVED);
521 return true;
522 }
523
ClockEnableEvent(const ArgsMap & args,const BytraceLine & line) const524 bool BytraceEventParser::ClockEnableEvent(const ArgsMap &args, const BytraceLine &line) const
525 {
526 if (args.empty() || args.size() < MIN_CLOCK_ENABLE_ARGS_COUNT) {
527 TS_LOGD("Failed to parse clock_enable event, no args or args size < 3");
528 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_DATA_INVALID);
529 return false;
530 }
531 auto name = std::string_view(args.at("name"));
532 auto state = base::StrToInt<int64_t>(args.at("state"));
533 auto cpuId = base::StrToInt<uint64_t>(args.at("cpu_id"));
534 DataIndex nameIndex = traceDataCache_->GetDataIndex(name);
535 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_ENABLE, cpuId.value(), nameIndex,
536 line.ts, state.value());
537 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_RECEIVED);
538 return true;
539 }
ClockDisableEvent(const ArgsMap & args,const BytraceLine & line) const540 bool BytraceEventParser::ClockDisableEvent(const ArgsMap &args, const BytraceLine &line) const
541 {
542 if (args.empty() || args.size() < MIN_CLOCK_DISABLE_ARGS_COUNT) {
543 TS_LOGD("Failed to parse clock_disable event, no args or args size < 3");
544 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_DATA_INVALID);
545 return false;
546 }
547 auto name = std::string_view(args.at("name"));
548 auto state = base::StrToInt<int64_t>(args.at("state"));
549 auto cpuId = base::StrToInt<uint64_t>(args.at("cpu_id"));
550 DataIndex nameIndex = traceDataCache_->GetDataIndex(name);
551 streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_DISABLE, cpuId.value(), nameIndex,
552 line.ts, state.value());
553 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_RECEIVED);
554 return true;
555 }
556
RegulatorSetVoltageEvent(const ArgsMap & args,const BytraceLine & line) const557 bool BytraceEventParser::RegulatorSetVoltageEvent(const ArgsMap &args, const BytraceLine &line) const
558 {
559 Unused(args);
560 Unused(line);
561 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE, STAT_EVENT_RECEIVED);
562 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE, STAT_EVENT_NOTSUPPORTED);
563 return true;
564 }
RegulatorSetVoltageCompleteEvent(const ArgsMap & args,const BytraceLine & line) const565 bool BytraceEventParser::RegulatorSetVoltageCompleteEvent(const ArgsMap &args, const BytraceLine &line) const
566 {
567 Unused(args);
568 Unused(line);
569 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE, STAT_EVENT_RECEIVED);
570 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE,
571 STAT_EVENT_NOTSUPPORTED);
572 return true;
573 }
RegulatorDisableEvent(const ArgsMap & args,const BytraceLine & line) const574 bool BytraceEventParser::RegulatorDisableEvent(const ArgsMap &args, const BytraceLine &line) const
575 {
576 Unused(args);
577 Unused(line);
578 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE, STAT_EVENT_RECEIVED);
579 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE, STAT_EVENT_NOTSUPPORTED);
580 return true;
581 }
RegulatorDisableCompleteEvent(const ArgsMap & args,const BytraceLine & line) const582 bool BytraceEventParser::RegulatorDisableCompleteEvent(const ArgsMap &args, const BytraceLine &line) const
583 {
584 Unused(args);
585 Unused(line);
586 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE, STAT_EVENT_RECEIVED);
587 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE, STAT_EVENT_NOTSUPPORTED);
588 return true;
589 }
590
IpiEntryEvent(const ArgsMap & args,const BytraceLine & line) const591 bool BytraceEventParser::IpiEntryEvent(const ArgsMap &args, const BytraceLine &line) const
592 {
593 Unused(args);
594 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IPI_ENTRY, STAT_EVENT_RECEIVED);
595 streamFilters_->irqFilter_->IpiHandlerEntry(line.ts, line.cpu, traceDataCache_->GetDataIndex(line.argsStr));
596 return true;
597 }
IpiExitEvent(const ArgsMap & args,const BytraceLine & line) const598 bool BytraceEventParser::IpiExitEvent(const ArgsMap &args, const BytraceLine &line) const
599 {
600 Unused(args);
601 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IPI_EXIT, STAT_EVENT_RECEIVED);
602 streamFilters_->irqFilter_->IpiHandlerExit(line.ts, line.cpu);
603 return true;
604 }
IrqHandlerEntryEvent(const ArgsMap & args,const BytraceLine & line) const605 bool BytraceEventParser::IrqHandlerEntryEvent(const ArgsMap &args, const BytraceLine &line) const
606 {
607 if (args.empty() || args.size() < MIN_IRQ_HANDLER_ENTRY_ARGS_COUNT) {
608 TS_LOGD("Failed to parse irq_handler_entry event, no args or args size < 2");
609 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_ENTRY, STAT_EVENT_DATA_INVALID);
610 return false;
611 }
612 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_ENTRY, STAT_EVENT_RECEIVED);
613 auto name = std::string_view(args.at("name"));
614 streamFilters_->irqFilter_->IrqHandlerEntry(line.ts, line.cpu, traceDataCache_->GetDataIndex(name));
615 return true;
616 }
IrqHandlerExitEvent(const ArgsMap & args,const BytraceLine & line) const617 bool BytraceEventParser::IrqHandlerExitEvent(const ArgsMap &args, const BytraceLine &line) const
618 {
619 if (args.empty() || args.size() < MIN_IRQ_HANDLER_EXIT_ARGS_COUNT) {
620 TS_LOGD("Failed to parse irq_handler_exit event, no args or args size < 2");
621 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_DATA_INVALID);
622 return false;
623 }
624 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_IRQ_HANDLER_EXIT, STAT_EVENT_RECEIVED);
625 uint32_t ret = (args.at("ret") == "handled") ? 1 : 0;
626 auto irq = base::StrToInt<uint32_t>(args.at("irq"));
627 streamFilters_->irqFilter_->IrqHandlerExit(line.ts, line.cpu, irq.value(), ret);
628 return true;
629 }
SoftIrqRaiseEvent(const ArgsMap & args,const BytraceLine & line) const630 bool BytraceEventParser::SoftIrqRaiseEvent(const ArgsMap &args, const BytraceLine &line) const
631 {
632 Unused(args);
633 Unused(line);
634 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_RAISE, STAT_EVENT_RECEIVED);
635 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_RAISE, STAT_EVENT_NOTSUPPORTED);
636 return true;
637 }
SoftIrqEntryEvent(const ArgsMap & args,const BytraceLine & line) const638 bool BytraceEventParser::SoftIrqEntryEvent(const ArgsMap &args, const BytraceLine &line) const
639 {
640 if (args.empty() || args.size() < MIN_SOFTIRQ_ENTRY_ARGS_COUNT) {
641 TS_LOGD("Failed to parse softirq_entry event, no args or args size < 2");
642 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SOFTIRQ_ENTRY, STAT_EVENT_DATA_INVALID);
643 return false;
644 }
645 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_ENTRY, STAT_EVENT_RECEIVED);
646 auto vec = base::StrToInt<uint32_t>(args.at("vec"));
647 streamFilters_->irqFilter_->SoftIrqEntry(line.ts, line.cpu, vec.value());
648 return true;
649 }
SoftIrqExitEvent(const ArgsMap & args,const BytraceLine & line) const650 bool BytraceEventParser::SoftIrqExitEvent(const ArgsMap &args, const BytraceLine &line) const
651 {
652 if (args.empty() || args.size() < MIN_SOFTIRQ_EXIT_ARGS_COUNT) {
653 TS_LOGD("Failed to parse softirq_exit event, no args or args size < 2");
654 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_DATA_INVALID);
655 return false;
656 }
657 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_SOFTIRQ_EXIT, STAT_EVENT_RECEIVED);
658 auto vec = base::StrToInt<uint32_t>(args.at("vec"));
659 streamFilters_->irqFilter_->SoftIrqExit(line.ts, line.cpu, vec.value());
660 return true;
661 }
DmaFenceEvent(const ArgsMap & args,const BytraceLine & line) const662 bool BytraceEventParser::DmaFenceEvent(const ArgsMap &args, const BytraceLine &line) const
663 {
664 if (args.empty() || args.size() < MIN_DMA_FENCE_ARGS_COUNT) {
665 TS_LOGD("Failed to dma fence event,no args or args size <4");
666 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_DMA_FENCE, STAT_EVENT_DATA_INVALID);
667 return false;
668 }
669 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_DMA_FENCE, STAT_EVENT_RECEIVED);
670 auto driverStr = std::string_view(args.at("driver"));
671 auto timelineStr = std::string_view(args.at("timeline"));
672 auto context = base::StrToInt<uint32_t>(args.at("context"));
673 auto seqno = base::StrToInt<uint32_t>(args.at("seqno"));
674 if (timelineStr.empty() || !(context.has_value()) || !(seqno.has_value())) {
675 TS_LOGD("Failed to dma fence event,timelineStr or context or seqno is empty");
676 return false;
677 }
678 DmaFenceRow dmaFenceRow = {line.ts,
679 0,
680 traceDataCache_->GetDataIndex(line.eventName),
681 traceDataCache_->GetDataIndex(driverStr),
682 traceDataCache_->GetDataIndex(timelineStr),
683 context.value(),
684 seqno.value()};
685 streamFilters_->sliceFilter_->DmaFence(dmaFenceRow);
686 return true;
687 }
BinderTransaction(const ArgsMap & args,const BytraceLine & line) const688 bool BytraceEventParser::BinderTransaction(const ArgsMap &args, const BytraceLine &line) const
689 {
690 if (args.empty() || args.size() < MIN_BINDER_TRANSACTION_ARGS_COUNT) {
691 TS_LOGD("Failed to parse binder_transaction event, no args or args size < 7");
692 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION, STAT_EVENT_DATA_INVALID);
693 return false;
694 }
695 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION, STAT_EVENT_RECEIVED);
696 auto transactionId = base::StrToInt<int64_t>(args.at("transaction"));
697 auto destNode = base::StrToInt<uint32_t>(args.at("dest_node"));
698 auto destProc = base::StrToInt<uint32_t>(args.at("dest_proc"));
699 auto destThread = base::StrToInt<uint32_t>(args.at("dest_thread"));
700 auto isReply = base::StrToInt<uint32_t>(args.at("reply"));
701 auto flags = base::StrToInt<uint32_t>(args.at("flags"), base::INTEGER_RADIX_TYPE_HEX);
702 auto codeStr = base::StrToInt<uint32_t>(args.at("code"), base::INTEGER_RADIX_TYPE_HEX);
703 TS_LOGD("ts:%" PRIu64 ", pid:%u, destNode:%u, destTgid:%u, destTid:%u, transactionId:%" PRIu64
704 ", isReply:%u flags:%u, code:%u",
705 line.ts, line.pid, destNode.value(), destProc.value(), destThread.value(), transactionId.value(),
706 isReply.value(), flags.value(), codeStr.value());
707 streamFilters_->binderFilter_->SendTraction(line.ts, line.pid, transactionId.value(), destNode.value(),
708 destProc.value(), destThread.value(), isReply.value(), flags.value(),
709 codeStr.value());
710 if (traceDataCache_->BinderRunnableTraceEnabled() && transactionId.has_value() && flags.has_value() &&
711 !streamFilters_->binderFilter_->IsAsync(flags.value())) {
712 streamFilters_->cpuFilter_->InsertRunnableBinderEvent(transactionId.value(),
713 streamFilters_->processFilter_->GetInternalTid(line.pid));
714 }
715 return true;
716 }
BinderTransactionReceived(const ArgsMap & args,const BytraceLine & line) const717 bool BytraceEventParser::BinderTransactionReceived(const ArgsMap &args, const BytraceLine &line) const
718 {
719 if (args.empty() || args.size() < MIN_BINDER_TRANSACTION_RECEIVED_ARGS_COUNT) {
720 TS_LOGD("Failed to parse binder_transaction_received event, no args or args size < 1");
721 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED, STAT_EVENT_DATA_INVALID);
722 return false;
723 }
724 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED, STAT_EVENT_RECEIVED);
725 auto transactionId = base::StrToInt<int64_t>(args.at("transaction"));
726 streamFilters_->binderFilter_->ReceiveTraction(line.ts, line.pid, transactionId.value());
727 if (traceDataCache_->BinderRunnableTraceEnabled() && transactionId.has_value()) {
728 streamFilters_->cpuFilter_->InsertRunnableBinderRecvEvent(
729 transactionId.value(), streamFilters_->processFilter_->GetInternalTid(line.pid));
730 }
731 TS_LOGD("ts:%" PRIu64 ", pid:%u, transactionId:%" PRIu64 "", line.ts, line.pid, transactionId.value());
732 return true;
733 }
BinderTransactionAllocBufEvent(const ArgsMap & args,const BytraceLine & line) const734 bool BytraceEventParser::BinderTransactionAllocBufEvent(const ArgsMap &args, const BytraceLine &line) const
735 {
736 if (args.empty() || args.size() < MIN_BINDER_TRANSACTION_ALLOC_BUF_ARGS_COUNT) {
737 TS_LOGD("Failed to parse binder_transaction_alloc_buf event, no args or args size < 3");
738 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF, STAT_EVENT_DATA_INVALID);
739 return false;
740 }
741 streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF, STAT_EVENT_RECEIVED);
742 auto dataSize = base::StrToInt<uint64_t>(args.at("data_size"));
743 auto offsetsSize = base::StrToInt<uint64_t>(args.at("offsets_size"));
744 streamFilters_->binderFilter_->TransactionAllocBuf(line.ts, line.pid, dataSize.value(), offsetsSize.value());
745 TS_LOGD("dataSize:%" PRIu64 ", offsetSize:%" PRIu64 "", dataSize.value(), offsetsSize.value());
746 return true;
747 }
ParseDataItem(const BytraceLine & line)748 void BytraceEventParser::ParseDataItem(const BytraceLine &line)
749 {
750 eventList_.emplace_back(std::make_unique<EventInfo>(line.ts, line));
751 size_t maxQueue = 2;
752 if (eventList_.size() < maxBuffSize_ * maxQueue) {
753 return;
754 }
755 auto cmp = [](const std::unique_ptr<EventInfo> &a, const std::unique_ptr<EventInfo> &b) {
756 return a->eventTimestamp < b->eventTimestamp;
757 };
758 std::stable_sort(eventList_.begin(), eventList_.end(), cmp);
759 auto endOfList = eventList_.begin() + maxBuffSize_;
760 for (auto itor = eventList_.begin(); itor != endOfList; itor++) {
761 EventInfo *event = itor->get();
762 BeginFilterEvents(event);
763 itor->reset();
764 }
765 eventList_.erase(eventList_.begin(), endOfList);
766 }
767
GetDataSegArgs(const BytraceLine & bufLine,ArgsMap & args) const768 void BytraceEventParser::GetDataSegArgs(const BytraceLine &bufLine, ArgsMap &args) const
769 {
770 int32_t len = bufLine.argsStr.size();
771 int32_t first = -1;
772 int32_t second = -1;
773 for (int32_t i = 0; i < len; i++) {
774 if (bufLine.argsStr[i] == ' ') {
775 if (first == -1) {
776 continue;
777 }
778 if (second != -1) {
779 args.emplace(bufLine.argsStr.substr(first, second - 1 - first),
780 bufLine.argsStr.substr(second, i - second));
781 second = -1;
782 } else {
783 args.emplace("name", bufLine.argsStr.substr(first, i - first));
784 }
785 first = -1;
786 } else {
787 if (first == -1) {
788 first = i;
789 }
790 if (bufLine.argsStr[i] == '=' && second == -1) {
791 second = i + 1;
792 }
793 }
794 }
795 if (second != -1) {
796 args.emplace(bufLine.argsStr.substr(first, second - 1 - first), bufLine.argsStr.substr(second, len - second));
797 return;
798 }
799 if (first != -1) {
800 args.emplace("name", bufLine.argsStr.substr(first, len - first));
801 }
802 }
803
FilterAllEvents()804 void BytraceEventParser::FilterAllEvents()
805 {
806 auto cmp = [](const std::unique_ptr<EventInfo> &a, const std::unique_ptr<EventInfo> &b) {
807 return a->eventTimestamp < b->eventTimestamp;
808 };
809 std::stable_sort(eventList_.begin(), eventList_.end(), cmp);
810 while (eventList_.size()) {
811 int32_t size = std::min(maxBuffSize_, eventList_.size());
812 auto endOfList = eventList_.begin() + size;
813 for (auto itor = eventList_.begin(); itor != endOfList; itor++) {
814 EventInfo *event = itor->get();
815 BeginFilterEvents(event);
816 itor->reset();
817 }
818 eventList_.erase(eventList_.begin(), endOfList);
819 }
820 eventList_.clear();
821 streamFilters_->cpuFilter_->Finish();
822 traceDataCache_->dataDict_.Finish();
823 traceDataCache_->UpdataZeroThreadInfo();
824 if (traceDataCache_->AppStartTraceEnabled()) {
825 streamFilters_->appStartupFilter_->FilterAllAPPStartupData();
826 }
827 traceDataCache_->GetThreadStateData()->SortAllRowByTs();
828 }
829
BeginFilterEvents(EventInfo * event)830 void BytraceEventParser::BeginFilterEvents(EventInfo *event)
831 {
832 auto it = eventToFunctionMap_.find(event->line.eventName);
833 if (it != eventToFunctionMap_.end()) {
834 uint32_t tgid = event->line.tgid;
835 ArgsMap args;
836 GetDataSegArgs(event->line, args);
837 if (tgid) {
838 streamFilters_->processFilter_->UpdateOrCreateThreadWithPidAndName(event->line.pid, tgid, event->line.task);
839 } else {
840 // When tgid is zero, only use tid create thread
841 streamFilters_->processFilter_->GetOrCreateThreadWithPid(event->line.pid, tgid);
842 }
843 if (it->second(args, event->line)) {
844 traceDataCache_->UpdateTraceTime(event->line.ts);
845 }
846 } else {
847 traceDataCache_->GetStatAndInfo()->IncreaseStat(TRACE_EVENT_OTHER, STAT_EVENT_NOTSUPPORTED);
848 TS_LOGD("UnRecognizable event name:%s", event->line.eventName.c_str());
849 }
850 }
851
Clear()852 void BytraceEventParser::Clear()
853 {
854 const_cast<TraceStreamerFilters *>(streamFilters_)->FilterClear();
855 printEventParser_.Finish();
856 }
857 } // namespace TraceStreamer
858 } // namespace SysTuning
859