1 /*
2 * Copyright (c) 2025 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 "trace_state_machine.h"
16
17 #include "hiview_logger.h"
18 #include "unistd.h"
19
20 namespace OHOS::HiviewDFX {
21 namespace {
22 DEFINE_LOG_TAG("TraceStateMachine");
23 const std::vector<std::string> TAG_GROUPS = {"scene_performance"};
24 const std::vector<std::string> TELEMETRY_TAG_GROUPS_DEFAULT = {"telemetry"};
25 }
26
TraceStateMachine()27 TraceStateMachine::TraceStateMachine()
28 {
29 currentState_ = std::make_shared<CloseState>();
30 }
31
OpenDynamicTrace(int32_t appid)32 TraceRet TraceStateMachine::OpenDynamicTrace(int32_t appid)
33 {
34 std::lock_guard<std::mutex> lock(traceMutex_);
35 return currentState_->OpenAppTrace(appid);
36 }
37
OpenTelemetryTrace(const std::string & args)38 TraceRet TraceStateMachine::OpenTelemetryTrace(const std::string &args)
39 {
40 std::lock_guard<std::mutex> lock(traceMutex_);
41 return currentState_->OpenTelemetryTrace(args);
42 }
43
DumpTrace(TraceScenario scenario,int maxDuration,uint64_t happenTime,TraceRetInfo & info)44 TraceRet TraceStateMachine::DumpTrace(TraceScenario scenario, int maxDuration, uint64_t happenTime, TraceRetInfo &info)
45 {
46 std::lock_guard<std::mutex> lock(traceMutex_);
47 auto ret = currentState_->DumpTrace(scenario, maxDuration, happenTime, info);
48 if (ret.GetCodeError() == TraceErrorCode::TRACE_IS_OCCUPIED ||
49 ret.GetCodeError() == TraceErrorCode::WRONG_TRACE_MODE) {
50 RecoverState();
51 }
52 return ret;
53 }
54
DumpTraceWithFilter(const std::vector<int32_t> & pidList,int maxDuration,uint64_t happenTime,TraceRetInfo & info)55 TraceRet TraceStateMachine::DumpTraceWithFilter(const std::vector<int32_t> &pidList, int maxDuration,
56 uint64_t happenTime, TraceRetInfo &info)
57 {
58 std::lock_guard<std::mutex> lock(traceMutex_);
59 return currentState_->DumpTraceWithFilter(pidList, maxDuration, happenTime, info);
60 }
61
OpenTrace(TraceScenario scenario,const std::vector<std::string> & tagGroups)62 TraceRet TraceStateMachine::OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups)
63 {
64 HIVIEW_LOGI("TraceStateMachine OpenTrace scenario:%{public}d", static_cast<int>(scenario));
65 std::lock_guard<std::mutex> lock(traceMutex_);
66 return currentState_->OpenTrace(scenario, tagGroups);
67 }
68
OpenTrace(TraceScenario scenario,const std::string & args)69 TraceRet TraceStateMachine::OpenTrace(TraceScenario scenario, const std::string &args)
70 {
71 std::lock_guard<std::mutex> lock(traceMutex_);
72 HIVIEW_LOGI("TraceStateMachine OpenTrace scenario:%{public}d", static_cast<int>(scenario));
73 return currentState_->OpenTrace(scenario, args);
74 }
75
TraceDropOn(TraceScenario scenario)76 TraceRet TraceStateMachine::TraceDropOn(TraceScenario scenario)
77 {
78 std::lock_guard<std::mutex> lock(traceMutex_);
79 return currentState_->TraceDropOn(scenario);
80 }
81
TraceDropOff(TraceScenario scenario,TraceRetInfo & info)82 TraceRet TraceStateMachine::TraceDropOff(TraceScenario scenario, TraceRetInfo &info)
83 {
84 std::lock_guard<std::mutex> lock(traceMutex_);
85 return currentState_->TraceDropOff(scenario, info);
86 }
87
CloseTrace(TraceScenario scenario)88 TraceRet TraceStateMachine::CloseTrace(TraceScenario scenario)
89 {
90 std::lock_guard<std::mutex> lock(traceMutex_);
91 if (auto ret = currentState_->CloseTrace(scenario); !ret.IsSuccess()) {
92 HIVIEW_LOGW("fail stateError:%{public}d, codeError%{public}d", static_cast<int >(ret.stateError_),
93 ret.codeError_);
94 return ret;
95 }
96 return RecoverState();
97 }
98
InitOrUpdateState()99 TraceRet TraceStateMachine::InitOrUpdateState()
100 {
101 std::lock_guard<std::mutex> lock(traceMutex_);
102 return RecoverState();
103 }
104
TransToDynamicState(int32_t appPid)105 void TraceStateMachine::TransToDynamicState(int32_t appPid)
106 {
107 HIVIEW_LOGI("to app state");
108 currentState_ = std::make_shared<DynamicState>(appPid);
109 }
110
TransToCommonState()111 void TraceStateMachine::TransToCommonState()
112 {
113 HIVIEW_LOGI("to common state");
114 currentState_ = std::make_shared<CommonState>(isCachSwitchOn_, cacheSizeLimit_, cacheSliceSpan_);
115 }
116
TransToCommonDropState()117 void TraceStateMachine::TransToCommonDropState()
118 {
119 HIVIEW_LOGI("to common drop state");
120 currentState_ = std::make_shared<CommonDropState>();
121 }
122
123
TransToTeleMetryState()124 void TraceStateMachine::TransToTeleMetryState()
125 {
126 HIVIEW_LOGI("to telemetry state");
127 currentState_ = std::make_shared<TelemetryState>();
128 }
129
TransToCloseState()130 void TraceStateMachine::TransToCloseState()
131 {
132 HIVIEW_LOGI("to close state");
133 currentState_ = std::make_shared<CloseState>();
134 }
135
TransToCommandState()136 void TraceStateMachine::TransToCommandState()
137 {
138 HIVIEW_LOGI("to command state");
139 SetCommandState(true);
140 currentState_ = std::make_shared<CommandState>();
141 }
142
TransToCommandDropState()143 void TraceStateMachine::TransToCommandDropState()
144 {
145 HIVIEW_LOGI("to command drop state");
146 currentState_ = std::make_shared<CommandDropState>();
147 }
148
InitCommonDropState()149 TraceRet TraceStateMachine::InitCommonDropState()
150 {
151 if (auto ret = Hitrace::OpenTrace(TAG_GROUPS); ret != TraceErrorCode::SUCCESS) {
152 HIVIEW_LOGE("OpenTrace error:%{public}d", ret);
153 return TraceRet(ret);
154 }
155 if (auto retTraceOn = Hitrace::RecordTraceOn(); retTraceOn != TraceErrorCode::SUCCESS) {
156 HIVIEW_LOGE("DumpTraceOn error:%{public}d", retTraceOn);
157 return TraceRet(retTraceOn);
158 }
159 TransToCommonDropState();
160 return {};
161 }
162
InitCommonState()163 TraceRet TraceStateMachine::InitCommonState()
164 {
165 if (auto ret = Hitrace::OpenTrace(TAG_GROUPS); ret != TraceErrorCode::SUCCESS) {
166 HIVIEW_LOGE("OpenTrace error:%{public}d", ret);
167 return TraceRet(ret);
168 }
169 TransToCommonState();
170 return {};
171 }
172
TraceCacheOn()173 TraceRet TraceStateMachine::TraceCacheOn()
174 {
175 std::lock_guard<std::mutex> lock(traceMutex_);
176 isCachSwitchOn_ = true;
177 return currentState_->TraceCacheOn();
178 }
179
TraceCacheOff()180 TraceRet TraceStateMachine::TraceCacheOff()
181 {
182 std::lock_guard<std::mutex> lock(traceMutex_);
183 isCachSwitchOn_ = false;
184 return currentState_->TraceCacheOff();
185 }
186
RecoverState()187 TraceRet TraceStateMachine::RecoverState()
188 {
189 if (Hitrace::GetTraceMode() != Hitrace::TraceMode::CLOSE) {
190 if (auto ret = Hitrace::CloseTrace(); ret != TraceErrorCode::SUCCESS) {
191 HIVIEW_LOGE("Hitrace close error:%{public}d", ret);
192 return TraceRet(ret);
193 }
194 }
195
196 // All switch is closed
197 if (traceSwitchState_ == 0) {
198 HIVIEW_LOGI("commercial version and all switch is closed, trans to CloseState");
199 TransToCloseState();
200 return {};
201 }
202
203 // If trace recording switch is open
204 if ((traceSwitchState_ & 1) == 1) {
205 return InitCommonDropState();
206 }
207
208 // trace froze or UCollection switch is open or isBetaVersion
209 return InitCommonState();
210 }
211
RegisterTelemetryCallback(std::function<void ()> func)212 bool TraceStateMachine::RegisterTelemetryCallback(std::function<void()> func)
213 {
214 std::lock_guard<std::mutex> lock(traceMutex_);
215 return currentState_->RegisterTelemetryCallback(std::move(func));
216 }
217
CloseTrace(TraceScenario scenario)218 TraceRet TraceBaseState::CloseTrace(TraceScenario scenario)
219 {
220 if (TraceErrorCode ret = Hitrace::CloseTrace(); ret != TraceErrorCode::SUCCESS) {
221 HIVIEW_LOGE(":%{public}s, CloseTrace error:%{public}d", GetTag().c_str(), ret);
222 return TraceRet(ret);
223 }
224 return {};
225 }
226
OpenTrace(TraceScenario scenario,const std::vector<std::string> & tagGroups)227 TraceRet TraceBaseState::OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups)
228 {
229 if (auto ret = Hitrace::OpenTrace(tagGroups); ret != TraceErrorCode::SUCCESS) {
230 HIVIEW_LOGE(":%{public}s, scenario:%{public}d error:%{public}d", GetTag().c_str(), static_cast<int>(scenario),
231 ret);
232 return TraceRet(ret);
233 }
234 HIVIEW_LOGI(":%{public}s, OpenTrace success scenario:%{public}d", GetTag().c_str(), static_cast<int>(scenario));
235 switch (scenario) {
236 case TraceScenario::TRACE_COMMAND:
237 TraceStateMachine::GetInstance().TransToCommandState();
238 break;
239 case TraceScenario::TRACE_COMMON:
240 TraceStateMachine::GetInstance().TransToCommonState();
241 break;
242 default:
243 break;
244 }
245 return {};
246 }
247
OpenTrace(TraceScenario scenario,const std::string & args)248 TraceRet TraceBaseState::OpenTrace(TraceScenario scenario, const std::string &args)
249 {
250 if (TraceErrorCode ret = Hitrace::OpenTrace(args); ret != TraceErrorCode::SUCCESS) {
251 HIVIEW_LOGE(":%{public}s, scenario:%{public}d error:%{public}d", GetTag().c_str(), static_cast<int>(scenario),
252 ret);
253 return TraceRet(ret);
254 }
255 HIVIEW_LOGI(":%{public}s,OpenTrace success with scenario:%{public}d", GetTag().c_str(), static_cast<int>(scenario));
256 switch (scenario) {
257 case TraceScenario::TRACE_COMMAND:
258 TraceStateMachine::GetInstance().TransToCommandState();
259 break;
260 case TraceScenario::TRACE_COMMON:
261 TraceStateMachine::GetInstance().TransToCommonState();
262 break;
263 default:
264 break;
265 }
266 return {};
267 }
268
TraceCacheOn()269 TraceRet TraceBaseState::TraceCacheOn()
270 {
271 HIVIEW_LOGW(":%{public}s, invoke state fail", GetTag().c_str());
272 return TraceRet(TraceStateCode::FAIL);
273 }
274
TraceCacheOff()275 TraceRet TraceBaseState::TraceCacheOff()
276 {
277 HIVIEW_LOGW(":%{public}s, invoke state fail", GetTag().c_str());
278 return TraceRet(TraceStateCode::FAIL);
279 }
280
SetCacheParams(int32_t totalFileSize,int32_t sliceMaxDuration)281 TraceRet TraceBaseState::SetCacheParams(int32_t totalFileSize, int32_t sliceMaxDuration)
282 {
283 return TraceRet(TraceStateCode::FAIL);
284 }
285
OpenTelemetryTrace(const std::string & args)286 TraceRet TraceBaseState::OpenTelemetryTrace(const std::string &args)
287 {
288 HIVIEW_LOGW(":%{public}s, invoke state deny", GetTag().c_str());
289 return TraceRet(TraceStateCode::DENY);
290 }
291
OpenAppTrace(int32_t appPid)292 TraceRet TraceBaseState::OpenAppTrace(int32_t appPid)
293 {
294 HIVIEW_LOGW(":%{public}s, invoke state deny", GetTag().c_str());
295 return TraceRet(TraceStateCode::DENY);
296 }
297
DumpTrace(TraceScenario scenario,int maxDuration,uint64_t happenTime,TraceRetInfo & info)298 TraceRet TraceBaseState::DumpTrace(TraceScenario scenario, int maxDuration, uint64_t happenTime, TraceRetInfo &info)
299 {
300 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is fail", GetTag().c_str(), static_cast<int>(scenario));
301 return TraceRet(TraceStateCode::FAIL);
302 }
303
TraceDropOn(TraceScenario scenario)304 TraceRet TraceBaseState::TraceDropOn(TraceScenario scenario)
305 {
306 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is fail", GetTag().c_str(), static_cast<int>(scenario));
307 return TraceRet(TraceStateCode::FAIL);
308 }
309
TraceDropOff(TraceScenario scenario,TraceRetInfo & info)310 TraceRet TraceBaseState::TraceDropOff(TraceScenario scenario, TraceRetInfo &info)
311 {
312 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is fail", GetTag().c_str(), static_cast<int>(scenario));
313 return TraceRet(TraceStateCode::FAIL);
314 }
315
DumpTraceWithFilter(const std::vector<int32_t> & pidList,int maxDuration,uint64_t happenTime,TraceRetInfo & info)316 TraceRet TraceBaseState::DumpTraceWithFilter(const std::vector<int32_t> &pidList, int maxDuration, uint64_t happenTime,
317 TraceRetInfo &info)
318 {
319 HIVIEW_LOGW("%{public}s is fail", GetTag().c_str());
320 return TraceRet(TraceStateCode::FAIL);
321 }
322
OpenTrace(TraceScenario scenario,const std::vector<std::string> & tagGroups)323 TraceRet CommandState::OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups)
324 {
325 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is deny", GetTag().c_str(), static_cast<int>(scenario));
326 return TraceRet(TraceStateCode::DENY);
327 }
328
OpenTrace(TraceScenario scenario,const std::string & args)329 TraceRet CommandState::OpenTrace(TraceScenario scenario, const std::string &args)
330 {
331 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is deny", GetTag().c_str(), static_cast<int>(scenario));
332 return TraceRet(TraceStateCode::DENY);
333 }
334
DumpTrace(TraceScenario scenario,int maxDuration,uint64_t happenTime,TraceRetInfo & info)335 TraceRet CommandState::DumpTrace(TraceScenario scenario, int maxDuration, uint64_t happenTime, TraceRetInfo &info)
336 {
337 if (scenario != TraceScenario::TRACE_COMMAND) {
338 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is fail", GetTag().c_str(), static_cast<int>(scenario));
339 return TraceRet(TraceStateCode::FAIL);
340 }
341 info = Hitrace::DumpTrace(maxDuration, happenTime);
342 HIVIEW_LOGI(":%{public}s, DumpTrace result:%{public}d", GetTag().c_str(), info.errorCode);
343 return TraceRet(info.errorCode);
344 }
345
TraceDropOn(TraceScenario scenario)346 TraceRet CommandState::TraceDropOn(TraceScenario scenario)
347 {
348 if (scenario != TraceScenario::TRACE_COMMAND) {
349 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is deny", GetTag().c_str(), static_cast<int>(scenario));
350 return TraceRet(TraceStateCode::FAIL);
351 }
352 if (TraceErrorCode ret = Hitrace::RecordTraceOn(); ret != TraceErrorCode::SUCCESS) {
353 HIVIEW_LOGE(":%{public}s, TraceDropOn error:%{public}d", GetTag().c_str(), ret);
354 return TraceRet(ret);
355 }
356 TraceStateMachine::GetInstance().TransToCommandDropState();
357 return {};
358 }
359
CloseTrace(TraceScenario scenario)360 TraceRet CommandState::CloseTrace(TraceScenario scenario)
361 {
362 if (scenario != TraceScenario::TRACE_COMMAND) {
363 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is deny", GetTag().c_str(), static_cast<int>(scenario));
364 return TraceRet(TraceStateCode::FAIL);
365 }
366 auto ret = TraceBaseState::CloseTrace(scenario);
367 if (ret.IsSuccess()) {
368 TraceStateMachine::GetInstance().SetCommandState(false);
369 }
370 return ret;
371 }
372
OpenTrace(TraceScenario scenario,const std::vector<std::string> & tagGroups)373 TraceRet CommandDropState::OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups)
374 {
375 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is deny", GetTag().c_str(), static_cast<int>(scenario));
376 return TraceRet(TraceStateCode::DENY);
377 }
378
OpenTrace(TraceScenario scenario,const std::string & args)379 TraceRet CommandDropState::OpenTrace(TraceScenario scenario, const std::string &args)
380 {
381 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is deny", GetTag().c_str(), static_cast<int>(scenario));
382 return TraceRet(TraceStateCode::DENY);
383 }
384
TraceDropOff(TraceScenario scenario,TraceRetInfo & info)385 TraceRet CommandDropState::TraceDropOff(TraceScenario scenario, TraceRetInfo &info)
386 {
387 if (scenario != TraceScenario::TRACE_COMMAND) {
388 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is fail", GetTag().c_str(), static_cast<int>(scenario));
389 return TraceRet(TraceStateCode::FAIL);
390 }
391 if (info = Hitrace::RecordTraceOff(); info.errorCode != TraceErrorCode::SUCCESS) {
392 HIVIEW_LOGE(":%{public}s, TraceDropOff error:%{public}d", GetTag().c_str(), info.errorCode);
393 return TraceRet(info.errorCode);
394 }
395 TraceStateMachine::GetInstance().TransToCommandState();
396 return {};
397 }
398
CloseTrace(TraceScenario scenario)399 TraceRet CommandDropState::CloseTrace(TraceScenario scenario)
400 {
401 if (scenario == TraceScenario::TRACE_COMMAND) {
402 return TraceBaseState::CloseTrace(TraceScenario::TRACE_COMMAND);
403 }
404 HIVIEW_LOGW(":%{public}s, invoke state fail", GetTag().c_str());
405 return TraceRet(TraceStateCode::FAIL);
406 }
407
CommonState(bool isCachOn,int32_t totalFileSize,int32_t sliceMaxDuration)408 CommonState::CommonState(bool isCachOn, int32_t totalFileSize, int32_t sliceMaxDuration)
409 : totalFileSize_(totalFileSize), sliceMaxDuration_(sliceMaxDuration)
410 {
411 if (isCachOn) {
412 Hitrace::CacheTraceOn(totalFileSize_, sliceMaxDuration_);
413 }
414 }
415
OpenTrace(TraceScenario scenario,const std::vector<std::string> & tagGroups)416 TraceRet CommonState::OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups)
417 {
418 if (scenario != TraceScenario::TRACE_COMMAND) {
419 HIVIEW_LOGW(":%{public}s, invoke state deny", GetTag().c_str());
420 return TraceRet(TraceStateCode::DENY);
421 }
422
423 // If is command open, first close common state trace
424 if (auto closeRet = Hitrace::CloseTrace(); closeRet != TraceErrorCode::SUCCESS) {
425 HIVIEW_LOGE(":%{public}s, CloseTrace error:%{public}d", GetTag().c_str(), closeRet);
426 return TraceRet(closeRet);
427 }
428
429 // Second open command state trace
430 return TraceBaseState::OpenTrace(TraceScenario::TRACE_COMMAND, tagGroups);
431 }
432
OpenTrace(TraceScenario scenario,const std::string & args)433 TraceRet CommonState::OpenTrace(TraceScenario scenario, const std::string &args)
434 {
435 if (scenario != TraceScenario::TRACE_COMMAND) {
436 HIVIEW_LOGW(":%{public}s, invoke state deny", GetTag().c_str());
437 return TraceRet(TraceStateCode::DENY);
438 }
439
440 // Is command open, first close common state trace
441 if (auto closeRet = Hitrace::CloseTrace(); closeRet != TraceErrorCode::SUCCESS) {
442 HIVIEW_LOGE(":%{public}s, CloseTrace error:%{public}d", GetTag().c_str(), closeRet);
443 return TraceRet(closeRet);
444 }
445
446 // Second open command state trace
447 return TraceBaseState::OpenTrace(TraceScenario::TRACE_COMMAND, args);
448 }
449
DumpTrace(TraceScenario scenario,int maxDuration,uint64_t happenTime,TraceRetInfo & info)450 TraceRet CommonState::DumpTrace(TraceScenario scenario, int maxDuration, uint64_t happenTime, TraceRetInfo &info)
451 {
452 if (scenario == TraceScenario::TRACE_COMMON || scenario == TraceScenario::TRACE_COMMAND) {
453 HIVIEW_LOGI(":%{public}s, DumpTrace result:%{public}d", GetTag().c_str(), info.errorCode);
454 info = Hitrace::DumpTrace(maxDuration, happenTime);
455 return TraceRet(info.errorCode);
456 }
457 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is fail", GetTag().c_str(), static_cast<int>(scenario));
458 return TraceRet(TraceStateCode::FAIL);
459 }
460
TraceDropOn(TraceScenario scenario)461 TraceRet CommonState::TraceDropOn(TraceScenario scenario)
462 {
463 if (scenario != TraceScenario::TRACE_COMMON) {
464 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is fail", GetTag().c_str(), static_cast<int>(scenario));
465 return TraceRet(TraceStateCode::FAIL);
466 }
467 if (auto ret = Hitrace::RecordTraceOn(); ret != TraceErrorCode::SUCCESS) {
468 HIVIEW_LOGE(":%{public}s, TraceDropOn error:%{public}d", GetTag().c_str(), ret);
469 return TraceRet(ret);
470 }
471 TraceStateMachine::GetInstance().TransToCommonDropState();
472 return {};
473 }
474
CloseTrace(TraceScenario scenario)475 TraceRet CommonState::CloseTrace(TraceScenario scenario)
476 {
477 if (scenario == TraceScenario::TRACE_COMMON) {
478 return TraceBaseState::CloseTrace(scenario);
479 }
480
481 // beta version can close trace by trace command
482 if (scenario == TraceScenario::TRACE_COMMAND && !TraceStateMachine::GetInstance().GetCommandState()) {
483 // Prevent traceStateMachine recovery to beta common state after close
484 TraceStateMachine::GetInstance().CloseVersionBeta();
485 return TraceBaseState::CloseTrace(scenario);
486 }
487 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is fail", GetTag().c_str(), static_cast<int>(scenario));
488 return TraceRet(TraceStateCode::FAIL);
489 }
490
TraceCacheOn()491 TraceRet CommonState::TraceCacheOn()
492 {
493 return TraceRet(Hitrace::CacheTraceOn(totalFileSize_, sliceMaxDuration_));
494 }
495
TraceCacheOff()496 TraceRet CommonState::TraceCacheOff()
497 {
498 return TraceRet(Hitrace::CacheTraceOff());
499 }
500
SetCacheParams(int32_t totalFileSize,int32_t sliceMaxDuration)501 TraceRet CommonState::SetCacheParams(int32_t totalFileSize, int32_t sliceMaxDuration)
502 {
503 totalFileSize_ = totalFileSize;
504 sliceMaxDuration_ = sliceMaxDuration;
505 return {};
506 }
507
OpenTrace(TraceScenario scenario,const std::vector<std::string> & tagGroups)508 TraceRet CommonDropState::OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups)
509 {
510 if (scenario != TraceScenario::TRACE_COMMAND) {
511 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is deny", GetTag().c_str(), static_cast<int>(scenario));
512 return TraceRet(TraceStateCode::DENY);
513 }
514 if (auto dropRet = Hitrace::RecordTraceOff(); dropRet.errorCode != TraceErrorCode::SUCCESS) {
515 HIVIEW_LOGE(":%{public}s, DumpTraceOff error:%{public}d", GetTag().c_str(), dropRet.errorCode);
516 return TraceRet(dropRet.errorCode);
517 }
518 if (auto closeRet = Hitrace::CloseTrace(); closeRet != TraceErrorCode::SUCCESS) {
519 HIVIEW_LOGE(":%{public}s, CloseTrace error:%{public}d", GetTag().c_str(), closeRet);
520 TraceStateMachine::GetInstance().TransToCommonState();
521 return TraceRet(closeRet);
522 }
523 return TraceBaseState::OpenTrace(TraceScenario::TRACE_COMMAND, tagGroups);
524 }
525
OpenTrace(TraceScenario scenario,const std::string & args)526 TraceRet CommonDropState::OpenTrace(TraceScenario scenario, const std::string &args)
527 {
528 if (scenario != TraceScenario::TRACE_COMMAND) {
529 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is deny", GetTag().c_str(), static_cast<int>(scenario));
530 return TraceRet(TraceStateCode::DENY);
531 }
532 if (auto dropRet = Hitrace::RecordTraceOff(); dropRet.errorCode != TraceErrorCode::SUCCESS) {
533 HIVIEW_LOGE(":%{public}s, DumpTraceOff error:%{public}d", GetTag().c_str(), dropRet.errorCode);
534 return TraceRet(dropRet.errorCode);
535 }
536 if (auto closeRet = Hitrace::CloseTrace(); closeRet != TraceErrorCode::SUCCESS) {
537 HIVIEW_LOGE(":%{public}s, CloseTrace error:%{public}d", GetTag().c_str(), closeRet);
538 TraceStateMachine::GetInstance().TransToCommonState();
539 return TraceRet(closeRet);
540 }
541 return TraceBaseState::OpenTrace(TraceScenario::TRACE_COMMAND, args);
542 }
543
TraceDropOff(TraceScenario scenario,TraceRetInfo & info)544 TraceRet CommonDropState::TraceDropOff(TraceScenario scenario, TraceRetInfo &info)
545 {
546 if (scenario != TraceScenario::TRACE_COMMON) {
547 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is fail", GetTag().c_str(), static_cast<int>(scenario));
548 return TraceRet(TraceStateCode::FAIL);
549 }
550 if (info = Hitrace::RecordTraceOff(); info.errorCode != TraceErrorCode::SUCCESS) {
551 HIVIEW_LOGE(":%{public}s, TraceDropOff error:%{public}d", GetTag().c_str(), info.errorCode);
552 return TraceRet(info.errorCode);
553 }
554 TraceStateMachine::GetInstance().TransToCommonState();
555 return {};
556 }
557
CloseTrace(TraceScenario scenario)558 TraceRet CommonDropState::CloseTrace(TraceScenario scenario)
559 {
560 return TraceRet(TraceStateCode::FAIL);
561 }
562
DumpTrace(TraceScenario scenario,int maxDuration,uint64_t happenTime,TraceRetInfo & info)563 TraceRet DynamicState::DumpTrace(TraceScenario scenario, int maxDuration, uint64_t happenTime, TraceRetInfo &info)
564 {
565 if (scenario != TraceScenario::TRACE_DYNAMIC) {
566 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is fail", GetTag().c_str(), static_cast<int>(scenario));
567 return TraceRet(TraceStateCode::FAIL);
568 }
569 info = Hitrace::DumpTrace(maxDuration, happenTime);
570 HIVIEW_LOGI(":%{public}s, DumpTrace result:%{public}d", GetTag().c_str(), info.errorCode);
571 return TraceRet(info.errorCode);
572 }
573
CloseTrace(TraceScenario scenario)574 TraceRet DynamicState::CloseTrace(TraceScenario scenario)
575 {
576 if (scenario != TraceScenario::TRACE_DYNAMIC) {
577 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is fail", GetTag().c_str(), static_cast<int>(scenario));
578 return TraceRet(TraceStateCode::FAIL);
579 }
580 return TraceBaseState::CloseTrace(scenario);
581 }
582
OpenTrace(TraceScenario scenario,const std::vector<std::string> & tagGroups)583 TraceRet TelemetryState::OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups)
584 {
585 if (auto closeRet = Hitrace::CloseTrace(); closeRet != TraceErrorCode::SUCCESS) {
586 HIVIEW_LOGE(":%{public}s, CloseTrace result:%{public}d", GetTag().c_str(), closeRet);
587 return TraceRet(closeRet);
588 }
589 return TraceBaseState::OpenTrace(scenario, tagGroups);
590 }
591
OpenTrace(TraceScenario scenario,const std::string & args)592 TraceRet TelemetryState::OpenTrace(TraceScenario scenario, const std::string &args)
593 {
594 if (auto closeRet = Hitrace::CloseTrace(); closeRet != TraceErrorCode::SUCCESS) {
595 HIVIEW_LOGE(":%{public}s, CloseTrace result:%{public}d", GetTag().c_str(), closeRet);
596 return TraceRet(closeRet);
597 }
598 return TraceBaseState::OpenTrace(scenario, args);
599 }
600
DumpTraceWithFilter(const std::vector<int32_t> & pidList,int maxDuration,uint64_t happenTime,TraceRetInfo & info)601 TraceRet TelemetryState::DumpTraceWithFilter(const std::vector<int32_t> &pidList, int maxDuration, uint64_t happenTime,
602 TraceRetInfo &info)
603 {
604 info = Hitrace::DumpTrace(maxDuration, happenTime);
605 HIVIEW_LOGI(":%{public}s, result:%{public}d", GetTag().c_str(), info.errorCode);
606 return TraceRet(info.errorCode);
607 }
608
CloseTrace(TraceScenario scenario)609 TraceRet TelemetryState::CloseTrace(TraceScenario scenario)
610 {
611 if (scenario != TraceScenario::TRACE_TELEMETRY) {
612 HIVIEW_LOGW(":%{public}s, scenario:%{public}d is deny", GetTag().c_str(), static_cast<int>(scenario));
613 return TraceRet(TraceStateCode::FAIL);
614 }
615 return TraceBaseState::CloseTrace(scenario);
616 }
617
OpenTrace(TraceScenario scenario,const std::vector<std::string> & tagGroups)618 TraceRet DynamicState::OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups)
619 {
620 if (auto closeRet = Hitrace::CloseTrace(); closeRet != TraceErrorCode::SUCCESS) {
621 HIVIEW_LOGE("%{public}s: CloseTrace result:%{public}d", GetTag().c_str(), closeRet);
622 return TraceRet(closeRet);
623 }
624 return TraceBaseState::OpenTrace(scenario, tagGroups);
625 }
626
OpenTrace(TraceScenario scenario,const std::string & args)627 TraceRet DynamicState::OpenTrace(TraceScenario scenario, const std::string &args)
628 {
629 if (auto closeRet = Hitrace::CloseTrace(); closeRet != TraceErrorCode::SUCCESS) {
630 HIVIEW_LOGE("%{public}s: CloseTrace result:%{public}d", GetTag().c_str(), closeRet);
631 return TraceRet(closeRet);
632 }
633 return TraceBaseState::OpenTrace(scenario, args);
634 }
635
OpenTelemetryTrace(const std::string & args)636 TraceRet DynamicState::OpenTelemetryTrace(const std::string &args)
637 {
638 if (auto closeRet = Hitrace::CloseTrace(); closeRet != TraceErrorCode::SUCCESS) {
639 HIVIEW_LOGE("%{public}s: CloseTrace result:%{public}d", GetTag().c_str(), closeRet);
640 return TraceRet(closeRet);
641 }
642 auto ret = args.empty() ? Hitrace::OpenTrace(TELEMETRY_TAG_GROUPS_DEFAULT) : Hitrace::OpenTrace(args);
643 HIVIEW_LOGI("%{public}s: args:%{public}s: result:%{public}d", GetTag().c_str(), args.c_str(), ret);
644 if (ret != TraceErrorCode::SUCCESS) {
645 return TraceRet(ret);
646 }
647 TraceStateMachine::GetInstance().TransToTeleMetryState();
648 return {};
649 }
650
OpenAppTrace(int32_t appPid)651 TraceRet DynamicState::OpenAppTrace(int32_t appPid)
652 {
653 HIVIEW_LOGW("DynamicState already open, occupied by appid:%{public}d", appPid);
654 return TraceRet(TraceStateCode::DENY);
655 }
656
OpenTelemetryTrace(const std::string & args)657 TraceRet CloseState::OpenTelemetryTrace(const std::string &args)
658 {
659 auto ret = args.empty() ? Hitrace::OpenTrace(TELEMETRY_TAG_GROUPS_DEFAULT) : Hitrace::OpenTrace(args);
660 HIVIEW_LOGI("%{public}s: args:%{public}s: result:%{public}d", GetTag().c_str(), args.c_str(), ret);
661 if (ret != TraceErrorCode::SUCCESS) {
662 return TraceRet(ret);
663 }
664 TraceStateMachine::GetInstance().TransToTeleMetryState();
665 return {};
666 }
667
OpenAppTrace(int32_t appPid)668 TraceRet CloseState::OpenAppTrace(int32_t appPid)
669 {
670 std::string appArgs = "tags:graphic,ace,app clockType:boot bufferSize:10240 overwrite:1 fileLimit:20 ";
671 appArgs.append("appPid:").append(std::to_string(appPid));
672 if (auto ret = Hitrace::OpenTrace(appArgs); ret != TraceErrorCode::SUCCESS) {
673 HIVIEW_LOGE("%{public}s: args:%{public}s, result:%{public}d", GetTag().c_str(), appArgs.c_str(), ret);
674 return TraceRet(ret);
675 }
676 TraceStateMachine::GetInstance().TransToDynamicState(appPid);
677 return {};
678 }
679
CloseTrace(TraceScenario scenario)680 TraceRet CloseState::CloseTrace(TraceScenario scenario)
681 {
682 return {};
683 }
684 }
685