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 // Optimizing the trace data structure for the HM kernel compatibility.
253 if (format.fields[index].size == NEW_SCHED_PRIO_SIZE) {
254 schedSwitchMsg->set_prev_prio(
255 FtraceFieldProcessor::HandleIntField<int16_t>(format.fields, index++, data, size));
256 } else {
257 schedSwitchMsg->set_prev_prio(
258 FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
259 }
260 schedSwitchMsg->set_prev_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
261 schedSwitchMsg->set_next_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
262 schedSwitchMsg->set_next_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
263 if (format.fields[index].size == NEW_SCHED_PRIO_SIZE) {
264 schedSwitchMsg->set_next_prio(
265 FtraceFieldProcessor::HandleIntField<int16_t>(format.fields, index++, data, size));
266 } else {
267 schedSwitchMsg->set_next_prio(
268 FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
269 }
270 return true;
271 }
SchedBlockedReason(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)272 bool FtraceEventProcessor::SchedBlockedReason(FtraceEvent &ftraceEvent,
273 uint8_t data[],
274 size_t size,
275 const EventFormat &format)
276 {
277 uint8_t index = 0;
278 auto schedBlockedMsg = ftraceEvent.mutable_sched_blocked_reason_format();
279 schedBlockedMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
280 schedBlockedMsg->set_caller(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
281 schedBlockedMsg->set_io_wait(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
282 if (format.fields.size() == SCHED_BLOCKED_REASON_FIELD_SIZE_EIGHT) {
283 index++; // skip delay field
284 uint64_t offset = FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size);
285 uint64_t siz = FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size);
286 std::string funcName = FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size);
287 std::string modName = FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size);
288 std::ostringstream caller;
289 caller << funcName << "+0x" << std::hex << offset << "/0x" << std::hex << siz << "[" << modName << "]";
290 schedBlockedMsg->set_caller_str(caller.str());
291 }
292 return true;
293 }
SchedWakeup(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)294 bool FtraceEventProcessor::SchedWakeup(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
295 {
296 uint8_t index = 0;
297 auto schedWakeupMsg = ftraceEvent.mutable_sched_wakeup_format();
298 schedWakeupMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
299 schedWakeupMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
300 if (format.fields[index].size == NEW_SCHED_PRIO_SIZE) {
301 schedWakeupMsg->set_prio(FtraceFieldProcessor::HandleIntField<int16_t>(format.fields, index++, data, size));
302 schedWakeupMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
303 } else {
304 schedWakeupMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
305 schedWakeupMsg->set_success(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
306 schedWakeupMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
307 }
308 return true;
309 }
SchedWaking(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)310 bool FtraceEventProcessor::SchedWaking(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
311 {
312 uint8_t index = 0;
313 auto schedWakingMsg = ftraceEvent.mutable_sched_waking_format();
314 schedWakingMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
315 schedWakingMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
316 if (format.fields[index].size == NEW_SCHED_PRIO_SIZE) {
317 schedWakingMsg->set_prio(FtraceFieldProcessor::HandleIntField<int16_t>(format.fields, index++, data, size));
318 schedWakingMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
319 } else {
320 schedWakingMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
321 schedWakingMsg->set_success(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
322 schedWakingMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
323 }
324 return true;
325 }
SchedWakeupNew(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)326 bool FtraceEventProcessor::SchedWakeupNew(FtraceEvent &ftraceEvent,
327 uint8_t data[],
328 size_t size,
329 const EventFormat &format)
330 {
331 uint8_t index = 0;
332 auto wakeupNewMsg = ftraceEvent.mutable_sched_wakeup_new_format();
333 wakeupNewMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
334 wakeupNewMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
335 if (format.fields[index].size == NEW_SCHED_PRIO_SIZE) {
336 wakeupNewMsg->set_prio(FtraceFieldProcessor::HandleIntField<int16_t>(format.fields, index++, data, size));
337 wakeupNewMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
338 } else {
339 wakeupNewMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
340 wakeupNewMsg->set_success(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
341 wakeupNewMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
342 }
343 return true;
344 }
SchedProcessExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)345 bool FtraceEventProcessor::SchedProcessExit(FtraceEvent &ftraceEvent,
346 uint8_t data[],
347 size_t size,
348 const EventFormat &format)
349 {
350 uint8_t index = 0;
351 auto processExitMsg = ftraceEvent.mutable_sched_process_exit_format();
352 processExitMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
353 processExitMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
354 processExitMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
355 return true;
356 }
SchedProcessFree(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)357 bool FtraceEventProcessor::SchedProcessFree(FtraceEvent &ftraceEvent,
358 uint8_t data[],
359 size_t size,
360 const EventFormat &format)
361 {
362 uint8_t index = 0;
363 auto processFreeMsg = ftraceEvent.mutable_sched_process_free_format();
364 processFreeMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
365 processFreeMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
366 processFreeMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
367 return true;
368 }
369
BinderTransaction(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)370 bool FtraceEventProcessor::BinderTransaction(FtraceEvent &ftraceEvent,
371 uint8_t data[],
372 size_t size,
373 const EventFormat &format)
374 {
375 uint8_t index = 0;
376 auto transactionMsg = ftraceEvent.mutable_binder_transaction_format();
377 transactionMsg->set_debug_id(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
378 transactionMsg->set_target_node(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
379 transactionMsg->set_to_proc(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
380 transactionMsg->set_to_thread(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
381 transactionMsg->set_reply(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
382 transactionMsg->set_code(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
383 transactionMsg->set_flags(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
384 return true;
385 }
BinderTransactionReceived(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)386 bool FtraceEventProcessor::BinderTransactionReceived(FtraceEvent &ftraceEvent,
387 uint8_t data[],
388 size_t size,
389 const EventFormat &format)
390 {
391 uint8_t index = 0;
392 auto transactionReceivedMsg = ftraceEvent.mutable_binder_transaction_received_format();
393 transactionReceivedMsg->set_debug_id(
394 FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
395 return true;
396 }
BinderTransactionAllocBuf(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)397 bool FtraceEventProcessor::BinderTransactionAllocBuf(FtraceEvent &ftraceEvent,
398 uint8_t data[],
399 size_t size,
400 const EventFormat &format)
401 {
402 uint8_t index = 0;
403 auto transactionAllocBufMsg = ftraceEvent.mutable_binder_transaction_alloc_buf_format();
404 transactionAllocBufMsg->set_debug_id(
405 FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
406 transactionAllocBufMsg->set_data_size(
407 FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
408 transactionAllocBufMsg->set_offsets_size(
409 FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
410 transactionAllocBufMsg->set_extra_buffers_size(
411 FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
412 return true;
413 }
BinderTransactionAllocLock(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)414 bool FtraceEventProcessor::BinderTransactionAllocLock(FtraceEvent &ftraceEvent,
415 uint8_t data[],
416 size_t size,
417 const EventFormat &format)
418 {
419 uint8_t index = 0;
420 auto transactionLockMsg = ftraceEvent.mutable_binder_lock_format();
421 transactionLockMsg->set_tag(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
422 return true;
423 }
BinderTransactionAllocLocked(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)424 bool FtraceEventProcessor::BinderTransactionAllocLocked(FtraceEvent &ftraceEvent,
425 uint8_t data[],
426 size_t size,
427 const EventFormat &format)
428 {
429 uint8_t index = 0;
430 auto transactionLockedMsg = ftraceEvent.mutable_binder_locked_format();
431 transactionLockedMsg->set_tag(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
432 return true;
433 }
BinderTransactionAllocUnlock(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)434 bool FtraceEventProcessor::BinderTransactionAllocUnlock(FtraceEvent &ftraceEvent,
435 uint8_t data[],
436 size_t size,
437 const EventFormat &format)
438 {
439 uint8_t index = 0;
440 auto transactionUnlockMsg = ftraceEvent.mutable_binder_unlock_format();
441 transactionUnlockMsg->set_tag(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
442 return true;
443 }
444
TaskRename(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)445 bool FtraceEventProcessor::TaskRename(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
446 {
447 uint8_t index = 0;
448 auto taskRenameMsg = ftraceEvent.mutable_task_rename_format();
449 taskRenameMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
450 taskRenameMsg->set_oldcomm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
451 taskRenameMsg->set_newcomm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
452 taskRenameMsg->set_oom_score_adj(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
453 return true;
454 }
TaskNewtask(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)455 bool FtraceEventProcessor::TaskNewtask(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
456 {
457 uint8_t index = 0;
458 auto newTaskMsg = ftraceEvent.mutable_task_newtask_format();
459 newTaskMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
460 newTaskMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
461 newTaskMsg->set_clone_flags(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
462 newTaskMsg->set_oom_score_adj(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
463 return true;
464 }
465
TracingMarkWriteOrPrintFormat(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)466 bool FtraceEventProcessor::TracingMarkWriteOrPrintFormat(FtraceEvent &ftraceEvent,
467 uint8_t data[],
468 size_t size,
469 const EventFormat &format)
470 {
471 uint8_t index = 0;
472 auto printMsg = ftraceEvent.mutable_print_format();
473 if (format.eventId < HM_EVENT_ID_OFFSET) {
474 printMsg->set_ip(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
475 }
476 // size大于20时为适配内核的event，小于则为原始的event
477 if (format.eventSize > 20) {
478 auto pid = FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size);
479 auto name = FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size);
480 auto start = FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size);
481 auto msg = std::string(start == 0 ? "E" : "B") + std::string("|") + std::to_string(pid) + std::string("|") +
482 std::string(start == 0 ? "" : name);
483 printMsg->set_buf(msg);
484 } else {
485 printMsg->set_buf(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
486 }
487 return true;
488 }
489
CpuIdle(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)490 bool FtraceEventProcessor::CpuIdle(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
491 {
492 uint8_t index = 0;
493 auto cpuIdleMsg = ftraceEvent.mutable_cpu_idle_format();
494 cpuIdleMsg->set_state(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
495 cpuIdleMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
496 return true;
497 }
CpuFrequency(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)498 bool FtraceEventProcessor::CpuFrequency(FtraceEvent &ftraceEvent,
499 uint8_t data[],
500 size_t size,
501 const EventFormat &format)
502 {
503 uint8_t index = 0;
504 auto cpuFrequencyMsg = ftraceEvent.mutable_cpu_frequency_format();
505 cpuFrequencyMsg->set_state(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
506 cpuFrequencyMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
507 return true;
508 }
CpuFrequencyLimits(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)509 bool FtraceEventProcessor::CpuFrequencyLimits(FtraceEvent &ftraceEvent,
510 uint8_t data[],
511 size_t size,
512 const EventFormat &format)
513 {
514 uint8_t index = 0;
515 auto frequencyLimitsMsg = ftraceEvent.mutable_cpu_frequency_limits_format();
516 frequencyLimitsMsg->set_min_freq(
517 FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
518 frequencyLimitsMsg->set_max_freq(
519 FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
520 frequencyLimitsMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
521 return true;
522 }
523
SuspendResume(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)524 bool FtraceEventProcessor::SuspendResume(FtraceEvent &ftraceEvent,
525 uint8_t data[],
526 size_t size,
527 const EventFormat &format)
528 {
529 uint8_t index = 0;
530 auto resumeMsg = ftraceEvent.mutable_suspend_resume_format();
531 resumeMsg->set_action(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
532 resumeMsg->set_val(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
533 resumeMsg->set_start(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
534 return true;
535 }
WorkqueueExecuteStart(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)536 bool FtraceEventProcessor::WorkqueueExecuteStart(FtraceEvent &ftraceEvent,
537 uint8_t data[],
538 size_t size,
539 const EventFormat &format)
540 {
541 uint8_t index = 0;
542 auto executeStartMsg = ftraceEvent.mutable_workqueue_execute_start_format();
543 executeStartMsg->set_work(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
544 executeStartMsg->set_function(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
545 return true;
546 }
WorkqueueExecuteEnd(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)547 bool FtraceEventProcessor::WorkqueueExecuteEnd(FtraceEvent &ftraceEvent,
548 uint8_t data[],
549 size_t size,
550 const EventFormat &format)
551 {
552 uint8_t index = 0;
553 auto executeEndMsg = ftraceEvent.mutable_workqueue_execute_end_format();
554 executeEndMsg->set_work(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
555 return true;
556 }
557
IpiEntry(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)558 bool FtraceEventProcessor::IpiEntry(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
559 {
560 uint8_t index = 0;
561 auto ipiEntryMsg = ftraceEvent.mutable_ipi_entry_format();
562 ipiEntryMsg->set_reason(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
563 return true;
564 }
IpiExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)565 bool FtraceEventProcessor::IpiExit(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
566 {
567 uint8_t index = 0;
568 auto ipiExitMsg = ftraceEvent.mutable_ipi_exit_format();
569 ipiExitMsg->set_reason(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
570 return true;
571 }
IrqHandlerEntry(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)572 bool FtraceEventProcessor::IrqHandlerEntry(FtraceEvent &ftraceEvent,
573 uint8_t data[],
574 size_t size,
575 const EventFormat &format)
576 {
577 uint8_t index = 0;
578 auto handlerEntryMsg = ftraceEvent.mutable_irq_handler_entry_format();
579 handlerEntryMsg->set_irq(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
580 handlerEntryMsg->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
581 return true;
582 }
IrqHandlerExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)583 bool FtraceEventProcessor::IrqHandlerExit(FtraceEvent &ftraceEvent,
584 uint8_t data[],
585 size_t size,
586 const EventFormat &format)
587 {
588 uint8_t index = 0;
589 auto handlerExitMsg = ftraceEvent.mutable_irq_handler_exit_format();
590 handlerExitMsg->set_irq(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
591 handlerExitMsg->set_ret(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
592 return true;
593 }
SoftirqRaise(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)594 bool FtraceEventProcessor::SoftirqRaise(FtraceEvent &ftraceEvent,
595 uint8_t data[],
596 size_t size,
597 const EventFormat &format)
598 {
599 uint8_t index = 0;
600 auto softirqRaiseMsg = ftraceEvent.mutable_softirq_raise_format();
601 softirqRaiseMsg->set_vec(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
602 return true;
603 }
SoftirqEntry(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)604 bool FtraceEventProcessor::SoftirqEntry(FtraceEvent &ftraceEvent,
605 uint8_t data[],
606 size_t size,
607 const EventFormat &format)
608 {
609 uint8_t index = 0;
610 auto softirqEntryMsg = ftraceEvent.mutable_softirq_entry_format();
611 softirqEntryMsg->set_vec(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
612 return true;
613 }
SoftirqExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)614 bool FtraceEventProcessor::SoftirqExit(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
615 {
616 uint8_t index = 0;
617 auto softirqExitMsg = ftraceEvent.mutable_softirq_exit_format();
618 softirqExitMsg->set_vec(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
619 return true;
620 }
DmaFenceInit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)621 bool FtraceEventProcessor::DmaFenceInit(FtraceEvent &ftraceEvent,
622 uint8_t data[],
623 size_t size,
624 const EventFormat &format)
625 {
626 uint8_t index = 0;
627 auto dmaFenceInitMsg = ftraceEvent.mutable_dma_fence_init_format();
628 dmaFenceInitMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
629 dmaFenceInitMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
630 dmaFenceInitMsg->set_context(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
631 dmaFenceInitMsg->set_seqno(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
632 return true;
633 }
DmaFenceDestroy(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)634 bool FtraceEventProcessor::DmaFenceDestroy(FtraceEvent &ftraceEvent,
635 uint8_t data[],
636 size_t size,
637 const EventFormat &format)
638 {
639 uint8_t index = 0;
640 auto dmaFenceDestroyMsg = ftraceEvent.mutable_dma_fence_destroy_format();
641 dmaFenceDestroyMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
642 dmaFenceDestroyMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
643 dmaFenceDestroyMsg->set_context(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
644 dmaFenceDestroyMsg->set_seqno(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
645 return true;
646 }
DmaFenceEnable(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)647 bool FtraceEventProcessor::DmaFenceEnable(FtraceEvent &ftraceEvent,
648 uint8_t data[],
649 size_t size,
650 const EventFormat &format)
651 {
652 uint8_t index = 0;
653 auto dmaFenceEnableMsg = ftraceEvent.mutable_dma_fence_enable_signal_format();
654 dmaFenceEnableMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
655 dmaFenceEnableMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
656 dmaFenceEnableMsg->set_context(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
657 dmaFenceEnableMsg->set_seqno(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
658 return true;
659 }
DmaFenceSignaled(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)660 bool FtraceEventProcessor::DmaFenceSignaled(FtraceEvent &ftraceEvent,
661 uint8_t data[],
662 size_t size,
663 const EventFormat &format)
664 {
665 uint8_t index = 0;
666 auto dmaFenceSignaledMsg = ftraceEvent.mutable_dma_fence_signaled_format();
667 dmaFenceSignaledMsg->set_driver(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
668 dmaFenceSignaledMsg->set_timeline(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
669 dmaFenceSignaledMsg->set_context(
670 FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
671 dmaFenceSignaledMsg->set_seqno(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
672 return true;
673 }
ClockSetRate(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)674 bool FtraceEventProcessor::ClockSetRate(FtraceEvent &ftraceEvent,
675 uint8_t data[],
676 size_t size,
677 const EventFormat &format)
678 {
679 uint8_t index = 0;
680 auto clockSetRateMsg = ftraceEvent.mutable_clock_set_rate_format();
681 clockSetRateMsg->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
682 clockSetRateMsg->set_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
683 clockSetRateMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
684 return true;
685 }
ClockEnable(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)686 bool FtraceEventProcessor::ClockEnable(FtraceEvent &ftraceEvent, uint8_t data[], size_t size, const EventFormat &format)
687 {
688 uint8_t index = 0;
689 auto clockEnable = ftraceEvent.mutable_clock_enable_format();
690 clockEnable->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
691 clockEnable->set_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
692 clockEnable->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
693 return true;
694 }
ClockDisable(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)695 bool FtraceEventProcessor::ClockDisable(FtraceEvent &ftraceEvent,
696 uint8_t data[],
697 size_t size,
698 const EventFormat &format)
699 {
700 uint8_t index = 0;
701 auto clockDisable = ftraceEvent.mutable_clock_disable_format();
702 clockDisable->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
703 clockDisable->set_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
704 clockDisable->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
705 return true;
706 }
RegulatorSetVoltage(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)707 bool FtraceEventProcessor::RegulatorSetVoltage(FtraceEvent &ftraceEvent,
708 uint8_t data[],
709 size_t size,
710 const EventFormat &format)
711 {
712 uint8_t index = 0;
713 auto regulatorSetVoltage = ftraceEvent.mutable_regulator_set_voltage_format();
714 regulatorSetVoltage->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
715 regulatorSetVoltage->set_min(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
716 regulatorSetVoltage->set_max(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
717 return true;
718 }
RegulatorSetVoltageComplete(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)719 bool FtraceEventProcessor::RegulatorSetVoltageComplete(FtraceEvent &ftraceEvent,
720 uint8_t data[],
721 size_t size,
722 const EventFormat &format)
723 {
724 uint8_t index = 0;
725 auto regulatorSetVoltage = ftraceEvent.mutable_regulator_set_voltage_complete_format();
726 regulatorSetVoltage->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
727 regulatorSetVoltage->set_val(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
728 return true;
729 }
RegulatorDisable(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)730 bool FtraceEventProcessor::RegulatorDisable(FtraceEvent &ftraceEvent,
731 uint8_t data[],
732 size_t size,
733 const EventFormat &format)
734 {
735 uint8_t index = 0;
736 auto regulatorDisable = ftraceEvent.mutable_regulator_disable_format();
737 regulatorDisable->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
738 return true;
739 }
RegulatorDisableComplete(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)740 bool FtraceEventProcessor::RegulatorDisableComplete(FtraceEvent &ftraceEvent,
741 uint8_t data[],
742 size_t size,
743 const EventFormat &format)
744 {
745 uint8_t index = 0;
746 auto regulatorDisableComplete = ftraceEvent.mutable_regulator_disable_complete_format();
747 regulatorDisableComplete->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
748 return true;
749 }
750 } // namespace TraceStreamer
751 } // namespace SysTuning
752