1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "ftrace_event_processor.h"
16 #include "log.h"
17
18 namespace SysTuning {
19 namespace TraceStreamer {
GetInstance()20 FtraceEventProcessor& FtraceEventProcessor::GetInstance()
21 {
22 static FtraceEventProcessor instance;
23 return instance;
24 }
25
FtraceEventProcessor()26 FtraceEventProcessor::FtraceEventProcessor()
27 {
28 eventNameToFunctions_ = {
29 {config_.eventNameMap_.at(TRACE_EVENT_TASK_RENAME),
30 std::bind(&FtraceEventProcessor::TaskRename, this, std::placeholders::_1, std::placeholders::_2,
31 std::placeholders::_3, std::placeholders::_4)},
32 {config_.eventNameMap_.at(TRACE_EVENT_TASK_NEWTASK),
33 std::bind(&FtraceEventProcessor::TaskNewtask, this, std::placeholders::_1, std::placeholders::_2,
34 std::placeholders::_3, std::placeholders::_4)},
35 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_SWITCH),
36 std::bind(&FtraceEventProcessor::SchedSwitch, this, std::placeholders::_1, std::placeholders::_2,
37 std::placeholders::_3, std::placeholders::_4)},
38 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_BLOCKED_REASON),
39 std::bind(&FtraceEventProcessor::SchedBlockedReason, this, std::placeholders::_1, std::placeholders::_2,
40 std::placeholders::_3, std::placeholders::_4)},
41 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP),
42 std::bind(&FtraceEventProcessor::SchedWakeup, this, std::placeholders::_1, std::placeholders::_2,
43 std::placeholders::_3, std::placeholders::_4)},
44 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKING),
45 std::bind(&FtraceEventProcessor::SchedWaking, this, std::placeholders::_1, std::placeholders::_2,
46 std::placeholders::_3, std::placeholders::_4)},
47 {config_.eventNameMap_.at(TRACE_EVENT_SCHED_WAKEUP_NEW),
48 std::bind(&FtraceEventProcessor::SchedWakeupNew, this, std::placeholders::_1, std::placeholders::_2,
49 std::placeholders::_3, std::placeholders::_4)},
50 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_EXIT),
51 std::bind(&FtraceEventProcessor::SchedProcessExit, this, std::placeholders::_1, std::placeholders::_2,
52 std::placeholders::_3, std::placeholders::_4)},
53 {config_.eventNameMap_.at(TRACE_EVENT_IPI_ENTRY),
54 std::bind(&FtraceEventProcessor::IpiEntry, this, std::placeholders::_1, std::placeholders::_2,
55 std::placeholders::_3, std::placeholders::_4)},
56 {config_.eventNameMap_.at(TRACE_EVENT_IPI_EXIT),
57 std::bind(&FtraceEventProcessor::IpiExit, this, std::placeholders::_1, std::placeholders::_2,
58 std::placeholders::_3, std::placeholders::_4)},
59 {config_.eventNameMap_.at(TRACE_EVENT_PROCESS_FREE),
60 std::bind(&FtraceEventProcessor::SchedProcessFree, this, std::placeholders::_1, std::placeholders::_2,
61 std::placeholders::_3, std::placeholders::_4)},
62 {config_.eventNameMap_.at(TRACE_EVENT_SUSPEND_RESUME),
63 std::bind(&FtraceEventProcessor::SuspendResume, this, std::placeholders::_1, std::placeholders::_2,
64 std::placeholders::_3, std::placeholders::_4)},
65 };
66 InterruptEventInitialization();
67 ClockEventInitialization();
68 CpuEventInitialization();
69 LockEventInitialization();
70 BinderEventInitialization();
71 StackEventsInitialization();
72 VoltageEventInitialization();
73 }
74
InterruptEventInitialization()75 void FtraceEventProcessor::InterruptEventInitialization()
76 {
77 // In order for the constructor to not exceed 50 lines, it can only be placed here
78 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_TRACING_MARK_WRITE),
79 std::bind(&FtraceEventProcessor::TracingMarkWriteOrPrintFormat, this,
80 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
81 std::placeholders::_4));
82
83 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_ENTRY),
84 std::bind(&FtraceEventProcessor::IrqHandlerEntry, this, std::placeholders::_1,
85 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
86
87 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_IRQ_HANDLER_EXIT),
88 std::bind(&FtraceEventProcessor::IrqHandlerExit, this, std::placeholders::_1,
89 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
90 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_RAISE),
91 std::bind(&FtraceEventProcessor::SoftirqRaise, this, std::placeholders::_1,
92 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
93 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_ENTRY),
94 std::bind(&FtraceEventProcessor::SoftirqEntry, this, std::placeholders::_1,
95 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
96
97 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_SOFTIRQ_EXIT),
98 std::bind(&FtraceEventProcessor::SoftirqExit, this, std::placeholders::_1,
99 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
100 }
ClockEventInitialization()101 void FtraceEventProcessor::ClockEventInitialization()
102 {
103 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_SET_RATE),
104 std::bind(&FtraceEventProcessor::ClockSetRate, this, std::placeholders::_1,
105 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
106 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_ENABLE),
107 std::bind(&FtraceEventProcessor::ClockEnable, this, std::placeholders::_1,
108 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
109 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CLOCK_DISABLE),
110 std::bind(&FtraceEventProcessor::ClockDisable, this, std::placeholders::_1,
111 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
112 }
CpuEventInitialization()113 void FtraceEventProcessor::CpuEventInitialization()
114 {
115 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_IDLE),
116 std::bind(&FtraceEventProcessor::CpuIdle, this, std::placeholders::_1,
117 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
118 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY),
119 std::bind(&FtraceEventProcessor::CpuFrequency, this, std::placeholders::_1,
120 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
121 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_CPU_FREQUENCY_LIMITS),
122 std::bind(&FtraceEventProcessor::CpuFrequencyLimits, this, std::placeholders::_1,
123 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
124 }
LockEventInitialization()125 void FtraceEventProcessor::LockEventInitialization()
126 {
127 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_LOCK),
128 std::bind(&FtraceEventProcessor::BinderTransactionAllocLock, this,
129 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
130 std::placeholders::_4));
131
132 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_LOCKED),
133 std::bind(&FtraceEventProcessor::BinderTransactionAllocLocked, this,
134 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
135 std::placeholders::_4));
136
137 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_UNLOCK),
138 std::bind(&FtraceEventProcessor::BinderTransactionAllocUnlock, this,
139 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
140 std::placeholders::_4));
141 }
BinderEventInitialization()142 void FtraceEventProcessor::BinderEventInitialization()
143 {
144 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION),
145 std::bind(&FtraceEventProcessor::BinderTransaction, this, std::placeholders::_1,
146 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
147 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_RECEIVED),
148 std::bind(&FtraceEventProcessor::BinderTransactionReceived, this,
149 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
150 std::placeholders::_4));
151
152 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_BINDER_TRANSACTION_ALLOC_BUF),
153 std::bind(&FtraceEventProcessor::BinderTransactionAllocBuf, this,
154 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
155 std::placeholders::_4));
156 }
StackEventsInitialization()157 void FtraceEventProcessor::StackEventsInitialization()
158 {
159 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_PRINT),
160 std::bind(&FtraceEventProcessor::TracingMarkWriteOrPrintFormat, this,
161 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
162 std::placeholders::_4));
163 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_START),
164 std::bind(&FtraceEventProcessor::WorkqueueExecuteStart, this, std::placeholders::_1,
165 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
166 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_WORKQUEUE_EXECUTE_END),
167 std::bind(&FtraceEventProcessor::WorkqueueExecuteEnd, this, std::placeholders::_1,
168 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
169 }
VoltageEventInitialization()170 void FtraceEventProcessor::VoltageEventInitialization()
171 {
172 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE),
173 std::bind(&FtraceEventProcessor::RegulatorSetVoltage, this, std::placeholders::_1,
174 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
175
176 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_SET_VOLTAGE_COMPLETE),
177 std::bind(&FtraceEventProcessor::RegulatorSetVoltageComplete, this,
178 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
179 std::placeholders::_4));
180 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE),
181 std::bind(&FtraceEventProcessor::RegulatorDisable, this, std::placeholders::_1,
182 std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
183
184 eventNameToFunctions_.emplace(config_.eventNameMap_.at(TRACE_EVENT_REGULATOR_DISABLE_COMPLETE),
185 std::bind(&FtraceEventProcessor::RegulatorDisableComplete, this,
186 std::placeholders::_1, std::placeholders::_2, std::placeholders::_3,
187 std::placeholders::_4));
188 }
189
~FtraceEventProcessor()190 FtraceEventProcessor::~FtraceEventProcessor()
191 {
192 TS_LOGI("FtraceEventProcessor destroy!");
193 }
194
IsSupported(uint32_t eventId) const195 bool FtraceEventProcessor::IsSupported(uint32_t eventId) const
196 {
197 return eventIdToFunctions_.count(eventId);
198 }
199
IsSupported(const std::string & eventName) const200 bool FtraceEventProcessor::IsSupported(const std::string& eventName) const
201 {
202 return eventNameToFunctions_.count(eventName) > 0;
203 }
204
HandleEvent(FtraceEvent & event,uint8_t data[],size_t size,const EventFormat & format) const205 bool FtraceEventProcessor::HandleEvent(FtraceEvent& event, uint8_t data[], size_t size, const EventFormat& format) const
206 {
207 auto iter = eventIdToFunctions_.find(format.eventId);
208 TS_CHECK_TRUE_RET(iter != eventIdToFunctions_.end(), false);
209 iter->second(event, data, size, format);
210 return true;
211 }
212
SetupEvent(const EventFormat & format)213 bool FtraceEventProcessor::SetupEvent(const EventFormat& format)
214 {
215 auto it = eventNameToFunctions_.find(format.eventName);
216 TS_CHECK_TRUE_RET(it != eventNameToFunctions_.end(), false);
217 eventIdToFunctions_[format.eventId] = it->second;
218 eventIdToNames_[format.eventId] = format.eventName;
219 return true;
220 }
GetEventNameById(uint32_t eventId)221 const std::string& FtraceEventProcessor::GetEventNameById(uint32_t eventId)
222 {
223 auto iter = eventIdToNames_.find(eventId);
224 TS_CHECK_TRUE_RET(iter != eventIdToNames_.end(), INVALID_STRING);
225 return iter->second;
226 }
227
SchedSwitch(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)228 bool FtraceEventProcessor::SchedSwitch(FtraceEvent& ftraceEvent, uint8_t data[], size_t size, const EventFormat& format)
229 {
230 uint8_t index = 0;
231 auto schedSwitchMsg = ftraceEvent.mutable_sched_switch_format();
232 schedSwitchMsg->set_prev_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
233 schedSwitchMsg->set_prev_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
234 schedSwitchMsg->set_prev_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
235 schedSwitchMsg->set_prev_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
236 schedSwitchMsg->set_next_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
237 schedSwitchMsg->set_next_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
238 schedSwitchMsg->set_next_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
239 return true;
240 }
SchedBlockedReason(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)241 bool FtraceEventProcessor::SchedBlockedReason(FtraceEvent& ftraceEvent,
242 uint8_t data[],
243 size_t size,
244 const EventFormat& format)
245 {
246 uint8_t index = 0;
247 auto schedBlockedMsg = ftraceEvent.mutable_sched_blocked_reason_format();
248 schedBlockedMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
249 schedBlockedMsg->set_caller(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
250 schedBlockedMsg->set_io_wait(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
251 return true;
252 }
SchedWakeup(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)253 bool FtraceEventProcessor::SchedWakeup(FtraceEvent& ftraceEvent, uint8_t data[], size_t size, const EventFormat& format)
254 {
255 uint8_t index = 0;
256 auto schedWakeupMsg = ftraceEvent.mutable_sched_wakeup_format();
257 schedWakeupMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
258 schedWakeupMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
259 schedWakeupMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
260 schedWakeupMsg->set_success(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
261 schedWakeupMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
262 return true;
263 }
SchedWaking(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)264 bool FtraceEventProcessor::SchedWaking(FtraceEvent& ftraceEvent, uint8_t data[], size_t size, const EventFormat& format)
265 {
266 uint8_t index = 0;
267 auto schedWakingMsg = ftraceEvent.mutable_sched_waking_format();
268 schedWakingMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
269 schedWakingMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
270 schedWakingMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
271 schedWakingMsg->set_success(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
272 schedWakingMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
273 return true;
274 }
SchedWakeupNew(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)275 bool FtraceEventProcessor::SchedWakeupNew(FtraceEvent& ftraceEvent,
276 uint8_t data[],
277 size_t size,
278 const EventFormat& format)
279 {
280 uint8_t index = 0;
281 auto wakeupNewMsg = ftraceEvent.mutable_sched_wakeup_new_format();
282 wakeupNewMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
283 wakeupNewMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
284 wakeupNewMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
285 wakeupNewMsg->set_success(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
286 wakeupNewMsg->set_target_cpu(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
287 return true;
288 }
SchedProcessExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)289 bool FtraceEventProcessor::SchedProcessExit(FtraceEvent& ftraceEvent,
290 uint8_t data[],
291 size_t size,
292 const EventFormat& format)
293 {
294 uint8_t index = 0;
295 auto processExitMsg = ftraceEvent.mutable_sched_process_exit_format();
296 processExitMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
297 processExitMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
298 processExitMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
299 return true;
300 }
SchedProcessFree(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)301 bool FtraceEventProcessor::SchedProcessFree(FtraceEvent& ftraceEvent,
302 uint8_t data[],
303 size_t size,
304 const EventFormat& format)
305 {
306 uint8_t index = 0;
307 auto processFreeMsg = ftraceEvent.mutable_sched_process_free_format();
308 processFreeMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
309 processFreeMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
310 processFreeMsg->set_prio(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
311 return true;
312 }
313
BinderTransaction(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)314 bool FtraceEventProcessor::BinderTransaction(FtraceEvent& ftraceEvent,
315 uint8_t data[],
316 size_t size,
317 const EventFormat& format)
318 {
319 uint8_t index = 0;
320 auto transactionMsg = ftraceEvent.mutable_binder_transaction_format();
321 transactionMsg->set_debug_id(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
322 transactionMsg->set_target_node(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
323 transactionMsg->set_to_proc(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
324 transactionMsg->set_to_thread(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
325 transactionMsg->set_reply(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
326 transactionMsg->set_code(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
327 transactionMsg->set_flags(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
328 return true;
329 }
BinderTransactionReceived(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)330 bool FtraceEventProcessor::BinderTransactionReceived(FtraceEvent& ftraceEvent,
331 uint8_t data[],
332 size_t size,
333 const EventFormat& format)
334 {
335 uint8_t index = 0;
336 auto transactionReceivedMsg = ftraceEvent.mutable_binder_transaction_received_format();
337 transactionReceivedMsg->set_debug_id(
338 FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
339 return true;
340 }
BinderTransactionAllocBuf(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)341 bool FtraceEventProcessor::BinderTransactionAllocBuf(FtraceEvent& ftraceEvent,
342 uint8_t data[],
343 size_t size,
344 const EventFormat& format)
345 {
346 uint8_t index = 0;
347 auto transactionAllocBufMsg = ftraceEvent.mutable_binder_transaction_alloc_buf_format();
348 transactionAllocBufMsg->set_debug_id(
349 FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
350 transactionAllocBufMsg->set_data_size(
351 FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
352 transactionAllocBufMsg->set_offsets_size(
353 FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
354 transactionAllocBufMsg->set_extra_buffers_size(
355 FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
356 return true;
357 }
BinderTransactionAllocLock(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)358 bool FtraceEventProcessor::BinderTransactionAllocLock(FtraceEvent& ftraceEvent,
359 uint8_t data[],
360 size_t size,
361 const EventFormat& format)
362 {
363 uint8_t index = 0;
364 auto transactionLockMsg = ftraceEvent.mutable_binder_lock_format();
365 transactionLockMsg->set_tag(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
366 return true;
367 }
BinderTransactionAllocLocked(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)368 bool FtraceEventProcessor::BinderTransactionAllocLocked(FtraceEvent& ftraceEvent,
369 uint8_t data[],
370 size_t size,
371 const EventFormat& format)
372 {
373 uint8_t index = 0;
374 auto transactionLockedMsg = ftraceEvent.mutable_binder_locked_format();
375 transactionLockedMsg->set_tag(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
376 return true;
377 }
BinderTransactionAllocUnlock(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)378 bool FtraceEventProcessor::BinderTransactionAllocUnlock(FtraceEvent& ftraceEvent,
379 uint8_t data[],
380 size_t size,
381 const EventFormat& format)
382 {
383 uint8_t index = 0;
384 auto transactionUnlockMsg = ftraceEvent.mutable_binder_unlock_format();
385 transactionUnlockMsg->set_tag(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
386 return true;
387 }
388
TaskRename(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)389 bool FtraceEventProcessor::TaskRename(FtraceEvent& ftraceEvent, uint8_t data[], size_t size, const EventFormat& format)
390 {
391 uint8_t index = 0;
392 auto taskRenameMsg = ftraceEvent.mutable_task_rename_format();
393 taskRenameMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
394 taskRenameMsg->set_oldcomm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
395 taskRenameMsg->set_newcomm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
396 taskRenameMsg->set_oom_score_adj(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
397 return true;
398 }
TaskNewtask(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)399 bool FtraceEventProcessor::TaskNewtask(FtraceEvent& ftraceEvent, uint8_t data[], size_t size, const EventFormat& format)
400 {
401 uint8_t index = 0;
402 auto newTaskMsg = ftraceEvent.mutable_task_newtask_format();
403 newTaskMsg->set_pid(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
404 newTaskMsg->set_comm(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
405 newTaskMsg->set_clone_flags(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
406 newTaskMsg->set_oom_score_adj(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
407 return true;
408 }
409
TracingMarkWriteOrPrintFormat(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)410 bool FtraceEventProcessor::TracingMarkWriteOrPrintFormat(FtraceEvent& ftraceEvent,
411 uint8_t data[],
412 size_t size,
413 const EventFormat& format)
414 {
415 uint8_t index = 0;
416 auto printMsg = ftraceEvent.mutable_print_format();
417 if (format.eventId < HM_EVENT_ID_OFFSET) {
418 printMsg->set_ip(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
419 }
420 printMsg->set_buf(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
421 return true;
422 }
423
CpuIdle(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)424 bool FtraceEventProcessor::CpuIdle(FtraceEvent& ftraceEvent, uint8_t data[], size_t size, const EventFormat& format)
425 {
426 uint8_t index = 0;
427 auto cpuIdleMsg = ftraceEvent.mutable_cpu_idle_format();
428 cpuIdleMsg->set_state(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
429 cpuIdleMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
430 return true;
431 }
CpuFrequency(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)432 bool FtraceEventProcessor::CpuFrequency(FtraceEvent& ftraceEvent,
433 uint8_t data[],
434 size_t size,
435 const EventFormat& format)
436 {
437 uint8_t index = 0;
438 auto cpuFrequencyMsg = ftraceEvent.mutable_cpu_frequency_format();
439 cpuFrequencyMsg->set_state(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
440 cpuFrequencyMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
441 return true;
442 }
CpuFrequencyLimits(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)443 bool FtraceEventProcessor::CpuFrequencyLimits(FtraceEvent& ftraceEvent,
444 uint8_t data[],
445 size_t size,
446 const EventFormat& format)
447 {
448 uint8_t index = 0;
449 auto frequencyLimitsMsg = ftraceEvent.mutable_cpu_frequency_limits_format();
450 frequencyLimitsMsg->set_min_freq(
451 FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
452 frequencyLimitsMsg->set_max_freq(
453 FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
454 frequencyLimitsMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
455 return true;
456 }
457
SuspendResume(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)458 bool FtraceEventProcessor::SuspendResume(FtraceEvent& ftraceEvent,
459 uint8_t data[],
460 size_t size,
461 const EventFormat& format)
462 {
463 uint8_t index = 0;
464 auto resumeMsg = ftraceEvent.mutable_suspend_resume_format();
465 resumeMsg->set_action(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
466 resumeMsg->set_val(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
467 resumeMsg->set_start(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
468 return true;
469 }
WorkqueueExecuteStart(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)470 bool FtraceEventProcessor::WorkqueueExecuteStart(FtraceEvent& ftraceEvent,
471 uint8_t data[],
472 size_t size,
473 const EventFormat& format)
474 {
475 uint8_t index = 0;
476 auto executeStartMsg = ftraceEvent.mutable_workqueue_execute_start_format();
477 executeStartMsg->set_work(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
478 executeStartMsg->set_function(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
479 return true;
480 }
WorkqueueExecuteEnd(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)481 bool FtraceEventProcessor::WorkqueueExecuteEnd(FtraceEvent& ftraceEvent,
482 uint8_t data[],
483 size_t size,
484 const EventFormat& format)
485 {
486 uint8_t index = 0;
487 auto executeEndMsg = ftraceEvent.mutable_workqueue_execute_end_format();
488 executeEndMsg->set_work(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
489 return true;
490 }
491
IpiEntry(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)492 bool FtraceEventProcessor::IpiEntry(FtraceEvent& ftraceEvent, uint8_t data[], size_t size, const EventFormat& format)
493 {
494 uint8_t index = 0;
495 auto ipiEntryMsg = ftraceEvent.mutable_ipi_entry_format();
496 ipiEntryMsg->set_reason(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
497 return true;
498 }
IpiExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)499 bool FtraceEventProcessor::IpiExit(FtraceEvent& ftraceEvent, uint8_t data[], size_t size, const EventFormat& format)
500 {
501 uint8_t index = 0;
502 auto ipiExitMsg = ftraceEvent.mutable_ipi_exit_format();
503 ipiExitMsg->set_reason(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
504 return true;
505 }
IrqHandlerEntry(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)506 bool FtraceEventProcessor::IrqHandlerEntry(FtraceEvent& ftraceEvent,
507 uint8_t data[],
508 size_t size,
509 const EventFormat& format)
510 {
511 uint8_t index = 0;
512 auto handlerEntryMsg = ftraceEvent.mutable_irq_handler_entry_format();
513 handlerEntryMsg->set_irq(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
514 handlerEntryMsg->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
515 return true;
516 }
IrqHandlerExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)517 bool FtraceEventProcessor::IrqHandlerExit(FtraceEvent& ftraceEvent,
518 uint8_t data[],
519 size_t size,
520 const EventFormat& format)
521 {
522 uint8_t index = 0;
523 auto handlerExitMsg = ftraceEvent.mutable_irq_handler_exit_format();
524 handlerExitMsg->set_irq(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
525 handlerExitMsg->set_ret(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
526 return true;
527 }
SoftirqRaise(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)528 bool FtraceEventProcessor::SoftirqRaise(FtraceEvent& ftraceEvent,
529 uint8_t data[],
530 size_t size,
531 const EventFormat& format)
532 {
533 uint8_t index = 0;
534 auto softirqRaiseMsg = ftraceEvent.mutable_softirq_raise_format();
535 softirqRaiseMsg->set_vec(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
536 return true;
537 }
SoftirqEntry(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)538 bool FtraceEventProcessor::SoftirqEntry(FtraceEvent& ftraceEvent,
539 uint8_t data[],
540 size_t size,
541 const EventFormat& format)
542 {
543 uint8_t index = 0;
544 auto softirqEntryMsg = ftraceEvent.mutable_softirq_entry_format();
545 softirqEntryMsg->set_vec(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
546 return true;
547 }
SoftirqExit(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)548 bool FtraceEventProcessor::SoftirqExit(FtraceEvent& ftraceEvent, uint8_t data[], size_t size, const EventFormat& format)
549 {
550 uint8_t index = 0;
551 auto softirqExitMsg = ftraceEvent.mutable_softirq_exit_format();
552 softirqExitMsg->set_vec(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
553 return true;
554 }
ClockSetRate(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)555 bool FtraceEventProcessor::ClockSetRate(FtraceEvent& ftraceEvent,
556 uint8_t data[],
557 size_t size,
558 const EventFormat& format)
559 {
560 uint8_t index = 0;
561 auto clockSetRateMsg = ftraceEvent.mutable_clock_set_rate_format();
562 clockSetRateMsg->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
563 clockSetRateMsg->set_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
564 clockSetRateMsg->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
565 return true;
566 }
ClockEnable(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)567 bool FtraceEventProcessor::ClockEnable(FtraceEvent& ftraceEvent, uint8_t data[], size_t size, const EventFormat& format)
568 {
569 uint8_t index = 0;
570 auto clockEnable = ftraceEvent.mutable_clock_enable_format();
571 clockEnable->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
572 clockEnable->set_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
573 clockEnable->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
574 return true;
575 }
ClockDisable(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)576 bool FtraceEventProcessor::ClockDisable(FtraceEvent& ftraceEvent,
577 uint8_t data[],
578 size_t size,
579 const EventFormat& format)
580 {
581 uint8_t index = 0;
582 auto clockDisable = ftraceEvent.mutable_clock_disable_format();
583 clockDisable->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
584 clockDisable->set_state(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
585 clockDisable->set_cpu_id(FtraceFieldProcessor::HandleIntField<uint64_t>(format.fields, index++, data, size));
586 return true;
587 }
RegulatorSetVoltage(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)588 bool FtraceEventProcessor::RegulatorSetVoltage(FtraceEvent& ftraceEvent,
589 uint8_t data[],
590 size_t size,
591 const EventFormat& format)
592 {
593 uint8_t index = 0;
594 auto regulatorSetVoltage = ftraceEvent.mutable_regulator_set_voltage_format();
595 regulatorSetVoltage->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
596 regulatorSetVoltage->set_min(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
597 regulatorSetVoltage->set_max(FtraceFieldProcessor::HandleIntField<int32_t>(format.fields, index++, data, size));
598 return true;
599 }
RegulatorSetVoltageComplete(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)600 bool FtraceEventProcessor::RegulatorSetVoltageComplete(FtraceEvent& ftraceEvent,
601 uint8_t data[],
602 size_t size,
603 const EventFormat& format)
604 {
605 uint8_t index = 0;
606 auto regulatorSetVoltage = ftraceEvent.mutable_regulator_set_voltage_complete_format();
607 regulatorSetVoltage->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
608 regulatorSetVoltage->set_val(FtraceFieldProcessor::HandleIntField<uint32_t>(format.fields, index++, data, size));
609 return true;
610 }
RegulatorDisable(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)611 bool FtraceEventProcessor::RegulatorDisable(FtraceEvent& ftraceEvent,
612 uint8_t data[],
613 size_t size,
614 const EventFormat& format)
615 {
616 uint8_t index = 0;
617 auto regulatorDisable = ftraceEvent.mutable_regulator_disable_format();
618 regulatorDisable->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
619 return true;
620 }
RegulatorDisableComplete(FtraceEvent & ftraceEvent,uint8_t data[],size_t size,const EventFormat & format)621 bool FtraceEventProcessor::RegulatorDisableComplete(FtraceEvent& ftraceEvent,
622 uint8_t data[],
623 size_t size,
624 const EventFormat& format)
625 {
626 uint8_t index = 0;
627 auto regulatorDisableComplete = ftraceEvent.mutable_regulator_disable_complete_format();
628 regulatorDisableComplete->set_name(FtraceFieldProcessor::HandleStrField(format.fields, index++, data, size));
629 return true;
630 }
631 } // namespace TraceStreamer
632 } // namespace SysTuning
633