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 #include "ftrace_event_processor.h"
16 #include "rawtrace_parser/ftrace_field_processor.h"
17 #include <cstdint>
18 #include <string>
19 #include <sstream>
20
21 namespace SysTuning {
22 namespace TraceStreamer {
GetInstance()23 FtraceEventProcessor &FtraceEventProcessor::GetInstance()
24 {
25 static FtraceEventProcessor instance;
26 return instance;
27 }
28
FtraceEventProcessor()29 FtraceEventProcessor::FtraceEventProcessor()
30 {
31 eventNameToFunctions_ = {
32 {config_.eventNameMap_.at(TRACE_EVENT_TASK_RENAME),
33 std::bind(&FtraceEventProcessor::TaskRename, this, std::placeholders::_1, std::placeholders::_2,
34 std::placeholders::_3, std::placeholders::_4)},
35 {config_.eventNameMap_.at(TRACE_EVENT_TASK_NEWTASK),
36 std::bind(&FtraceEventProcessor::TaskNewtask, this, std::placeholders::_1, std::placeholders::_2,
37 std::placeholders::_3, std::placeholders::_4)},
38 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_SWITCH),
39 std::bind(&FtraceEventProcessor::SchedSwitch, this, std::placeholders::_1, std::placeholders::_2,
40 std::placeholders::_3, std::placeholders::_4)},
41 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_BLOCKED_REASON),
42 std::bind(&FtraceEventProcessor::SchedBlockedReason, this, std::placeholders::_1, std::placeholders::_2,
43 std::placeholders::_3, std::placeholders::_4)},
44 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP),
45 std::bind(&FtraceEventProcessor::SchedWakeup, this, std::placeholders::_1, std::placeholders::_2,
46 std::placeholders::_3, std::placeholders::_4)},
47 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKING),
48 std::bind(&FtraceEventProcessor::SchedWaking, this, std::placeholders::_1, std::placeholders::_2,
49 std::placeholders::_3, std::placeholders::_4)},
50 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP_NEW),
51 std::bind(&FtraceEventProcessor::SchedWakeupNew, this, std::placeholders::_1, std::placeholders::_2,
52 std::placeholders::_3, std::placeholders::_4)},
53 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_EXIT),
54 std::bind(&FtraceEventProcessor::SchedProcessExit, this, std::placeholders::_1, std::placeholders::_2,
55 std::placeholders::_3, std::placeholders::_4)},
56 {config_.eventNameMap_.at(TRACE_EVENT_IPI_ENTRY),
57 std::bind(&FtraceEventProcessor::IpiEntry, this, std::placeholders::_1, std::placeholders::_2,
58 std::placeholders::_3, std::placeholders::_4)},
59 {config_.eventNameMap_.at(TRACE_EVENT_IPI_EXIT),
60 std::bind(&FtraceEventProcessor::IpiExit, this, std::placeholders::_1, std::placeholders::_2,
61 std::placeholders::_3, std::placeholders::_4)},
62 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_FREE),
63 std::bind(&FtraceEventProcessor::SchedProcessFree, this, std::placeholders::_1, std::placeholders::_2,
64 std::placeholders::_3, std::placeholders::_4)},
65 {config_.eventNameMap_.at(TRACE_EVENT_SUSPEND_RESUME),
66 std::bind(&FtraceEventProcessor::SuspendResume, this, std::placeholders::_1, std::placeholders::_2,
67 std::placeholders::_3, std::placeholders::_4)},
68 };
69 InterruptEventInitialization();
70 ClockEventInitialization();
71 CpuEventInitialization();
72 LockEventInitialization();
73 BinderEventInitialization();
74 StackEventsInitialization();
75 VoltageEventInitialization();
76 }
77
InterruptEventInitialization()78 void FtraceEventProcessor::InterruptEventInitialization()
79 {
80 // In order for the constructor to not exceed 50 lines, it can only be placed here
81 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_TRACING_MARK_WRITE),
82 std::bind(&FtraceEventProcessor::TracingMarkWriteOrPrintFormat, this,
83 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
84 std::placeholders::_4));
85
86 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_ENTRY),
87 std::bind(&FtraceEventProcessor::IrqHandlerEntry, this, std::placeholders::_1,
88 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
89
90 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_EXIT),
91 std::bind(&FtraceEventProcessor::IrqHandlerExit, this, std::placeholders::_1,
92 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
93 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_RAISE),
94 std::bind(&FtraceEventProcessor::SoftirqRaise, this, std::placeholders::_1,
95 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
96 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_ENTRY),
97 std::bind(&FtraceEventProcessor::SoftirqEntry, this, std::placeholders::_1,
98 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
99
100 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_EXIT),
101 std::bind(&FtraceEventProcessor::SoftirqExit, this, std::placeholders::_1,
102 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
103 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_INIT),
104 std::bind(&FtraceEventProcessor::DmaFenceInit, this, std::placeholders::_1,
105 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
106
107 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_DESTROY),
108 std::bind(&FtraceEventProcessor::DmaFenceDestroy, this, std::placeholders::_1,
109 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
110
111 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_ENABLE),
112 std::bind(&FtraceEventProcessor::DmaFenceEnable, this, std::placeholders::_1,
113 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
114
115 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_DMA_FENCE_SIGNALED),
116 std::bind(&FtraceEventProcessor::DmaFenceSignaled, this, std::placeholders::_1,
117 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
118 }
ClockEventInitialization()119 void FtraceEventProcessor::ClockEventInitialization()
120 {
121 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_SET_RATE),
122 std::bind(&FtraceEventProcessor::ClockSetRate, this, std::placeholders::_1,
123 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
124 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_ENABLE),
125 std::bind(&FtraceEventProcessor::ClockEnable, this, std::placeholders::_1,
126 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
127 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_DISABLE),
128 std::bind(&FtraceEventProcessor::ClockDisable, this, std::placeholders::_1,
129 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
130 }
CpuEventInitialization()131 void FtraceEventProcessor::CpuEventInitialization()
132 {
133 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_IDLE),
134 std::bind(&FtraceEventProcessor::CpuIdle, this, std::placeholders::_1,
135 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
136 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY),
137 std::bind(&FtraceEventProcessor::CpuFrequency, this, std::placeholders::_1,
138 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
139 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY_LIMITS),
140 std::bind(&FtraceEventProcessor::CpuFrequencyLimits, this, std::placeholders::_1,
141 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
142 }
LockEventInitialization()143 void FtraceEventProcessor::LockEventInitialization()
144 {
145 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_LOCK),
146 std::bind(&FtraceEventProcessor::BinderTransactionAllocLock, this,
147 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
148 std::placeholders::_4));
149
150 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_LOCKED),
151 std::bind(&FtraceEventProcessor::BinderTransactionAllocLocked, this,
152 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
153 std::placeholders::_4));
154
155 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_UNLOCK),
156 std::bind(&FtraceEventProcessor::BinderTransactionAllocUnlock, this,
157 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
158 std::placeholders::_4));
159 }
BinderEventInitialization()160 void FtraceEventProcessor::BinderEventInitialization()
161 {
162 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION),
163 std::bind(&FtraceEventProcessor::BinderTransaction, this, std::placeholders::_1,
164 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
165 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED),
166 std::bind(&FtraceEventProcessor::BinderTransactionReceived, this,
167 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
168 std::placeholders::_4));
169
170 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF),
171 std::bind(&FtraceEventProcessor::BinderTransactionAllocBuf, this,
172 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
173 std::placeholders::_4));
174 }
StackEventsInitialization()175 void FtraceEventProcessor::StackEventsInitialization()
176 {
177 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_PRINT),
178 std::bind(&FtraceEventProcessor::TracingMarkWriteOrPrintFormat, this,
179 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
180 std::placeholders::_4));
181 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_START),
182 std::bind(&FtraceEventProcessor::WorkqueueExecuteStart, this, std::placeholders::_1,
183 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
184 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_END),
185 std::bind(&FtraceEventProcessor::WorkqueueExecuteEnd, this, std::placeholders::_1,
186 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
187 }
VoltageEventInitialization()188 void FtraceEventProcessor::VoltageEventInitialization()
189 {
190 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE),
191 std::bind(&FtraceEventProcessor::RegulatorSetVoltage, this, std::placeholders::_1,
192 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
193
194 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE),
195 std::bind(&FtraceEventProcessor::RegulatorSetVoltageComplete, this,
196 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
197 std::placeholders::_4));
198 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE),
199 std::bind(&FtraceEventProcessor::RegulatorDisable, this, std::placeholders::_1,
200 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
201
202 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE),
203 std::bind(&FtraceEventProcessor::RegulatorDisableComplete, this,
204 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
205 std::placeholders::_4));
206 }
207
~FtraceEventProcessor()208 FtraceEventProcessor::~FtraceEventProcessor()
209 {
210 TS_LOGI("FtraceEventProcessor destroy!");
211 }
212
IsSupported(uint32_t eventId) const213 bool FtraceEventProcessor::IsSupported(uint32_t eventId) const
214 {
215 return eventIdToFunctions_.count(eventId);
216 }
217
IsSupported(const std::string & eventName) const218 bool FtraceEventProcessor::IsSupported(const std::string &eventName) const
219 {
220 return eventNameToFunctions_.count(eventName) > 0;
221 }
222
HandleEvent(FtraceEvent & event,uint8_t data[],size_t size,const EventFormat & format) const223 bool FtraceEventProcessor::HandleEvent(FtraceEvent &event, uint8_t data[], size_t size, const EventFormat &format) const
224 {
225 auto iter = eventIdToFunctions_.find(format.eventId);
226 TS_CHECK_TRUE_RET(iter != eventIdToFunctions_.end(), false);
227 iter->second(event, data, size, format);
228 return true;
229 }
230
SetupEvent(const EventFormat & format)231 bool FtraceEventProcessor::SetupEvent(const EventFormat &format)
232 {
233 auto it = eventNameToFunctions_.find(format.eventName);
234 TS_CHECK_TRUE_RET(it != eventNameToFunctions_.end(), false);
235 eventIdToFunctions_[format.eventId] = it->second;
236 eventIdToNames_[format.eventId] = format.eventName;
237 return true;
238 }
GetEventNameById(uint32_t eventId)239 const std::string &FtraceEventProcessor::GetEventNameById(uint32_t eventId)
240 {
241 auto iter = eventIdToNames_.find(eventId);
242 TS_CHECK_TRUE_RET(iter != eventIdToNames_.end(), INVALID_STRING);
243 return iter->second;
244 }
245
SchedSwitch(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)246 bool FtraceEventProcessor::SchedSwitch(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
247 {
248 uint8_t index = 0;
249 auto schedSwitchMsg = ftraceEvent.mutable_sched_switch_format();
250 schedSwitchMsg->set_prev_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
251 schedSwitchMsg->set_prev_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
252 schedSwitchMsg->set_prev_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
253 schedSwitchMsg->set_prev_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
254 schedSwitchMsg->set_next_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
255 schedSwitchMsg->set_next_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
256 schedSwitchMsg->set_next_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
257 return true;
258 }
SchedBlockedReason(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)259 bool FtraceEventProcessor::SchedBlockedReason(FtraceEvent &ftraceEvent,
260 uint8_t data[],
261 size_t size,
262 const EventFormat &format)
263 {
264 uint8_t index = 0;
265 auto schedBlockedMsg = ftraceEvent.mutable_sched_blocked_reason_format();
266 schedBlockedMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
267 schedBlockedMsg->set_caller(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
268 schedBlockedMsg->set_io_wait(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
269 if (format.fields.size() == SCHED_BLOCKED_REASON_FIELD_SIZE_EIGHT) {
270 index++; // skip delay field
271 uint64_t offset = FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size);
272 uint64_t siz = FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size);
273 std::string funcName = FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size);
274 std::string modName = FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size);
275 std::ostringstream caller;
276 caller << funcName << "+0x" << std::hex << offset << "/0x" << std::hex << siz << "[" << modName << "]";
277 schedBlockedMsg->set_caller_str(caller.str());
278 }
279 return true;
280 }
SchedWakeup(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)281 bool FtraceEventProcessor::SchedWakeup(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
282 {
283 uint8_t index = 0;
284 auto schedWakeupMsg = ftraceEvent.mutable_sched_wakeup_format();
285 schedWakeupMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
286 schedWakeupMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
287 schedWakeupMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
288 schedWakeupMsg->set_success(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
289 schedWakeupMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
290 return true;
291 }
SchedWaking(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)292 bool FtraceEventProcessor::SchedWaking(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
293 {
294 uint8_t index = 0;
295 auto schedWakingMsg = ftraceEvent.mutable_sched_waking_format();
296 schedWakingMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
297 schedWakingMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
298 schedWakingMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
299 schedWakingMsg->set_success(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
300 schedWakingMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
301 return true;
302 }
SchedWakeupNew(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)303 bool FtraceEventProcessor::SchedWakeupNew(FtraceEvent &ftraceEvent,
304 uint8_t data[],
305 size_t size,
306 const EventFormat &format)
307 {
308 uint8_t index = 0;
309 auto wakeupNewMsg = ftraceEvent.mutable_sched_wakeup_new_format();
310 wakeupNewMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
311 wakeupNewMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
312 wakeupNewMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
313 wakeupNewMsg->set_success(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
314 wakeupNewMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
315 return true;
316 }
SchedProcessExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)317 bool FtraceEventProcessor::SchedProcessExit(FtraceEvent &ftraceEvent,
318 uint8_t data[],
319 size_t size,
320 const EventFormat &format)
321 {
322 uint8_t index = 0;
323 auto processExitMsg = ftraceEvent.mutable_sched_process_exit_format();
324 processExitMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
325 processExitMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
326 processExitMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
327 return true;
328 }
SchedProcessFree(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)329 bool FtraceEventProcessor::SchedProcessFree(FtraceEvent &ftraceEvent,
330 uint8_t data[],
331 size_t size,
332 const EventFormat &format)
333 {
334 uint8_t index = 0;
335 auto processFreeMsg = ftraceEvent.mutable_sched_process_free_format();
336 processFreeMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
337 processFreeMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
338 processFreeMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
339 return true;
340 }
341
BinderTransaction(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)342 bool FtraceEventProcessor::BinderTransaction(FtraceEvent &ftraceEvent,
343 uint8_t data[],
344 size_t size,
345 const EventFormat &format)
346 {
347 uint8_t index = 0;
348 auto transactionMsg = ftraceEvent.mutable_binder_transaction_format();
349 transactionMsg->set_debug_id(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
350 transactionMsg->set_target_node(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
351 transactionMsg->set_to_proc(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
352 transactionMsg->set_to_thread(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
353 transactionMsg->set_reply(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
354 transactionMsg->set_code(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
355 transactionMsg->set_flags(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
356 return true;
357 }
BinderTransactionReceived(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)358 bool FtraceEventProcessor::BinderTransactionReceived(FtraceEvent &ftraceEvent,
359 uint8_t data[],
360 size_t size,
361 const EventFormat &format)
362 {
363 uint8_t index = 0;
364 auto transactionReceivedMsg = ftraceEvent.mutable_binder_transaction_received_format();
365 transactionReceivedMsg->set_debug_id(
366 FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
367 return true;
368 }
BinderTransactionAllocBuf(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)369 bool FtraceEventProcessor::BinderTransactionAllocBuf(FtraceEvent &ftraceEvent,
370 uint8_t data[],
371 size_t size,
372 const EventFormat &format)
373 {
374 uint8_t index = 0;
375 auto transactionAllocBufMsg = ftraceEvent.mutable_binder_transaction_alloc_buf_format();
376 transactionAllocBufMsg->set_debug_id(
377 FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
378 transactionAllocBufMsg->set_data_size(
379 FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
380 transactionAllocBufMsg->set_offsets_size(
381 FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
382 transactionAllocBufMsg->set_extra_buffers_size(
383 FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
384 return true;
385 }
BinderTransactionAllocLock(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)386 bool FtraceEventProcessor::BinderTransactionAllocLock(FtraceEvent &ftraceEvent,
387 uint8_t data[],
388 size_t size,
389 const EventFormat &format)
390 {
391 uint8_t index = 0;
392 auto transactionLockMsg = ftraceEvent.mutable_binder_lock_format();
393 transactionLockMsg->set_tag(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
394 return true;
395 }
BinderTransactionAllocLocked(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)396 bool FtraceEventProcessor::BinderTransactionAllocLocked(FtraceEvent &ftraceEvent,
397 uint8_t data[],
398 size_t size,
399 const EventFormat &format)
400 {
401 uint8_t index = 0;
402 auto transactionLockedMsg = ftraceEvent.mutable_binder_locked_format();
403 transactionLockedMsg->set_tag(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
404 return true;
405 }
BinderTransactionAllocUnlock(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)406 bool FtraceEventProcessor::BinderTransactionAllocUnlock(FtraceEvent &ftraceEvent,
407 uint8_t data[],
408 size_t size,
409 const EventFormat &format)
410 {
411 uint8_t index = 0;
412 auto transactionUnlockMsg = ftraceEvent.mutable_binder_unlock_format();
413 transactionUnlockMsg->set_tag(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
414 return true;
415 }
416
TaskRename(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)417 bool FtraceEventProcessor::TaskRename(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
418 {
419 uint8_t index = 0;
420 auto taskRenameMsg = ftraceEvent.mutable_task_rename_format();
421 taskRenameMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
422 taskRenameMsg->set_oldcomm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
423 taskRenameMsg->set_newcomm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
424 taskRenameMsg->set_oom_score_adj(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
425 return true;
426 }
TaskNewtask(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)427 bool FtraceEventProcessor::TaskNewtask(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
428 {
429 uint8_t index = 0;
430 auto newTaskMsg = ftraceEvent.mutable_task_newtask_format();
431 newTaskMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
432 newTaskMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
433 newTaskMsg->set_clone_flags(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
434 newTaskMsg->set_oom_score_adj(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
435 return true;
436 }
437
TracingMarkWriteOrPrintFormat(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)438 bool FtraceEventProcessor::TracingMarkWriteOrPrintFormat(FtraceEvent &ftraceEvent,
439 uint8_t data[],
440 size_t size,
441 const EventFormat &format)
442 {
443 uint8_t index = 0;
444 auto printMsg = ftraceEvent.mutable_print_format();
445 if (format.eventId < HM_EVENT_ID_OFFSET) {
446 printMsg->set_ip(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
447 }
448 // size大于20时为适配内核的event，小于则为原始的event
449 if (format.eventSize > 20) {
450 auto pid = FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size);
451 auto name = FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size);
452 auto start = FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size);
453 auto msg = std::string(start == 0 ? "E" : "B") + std::string("|") + std::to_string(pid) + std::string("|") +
454 std::string(start == 0 ? "" : name);
455 printMsg->set_buf(msg);
456 } else {
457 printMsg->set_buf(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
458 }
459 return true;
460 }
461
CpuIdle(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)462 bool FtraceEventProcessor::CpuIdle(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
463 {
464 uint8_t index = 0;
465 auto cpuIdleMsg = ftraceEvent.mutable_cpu_idle_format();
466 cpuIdleMsg->set_state(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
467 cpuIdleMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
468 return true;
469 }
CpuFrequency(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)470 bool FtraceEventProcessor::CpuFrequency(FtraceEvent &ftraceEvent,
471 uint8_t data[],
472 size_t size,
473 const EventFormat &format)
474 {
475 uint8_t index = 0;
476 auto cpuFrequencyMsg = ftraceEvent.mutable_cpu_frequency_format();
477 cpuFrequencyMsg->set_state(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
478 cpuFrequencyMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
479 return true;
480 }
CpuFrequencyLimits(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)481 bool FtraceEventProcessor::CpuFrequencyLimits(FtraceEvent &ftraceEvent,
482 uint8_t data[],
483 size_t size,
484 const EventFormat &format)
485 {
486 uint8_t index = 0;
487 auto frequencyLimitsMsg = ftraceEvent.mutable_cpu_frequency_limits_format();
488 frequencyLimitsMsg->set_min_freq(
489 FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
490 frequencyLimitsMsg->set_max_freq(
491 FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
492 frequencyLimitsMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
493 return true;
494 }
495
SuspendResume(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)496 bool FtraceEventProcessor::SuspendResume(FtraceEvent &ftraceEvent,
497 uint8_t data[],
498 size_t size,
499 const EventFormat &format)
500 {
501 uint8_t index = 0;
502 auto resumeMsg = ftraceEvent.mutable_suspend_resume_format();
503 resumeMsg->set_action(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
504 resumeMsg->set_val(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
505 resumeMsg->set_start(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
506 return true;
507 }
WorkqueueExecuteStart(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)508 bool FtraceEventProcessor::WorkqueueExecuteStart(FtraceEvent &ftraceEvent,
509 uint8_t data[],
510 size_t size,
511 const EventFormat &format)
512 {
513 uint8_t index = 0;
514 auto executeStartMsg = ftraceEvent.mutable_workqueue_execute_start_format();
515 executeStartMsg->set_work(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
516 executeStartMsg->set_function(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
517 return true;
518 }
WorkqueueExecuteEnd(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)519 bool FtraceEventProcessor::WorkqueueExecuteEnd(FtraceEvent &ftraceEvent,
520 uint8_t data[],
521 size_t size,
522 const EventFormat &format)
523 {
524 uint8_t index = 0;
525 auto executeEndMsg = ftraceEvent.mutable_workqueue_execute_end_format();
526 executeEndMsg->set_work(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
527 return true;
528 }
529
IpiEntry(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)530 bool FtraceEventProcessor::IpiEntry(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
531 {
532 uint8_t index = 0;
533 auto ipiEntryMsg = ftraceEvent.mutable_ipi_entry_format();
534 ipiEntryMsg->set_reason(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
535 return true;
536 }
IpiExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)537 bool FtraceEventProcessor::IpiExit(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
538 {
539 uint8_t index = 0;
540 auto ipiExitMsg = ftraceEvent.mutable_ipi_exit_format();
541 ipiExitMsg->set_reason(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
542 return true;
543 }
IrqHandlerEntry(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)544 bool FtraceEventProcessor::IrqHandlerEntry(FtraceEvent &ftraceEvent,
545 uint8_t data[],
546 size_t size,
547 const EventFormat &format)
548 {
549 uint8_t index = 0;
550 auto handlerEntryMsg = ftraceEvent.mutable_irq_handler_entry_format();
551 handlerEntryMsg->set_irq(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
552 handlerEntryMsg->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
553 return true;
554 }
IrqHandlerExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)555 bool FtraceEventProcessor::IrqHandlerExit(FtraceEvent &ftraceEvent,
556 uint8_t data[],
557 size_t size,
558 const EventFormat &format)
559 {
560 uint8_t index = 0;
561 auto handlerExitMsg = ftraceEvent.mutable_irq_handler_exit_format();
562 handlerExitMsg->set_irq(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
563 handlerExitMsg->set_ret(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
564 return true;
565 }
SoftirqRaise(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)566 bool FtraceEventProcessor::SoftirqRaise(FtraceEvent &ftraceEvent,
567 uint8_t data[],
568 size_t size,
569 const EventFormat &format)
570 {
571 uint8_t index = 0;
572 auto softirqRaiseMsg = ftraceEvent.mutable_softirq_raise_format();
573 softirqRaiseMsg->set_vec(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
574 return true;
575 }
SoftirqEntry(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)576 bool FtraceEventProcessor::SoftirqEntry(FtraceEvent &ftraceEvent,
577 uint8_t data[],
578 size_t size,
579 const EventFormat &format)
580 {
581 uint8_t index = 0;
582 auto softirqEntryMsg = ftraceEvent.mutable_softirq_entry_format();
583 softirqEntryMsg->set_vec(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
584 return true;
585 }
SoftirqExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)586 bool FtraceEventProcessor::SoftirqExit(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
587 {
588 uint8_t index = 0;
589 auto softirqExitMsg = ftraceEvent.mutable_softirq_exit_format();
590 softirqExitMsg->set_vec(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
591 return true;
592 }
DmaFenceInit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)593 bool FtraceEventProcessor::DmaFenceInit(FtraceEvent &ftraceEvent,
594 uint8_t data[],
595 size_t size,
596 const EventFormat &format)
597 {
598 uint8_t index = 0;
599 auto dmaFenceInitMsg = ftraceEvent.mutable_dma_fence_init_format();
600 dmaFenceInitMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
601 dmaFenceInitMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
602 dmaFenceInitMsg->set_context(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
603 dmaFenceInitMsg->set_seqno(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
604 return true;
605 }
DmaFenceDestroy(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)606 bool FtraceEventProcessor::DmaFenceDestroy(FtraceEvent &ftraceEvent,
607 uint8_t data[],
608 size_t size,
609 const EventFormat &format)
610 {
611 uint8_t index = 0;
612 auto dmaFenceDestroyMsg = ftraceEvent.mutable_dma_fence_destroy_format();
613 dmaFenceDestroyMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
614 dmaFenceDestroyMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
615 dmaFenceDestroyMsg->set_context(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
616 dmaFenceDestroyMsg->set_seqno(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
617 return true;
618 }
DmaFenceEnable(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)619 bool FtraceEventProcessor::DmaFenceEnable(FtraceEvent &ftraceEvent,
620 uint8_t data[],
621 size_t size,
622 const EventFormat &format)
623 {
624 uint8_t index = 0;
625 auto dmaFenceEnableMsg = ftraceEvent.mutable_dma_fence_enable_signal_format();
626 dmaFenceEnableMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
627 dmaFenceEnableMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
628 dmaFenceEnableMsg->set_context(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
629 dmaFenceEnableMsg->set_seqno(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
630 return true;
631 }
DmaFenceSignaled(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)632 bool FtraceEventProcessor::DmaFenceSignaled(FtraceEvent &ftraceEvent,
633 uint8_t data[],
634 size_t size,
635 const EventFormat &format)
636 {
637 uint8_t index = 0;
638 auto dmaFenceSignaledMsg = ftraceEvent.mutable_dma_fence_signaled_format();
639 dmaFenceSignaledMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
640 dmaFenceSignaledMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
641 dmaFenceSignaledMsg->set_context(
642 FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
643 dmaFenceSignaledMsg->set_seqno(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
644 return true;
645 }
ClockSetRate(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)646 bool FtraceEventProcessor::ClockSetRate(FtraceEvent &ftraceEvent,
647 uint8_t data[],
648 size_t size,
649 const EventFormat &format)
650 {
651 uint8_t index = 0;
652 auto clockSetRateMsg = ftraceEvent.mutable_clock_set_rate_format();
653 clockSetRateMsg->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
654 clockSetRateMsg->set_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
655 clockSetRateMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
656 return true;
657 }
ClockEnable(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)658 bool FtraceEventProcessor::ClockEnable(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
659 {
660 uint8_t index = 0;
661 auto clockEnable = ftraceEvent.mutable_clock_enable_format();
662 clockEnable->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
663 clockEnable->set_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
664 clockEnable->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
665 return true;
666 }
ClockDisable(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)667 bool FtraceEventProcessor::ClockDisable(FtraceEvent &ftraceEvent,
668 uint8_t data[],
669 size_t size,
670 const EventFormat &format)
671 {
672 uint8_t index = 0;
673 auto clockDisable = ftraceEvent.mutable_clock_disable_format();
674 clockDisable->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
675 clockDisable->set_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
676 clockDisable->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
677 return true;
678 }
RegulatorSetVoltage(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)679 bool FtraceEventProcessor::RegulatorSetVoltage(FtraceEvent &ftraceEvent,
680 uint8_t data[],
681 size_t size,
682 const EventFormat &format)
683 {
684 uint8_t index = 0;
685 auto regulatorSetVoltage = ftraceEvent.mutable_regulator_set_voltage_format();
686 regulatorSetVoltage->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
687 regulatorSetVoltage->set_min(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
688 regulatorSetVoltage->set_max(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
689 return true;
690 }
RegulatorSetVoltageComplete(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)691 bool FtraceEventProcessor::RegulatorSetVoltageComplete(FtraceEvent &ftraceEvent,
692 uint8_t data[],
693 size_t size,
694 const EventFormat &format)
695 {
696 uint8_t index = 0;
697 auto regulatorSetVoltage = ftraceEvent.mutable_regulator_set_voltage_complete_format();
698 regulatorSetVoltage->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
699 regulatorSetVoltage->set_val(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
700 return true;
701 }
RegulatorDisable(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)702 bool FtraceEventProcessor::RegulatorDisable(FtraceEvent &ftraceEvent,
703 uint8_t data[],
704 size_t size,
705 const EventFormat &format)
706 {
707 uint8_t index = 0;
708 auto regulatorDisable = ftraceEvent.mutable_regulator_disable_format();
709 regulatorDisable->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
710 return true;
711 }
RegulatorDisableComplete(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)712 bool FtraceEventProcessor::RegulatorDisableComplete(FtraceEvent &ftraceEvent,
713 uint8_t data[],
714 size_t size,
715 const EventFormat &format)
716 {
717 uint8_t index = 0;
718 auto regulatorDisableComplete = ftraceEvent.mutable_regulator_disable_complete_format();
719 regulatorDisableComplete->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
720 return true;
721 }
722 } // namespace TraceStreamer
723 } // namespace SysTuning
724