• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #ifndef HIVIEWDFX_HIVIEW_TRACE_STATE_MACHINE_H
16 #define HIVIEWDFX_HIVIEW_TRACE_STATE_MACHINE_H
17 
18 #include <cinttypes>
19 #include <memory>
20 #include <mutex>
21 #include <string>
22 #include <utility>
23 #include <vector>
24 
25 #include "singleton.h"
26 #include "time_util.h"
27 #include "trace_common.h"
28 
29 namespace OHOS::HiviewDFX {
30 class TraceBaseState {
31 public:
32     virtual ~TraceBaseState() = default;
33     virtual TraceRet OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups);
34     virtual TraceRet OpenTrace(TraceScenario scenario, const std::string &args);
35     virtual TraceRet OpenTelemetryTrace(const std::string &args);
36     virtual TraceRet OpenAppTrace(int32_t appPid);
37     virtual TraceRet DumpTrace(TraceScenario scenario, int maxDuration, uint64_t happenTime, TraceRetInfo &info);
38     virtual TraceRet DumpTraceWithFilter(const std::vector<int32_t> &pidList, int maxDuration, uint64_t happenTime,
39         TraceRetInfo &info);
40     virtual TraceRet TraceDropOn(TraceScenario scenario);
41     virtual TraceRet TraceDropOff(TraceScenario scenario, TraceRetInfo &info);
42     virtual TraceRet TraceCacheOn();
43     virtual TraceRet SetCacheParams(int32_t totalFileSize, int32_t sliceMaxDuration);
44     virtual TraceRet TraceCacheOff();
45     virtual TraceRet CloseTrace(TraceScenario scenario);
46 
RegisterTelemetryCallback(std::function<void ()> func)47     virtual bool RegisterTelemetryCallback(std::function<void()> func)
48     {
49         return false;
50     }
51 
GetTaskBeginTime()52     virtual uint64_t GetTaskBeginTime()
53     {
54         return 0;
55     }
56 
GetAppPid()57     virtual int32_t GetAppPid()
58     {
59         return -1;
60     }
61 
62 protected:
63     virtual std::string GetTag() = 0;
64 };
65 
66 class CommandState : public TraceBaseState {
67 public:
68     TraceRet OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups) override;
69     TraceRet OpenTrace(TraceScenario scenario, const std::string &args) override;
70     TraceRet DumpTrace(TraceScenario scenario, int maxDuration, uint64_t happenTime, TraceRetInfo &info) override;
71     TraceRet TraceDropOn(TraceScenario scenario) override;
72     TraceRet CloseTrace(TraceScenario scenario) override;
73 
74 protected:
GetTag()75     std::string GetTag() override
76     {
77         return "CommandState";
78     }
79 };
80 
81 class CommandDropState : public TraceBaseState {
82 public:
83     TraceRet OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups) override;
84     TraceRet OpenTrace(TraceScenario scenario, const std::string &args) override;
85     TraceRet TraceDropOff(TraceScenario scenario, TraceRetInfo &info) override;
86     TraceRet CloseTrace(TraceScenario scenario) override;
87 
88 protected:
GetTag()89     std::string GetTag() override
90     {
91         return "CommandDropState";
92     }
93 };
94 
95 class CommonState : public TraceBaseState {
96 public:
97     explicit CommonState(bool isCachOn, int32_t totalFileSize, int32_t sliceMaxDuration);
98     TraceRet OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups) override;
99     TraceRet OpenTrace(TraceScenario scenario, const std::string &args) override;
100     TraceRet DumpTrace(TraceScenario scenario, int maxDuration, uint64_t happenTime, TraceRetInfo &info) override;
101     TraceRet TraceDropOn(TraceScenario scenario) override;
102     TraceRet TraceCacheOn() override;
103     TraceRet TraceCacheOff() override;
104     TraceRet SetCacheParams(int32_t totalFileSize, int32_t sliceMaxDuration) override;
105     TraceRet CloseTrace(TraceScenario scenario) override;
106 
107 protected:
GetTag()108     std::string GetTag() override
109     {
110         return "CommonState";
111     }
112 
113 private:
114     int32_t totalFileSize_ ;
115     int32_t sliceMaxDuration_;
116 };
117 
118 class CommonDropState : public TraceBaseState {
119 public:
120     TraceRet OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups) override;
121     TraceRet OpenTrace(TraceScenario scenario, const std::string &args) override;
122     TraceRet TraceDropOff(TraceScenario scenario, TraceRetInfo &info) override;
123     TraceRet CloseTrace(TraceScenario scenario) override;
124 
125 protected:
GetTag()126     std::string GetTag() override
127     {
128         return "CommonDropState";
129     }
130 };
131 
132 class TelemetryState : public TraceBaseState {
133 public:
~TelemetryState()134     ~TelemetryState() override
135     {
136         if (stateStopCallback_) {
137             stateStopCallback_();
138         }
139     }
140 
RegisterTelemetryCallback(std::function<void ()> func)141     bool RegisterTelemetryCallback(std::function<void()> func) override
142     {
143         stateStopCallback_ = std::move(func);
144         return true;
145     }
146 
147     TraceRet OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups) override;
148     TraceRet OpenTrace(TraceScenario scenario, const std::string &args) override;
149     TraceRet DumpTraceWithFilter(const std::vector<int32_t> &pidList, int maxDuration, uint64_t happenTime,
150         TraceRetInfo &info) override;
151     TraceRet CloseTrace(TraceScenario scenario) override;
152 
153 protected:
GetTag()154     std::string GetTag() override
155     {
156         return "TelemetryState";
157     }
158 
159 private:
160     std::function<void()> stateStopCallback_;
161 };
162 
163 class DynamicState : public TraceBaseState {
164 public:
DynamicState(int32_t appPid)165     explicit DynamicState(int32_t appPid) : appPid_(appPid)
166     {
167         taskBeginTime_ = TimeUtil::GetMilliseconds();
168     }
169 
170     TraceRet OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups) override;
171     TraceRet OpenTrace(TraceScenario scenario, const std::string &args) override;
172     TraceRet OpenAppTrace(int32_t appPid) override;
173     TraceRet OpenTelemetryTrace(const std::string &args) override;
174     TraceRet DumpTrace(TraceScenario scenario, int maxDuration, uint64_t happenTime, TraceRetInfo &info) override;
175     TraceRet CloseTrace(TraceScenario scenario) override;
176 
GetTaskBeginTime()177     uint64_t GetTaskBeginTime() override
178     {
179         return taskBeginTime_;
180     }
181 
GetAppPid()182     int32_t GetAppPid() override
183     {
184         return appPid_;
185     }
186 
187 protected:
GetTag()188     std::string GetTag() override
189     {
190         return "DynamicState";
191     }
192 
193 private:
194     int32_t appPid_ = -1;
195     uint64_t taskBeginTime_ = 0;
196 };
197 
198 class CloseState : public TraceBaseState {
199 public:
200     TraceRet OpenTelemetryTrace(const std::string &args) override;
201 
202     TraceRet OpenAppTrace(int32_t appPid) override;
203 
204     TraceRet CloseTrace(TraceScenario scenario) override;
205 
206 protected:
GetTag()207     std::string GetTag() override
208     {
209         return "CloseState";
210     }
211 };
212 
213 class TraceStateMachine : public OHOS::DelayedRefSingleton<TraceStateMachine> {
214 public:
215     TraceStateMachine();
216 
217     TraceRet OpenTrace(TraceScenario scenario, const std::vector<std::string> &tagGroups);
218 
219     TraceRet OpenTrace(TraceScenario scenario, const std::string &args);
220 
221     TraceRet OpenTelemetryTrace(const std::string &args);
222 
223     TraceRet OpenDynamicTrace(int32_t appid);
224 
225     TraceRet DumpTrace(TraceScenario scenario, int maxDuration, uint64_t happenTime, TraceRetInfo &info);
226 
227     TraceRet DumpTraceWithFilter(const std::vector<int32_t> &pidList, int maxDuration, uint64_t happenTime,
228         TraceRetInfo &info);
229 
230     TraceRet TraceDropOn(TraceScenario scenario);
231 
232     TraceRet TraceDropOff(TraceScenario scenario, TraceRetInfo &info);
233 
234     TraceRet CloseTrace(TraceScenario scenario);
235 
236     TraceRet TraceCacheOn();
237 
238     TraceRet TraceCacheOff();
239 
240     TraceRet InitOrUpdateState();
241 
242     TraceRet InitCommonDropState();
243 
244     TraceRet InitCommonState();
245 
246     void TransToCommonState();
247 
248     void TransToCommandState();
249 
250     void TransToCommandDropState();
251 
252     void TransToCommonDropState();
253 
254     void TransToTeleMetryState();
255 
256     void TransToDynamicState(int32_t appid);
257 
258     void TransToCloseState();
259 
260     bool RegisterTelemetryCallback(std::function<void()> func);
261 
SetCacheParams(int32_t totalFileSize,int32_t sliceMaxDuration)262     void SetCacheParams(int32_t totalFileSize, int32_t sliceMaxDuration)
263     {
264         cacheSizeLimit_ = totalFileSize;
265         cacheSliceSpan_ = sliceMaxDuration;
266     }
267 
GetCurrentAppPid()268     int32_t GetCurrentAppPid()
269     {
270         return currentState_->GetAppPid();
271     }
272 
GetTaskBeginTime()273     uint64_t GetTaskBeginTime()
274     {
275         return currentState_->GetTaskBeginTime();
276     }
277 
SetTraceVersionBeta()278     void SetTraceVersionBeta()
279     {
280         std::lock_guard<std::mutex> lock(traceMutex_);
281         uint8_t beta = 1 << 3;
282         traceSwitchState_ = traceSwitchState_ | beta;
283         RecoverState();
284     }
285 
CloseVersionBeta()286     void CloseVersionBeta()
287     {
288         uint8_t beta = 1 << 3;
289         traceSwitchState_ = traceSwitchState_ & (~beta);
290     }
291 
SetTraceSwitchUcOn()292     void SetTraceSwitchUcOn()
293     {
294         std::lock_guard<std::mutex> lock(traceMutex_);
295         uint8_t ucollection = 1 << 2;
296         traceSwitchState_ = traceSwitchState_ | ucollection;
297         RecoverState();
298     }
299 
SetTraceSwitchUcOff()300     void SetTraceSwitchUcOff()
301     {
302         std::lock_guard<std::mutex> lock(traceMutex_);
303         uint8_t ucollection = 1 << 2;
304         traceSwitchState_ = traceSwitchState_ & (~ucollection);
305         RecoverState();
306     }
307 
SetTraceSwitchFreezeOn()308     void SetTraceSwitchFreezeOn()
309     {
310         std::lock_guard<std::mutex> lock(traceMutex_);
311         uint8_t freeze = 1 << 1;
312         traceSwitchState_ = traceSwitchState_ | freeze;
313         RecoverState();
314     }
315 
SetTraceSwitchFreezeOff()316     void SetTraceSwitchFreezeOff()
317     {
318         std::lock_guard<std::mutex> lock(traceMutex_);
319         uint8_t freeze = 1 << 1;
320         traceSwitchState_ = traceSwitchState_ & (~freeze);
321         RecoverState();
322     }
323 
SetTraceSwitchDevOn()324     void SetTraceSwitchDevOn()
325     {
326         std::lock_guard<std::mutex> lock(traceMutex_);
327         uint8_t dev = 1;
328         traceSwitchState_ = traceSwitchState_ | dev;
329         RecoverState();
330     }
331 
SetTraceSwitchDevOff()332     void SetTraceSwitchDevOff()
333     {
334         std::lock_guard<std::mutex> lock(traceMutex_);
335         uint8_t dev = 1;
336         traceSwitchState_ = traceSwitchState_ & (~dev);
337         RecoverState();
338     }
339 
SetCommandState(bool isCommandState)340     void SetCommandState(bool isCommandState)
341     {
342         isCommandState_ = isCommandState;
343     }
344 
GetCommandState()345     bool GetCommandState()
346     {
347         return isCommandState_;
348     }
349 
350 private:
351     TraceRet RecoverState();
352 
353 private:
354     std::shared_ptr<TraceBaseState> currentState_;
355     int32_t cacheSizeLimit_ = 800; // 800MB;
356     int32_t cacheSliceSpan_ = 10; // 10 seconds
357     uint8_t traceSwitchState_ = 0;
358     bool isCommandState_ = false;
359     bool isCachSwitchOn_ = false;
360     std::mutex traceMutex_;
361 };
362 }
363 
364 #endif // HIVIEWDFX_HIVIEW_TRACE_STATE_MACHINE_H
365