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 <fcntl.h>
16 #include <hwext/gtest-ext.h>
17 #include <hwext/gtest-tag.h>
18 #include <thread>
19 #include <unistd.h>
20
21 #include "flow_controller.h"
22 #include "ftrace_fs_ops.h"
23 #include "ftrace_parser.h"
24
25 using FTRACE_NS::FlowController;
26 using FTRACE_NS::FtraceFsOps;
27 using FTRACE_NS::FtraceParser;
28 using FTRACE_NS::PerCpuStats;
29 using testing::ext::TestSize;
30
31 namespace {
32 #ifndef PAGE_SIZE
33 constexpr uint32_t PAGE_SIZE = 4096;
34 #endif
35
36 constexpr uint32_t BUFFER_SIZE_KB = 256;
37 constexpr uint32_t FLUSH_INTERVAL_MS = 100;
38 constexpr uint32_t FLUSH_THRESHOLD_KB = 1024;
39 constexpr uint32_t TRACE_PERIOD_MS = 500;
40 using WriterStructPtr = std::unique_ptr<WriterStruct>::pointer;
41 using ConstVoidPtr = std::unique_ptr<const void>::pointer;
42
43 long WriteFunc(WriterStructPtr writer, ConstVoidPtr data, size_t size);
44 bool FlushFunc(WriterStructPtr writer);
45
46 class FtraceParserTest : public ::testing::Test {
47 protected:
SetUpTestCase()48 static void SetUpTestCase()
49 {
50 // start tracing sched_switch event
51 FlowController controller;
52 TracePluginConfig config;
53
54 // set writer
55 WriterStruct writer = {WriteFunc, FlushFunc};
56 controller.SetWriter(static_cast<WriterStructPtr>(&writer));
57
58 // set config
59 config.add_ftrace_events("sched/sched_switch");
60 config.set_buffer_size_kb(BUFFER_SIZE_KB);
61 config.set_flush_interval_ms(FLUSH_INTERVAL_MS);
62 config.set_flush_threshold_kb(FLUSH_THRESHOLD_KB);
63 config.set_parse_ksyms(true);
64 config.set_clock("global");
65 config.set_trace_period_ms(TRACE_PERIOD_MS);
66 config.set_raw_data_prefix("/data/local/tmp/raw_trace_");
67 std::vector<uint8_t> configData(config.ByteSizeLong());
68 config.SerializeToArray(configData.data(), configData.size());
69 controller.LoadConfig(configData.data(), configData.size());
70 controller.StartCapture();
71 sleep(1);
72 controller.StopCapture();
73 }
74
SetUp()75 void SetUp() override {}
TearDown()76 void TearDown() override {}
77 };
78
WriteFunc(WriterStructPtr writer,ConstVoidPtr data,size_t size)79 long WriteFunc(WriterStructPtr writer, ConstVoidPtr data, size_t size)
80 {
81 if (writer == nullptr || data == nullptr || size <= 0) {
82 return -1;
83 }
84
85 return 0;
86 }
87
FlushFunc(WriterStructPtr writer)88 bool FlushFunc(WriterStructPtr writer)
89 {
90 if (writer == nullptr) {
91 return false;
92 }
93 return true;
94 }
95
96 /*
97 * @tc.name: Init
98 * @tc.desc: test FtraceParser::Init with normal case.
99 * @tc.type: FUNC
100 */
101 HWTEST_F(FtraceParserTest, Init, TestSize.Level1)
102 {
103 FtraceParser parser;
104 EXPECT_TRUE(parser.Init());
105 }
106
107 /*
108 * @tc.name: SetupEvent
109 * @tc.desc: test FtraceParser::Init with normal case.
110 * @tc.type: FUNC
111 */
112 HWTEST_F(FtraceParserTest, SetupEvent, TestSize.Level1)
113 {
114 FtraceParser parser;
115 EXPECT_TRUE(parser.SetupEvent("sched", "sched_switch"));
116 }
117
118 /*
119 * @tc.name: ParseSavedTgid
120 * @tc.desc: test FtraceParser::ParseSavedTgid with normal case.
121 * @tc.type: FUNC
122 */
123 HWTEST_F(FtraceParserTest, ParseSavedTgid, TestSize.Level1)
124 {
125 FtraceParser parser;
126 EXPECT_TRUE(parser.ParseSavedTgid(FtraceFsOps::GetInstance().GetSavedTgids()));
127 }
128
129 /*
130 * @tc.name: ParseSavedCmdlines
131 * @tc.desc: test FtraceParser::ParseSavedCmdlines with normal case.
132 * @tc.type: FUNC
133 */
134 HWTEST_F(FtraceParserTest, ParseSavedCmdlines, TestSize.Level1)
135 {
136 FtraceParser parser;
137 EXPECT_TRUE(parser.ParseSavedCmdlines(FtraceFsOps::GetInstance().GetSavedCmdLines()));
138 }
139
140 /*
141 * @tc.name: ParsePerCpuStatus
142 * @tc.desc: test FtraceParser::ParsePerCpuStatus with normal case.
143 * @tc.type: FUNC
144 */
145 HWTEST_F(FtraceParserTest, ParsePerCpuStatus, TestSize.Level1)
146 {
147 FtraceParser parser;
148 PerCpuStats perCpuStats = {};
149 EXPECT_FALSE(parser.ParsePerCpuStatus(perCpuStats, ""));
150
151 std::string perCpuStatsStr = FtraceFsOps::GetInstance().GetPerCpuStats(0);
152 EXPECT_TRUE(parser.ParsePerCpuStatus(perCpuStats, perCpuStatsStr));
153 }
154
155 /*
156 * @tc.name: ParsePage
157 * @tc.desc: test SubEventParser::ParsePage with normal case.
158 * @tc.type: FUNC
159 */
160 HWTEST_F(FtraceParserTest, ParsePage, TestSize.Level1)
161 {
162 std::vector<uint8_t> buffer(PAGE_SIZE, 0);
163 std::string traceRaw = FtraceFsOps::GetInstance().GetRawTracePath(0);
164 int fd = open(traceRaw.c_str(), O_EXCL);
165 EXPECT_NE(fd, -1);
166
167 EXPECT_TRUE(FtraceFsOps::GetInstance().ClearTraceBuffer());
168 EXPECT_TRUE(FtraceFsOps::GetInstance().EnableEvent("sched", "sched_switch"));
169 EXPECT_TRUE(FtraceFsOps::GetInstance().EnableTracing());
170 std::this_thread::yield();
171 EXPECT_EQ(read(fd, buffer.data(), buffer.size()), PAGE_SIZE);
172 EXPECT_TRUE(FtraceFsOps::GetInstance().DisableTracing());
173
174 FtraceCpuDetailMsg cpuDetailMsg = {};
175 FtraceParser parser;
176 EXPECT_TRUE(parser.ParsePage(cpuDetailMsg, buffer.data(), buffer.size()));
177 EXPECT_EQ(close(fd), 0);
178 }
179 } // namespace