• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
16 #include <hwext/gtest-ext.h>
17 #include <hwext/gtest-tag.h>
18 
19 #include "binder_filter.h"
20 #include "htrace_cpu_detail_parser.h"
21 #include "trace_plugin_result.pb.h"
22 #include "trace_plugin_result.pbreader.h"
23 #include "trace_streamer_selector.h"
24 #include "ts_common.h"
25 
26 using namespace testing::ext;
27 using namespace SysTuning::TraceStreamer;
28 namespace SysTuning {
29 namespace TraceStreamer {
30 class HtraceBinderEventTest : public ::testing::Test {
31 public:
SetUp()32     void SetUp()
33     {
34         stream_.InitFilter();
35     }
36 
TearDown()37     void TearDown() {}
38 
SetBinderTransactionFormat(uint32_t flags=0x02,bool isReply=false)39     std::string SetBinderTransactionFormat(uint32_t flags = 0x02, bool isReply = false)
40     {
41         const int64_t ts1 = 100;
42         const int32_t destTgid1 = 2;
43         const int32_t destTid1 = 3;
44         BinderTransactionFormat *binderEvent = new BinderTransactionFormat();
45         binderEvent->set_to_proc(destTgid1);
46         binderEvent->set_target_node(1);
47         binderEvent->set_to_thread(destTid1);
48         binderEvent->set_debug_id(1);
49         binderEvent->set_reply(static_cast<int32_t>(isReply));
50         binderEvent->set_flags(flags);
51         TracePluginResult tracePacket;
52         FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail();
53         auto ftraceEvent = ftraceCpuDetail->add_event();
54         ftraceEvent->set_timestamp(ts1);
55         ftraceEvent->set_tgid(1);
56         ftraceEvent->set_comm("app1");
57         ftraceEvent->set_allocated_binder_transaction_format(binderEvent);
58 
59         std::string cpuDetailStrMsg = "";
60         tracePacket.SerializeToString(&cpuDetailStrMsg);
61         return cpuDetailStrMsg;
62     }
63 
SetBinderTransactionReceivedFormat(uint64_t transactionId=1)64     std::string SetBinderTransactionReceivedFormat(uint64_t transactionId = 1)
65     {
66         const int64_t ts1 = 200;
67         BinderTransactionReceivedFormat *binderReceivedEvent = new BinderTransactionReceivedFormat();
68         binderReceivedEvent->set_debug_id(transactionId);
69         TracePluginResult tracePacket;
70         FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail();
71         auto ftraceEvent = ftraceCpuDetail->add_event();
72         ftraceEvent->set_timestamp(ts1);
73         ftraceEvent->set_tgid(1);
74         ftraceEvent->set_comm("app2");
75         ftraceEvent->set_allocated_binder_transaction_received_format(binderReceivedEvent);
76 
77         std::string cpuDetailStrMsg = "";
78         tracePacket.SerializeToString(&cpuDetailStrMsg);
79         return cpuDetailStrMsg;
80     }
81 
SetBinderTransactionAllocBufFormat()82     std::string SetBinderTransactionAllocBufFormat()
83     {
84         const int64_t ts1 = 150;
85         const uint64_t dataSize = 100;
86         const uint64_t offsetSize = 200;
87         BinderTransactionAllocBufFormat *binderAllocEvent = new BinderTransactionAllocBufFormat();
88         binderAllocEvent->set_data_size(dataSize);
89         binderAllocEvent->set_offsets_size(offsetSize);
90         TracePluginResult tracePacket;
91         FtraceCpuDetailMsg *ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail();
92         auto ftraceEvent = ftraceCpuDetail->add_event();
93         ftraceEvent->set_timestamp(ts1);
94         ftraceEvent->set_tgid(1);
95         ftraceEvent->set_comm("app1");
96         ftraceEvent->set_allocated_binder_transaction_alloc_buf_format(binderAllocEvent);
97 
98         std::string cpuDetailStrMsg = "";
99         tracePacket.SerializeToString(&cpuDetailStrMsg);
100         return cpuDetailStrMsg;
101     }
102 
103 public:
104     SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {};
105 };
106 
107 /**
108  * @tc.name: BinderSenderfilterNeedReply
109  * @tc.desc: Binary formate binder event test, The binder event needs reply
110  * @tc.type: FUNC
111  */
112 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReply, TestSize.Level1)
113 {
114     TS_LOGI("test10-1");
115 
116     PbreaderDataSegment dataSeg;
117     dataSeg.clockId = TS_CLOCK_BOOTTIME;
118     std::string cpuDetailStrMsg = SetBinderTransactionFormat();
119     dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg);
120     ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()),
121                                               dataSeg.seg->size());
122     dataSeg.protoData = cpuDetailBytesView;
123 
124     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
125     bool haveSplit = false;
126     ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData);
127     eventParser.ParseDataItem(dataSeg, tracePluginResult, haveSplit);
128     eventParser.FilterAllEvents();
129     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1);
130     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0);
131     EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 7);
132 }
133 
134 /**
135  * @tc.name: BinderSenderfilterNeedReplyAndReceive
136  * @tc.desc: Binary formate binder event test, The binder event needs reply and received reply
137  * @tc.type: FUNC
138  */
139 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReplyAndReceive, TestSize.Level1)
140 {
141     TS_LOGI("test10-2");
142 
143     PbreaderDataSegment dataSeg;
144     dataSeg.clockId = TS_CLOCK_BOOTTIME;
145     std::string cpuDetailStrMsg = SetBinderTransactionFormat();
146     dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg);
147     ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()),
148                                               dataSeg.seg->size());
149     dataSeg.protoData = cpuDetailBytesView;
150 
151     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
152     bool haveSplit = false;
153     ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData);
154     eventParser.ParseDataItem(dataSeg, tracePluginResult, haveSplit);
155     eventParser.FilterAllEvents();
156     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1);
157     EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 7);
158 
159     PbreaderDataSegment dataSeg2;
160     dataSeg2.clockId = TS_CLOCK_BOOTTIME;
161     cpuDetailStrMsg = SetBinderTransactionReceivedFormat();
162     dataSeg2.seg = std::make_shared<std::string>(cpuDetailStrMsg);
163     ProtoReader::BytesView cpuDetailBytesView2(reinterpret_cast<const uint8_t *>(dataSeg2.seg->data()),
164                                                dataSeg2.seg->size());
165     dataSeg2.protoData = cpuDetailBytesView2;
166     ProtoReader::TracePluginResult_Reader tracePluginResult2(dataSeg2.protoData);
167     eventParser.ParseDataItem(dataSeg2, tracePluginResult2, haveSplit);
168     eventParser.FilterAllEvents();
169     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2);
170     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0);
171     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[1] == 1);
172     EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 11);
173 }
174 
175 /**
176  * @tc.name: BinderSenderfilterNeedReplyAndReceiveWithAlloc
177  * @tc.desc: Binary formate BinderTransactionAllocBuf event test, The binder event needs reply and received reply
178  * @tc.type: FUNC
179  */
180 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReplyAndReceiveWithAlloc, TestSize.Level1)
181 {
182     TS_LOGI("test10-3");
183 
184     PbreaderDataSegment dataSeg;
185     dataSeg.clockId = TS_CLOCK_BOOTTIME;
186     std::string cpuDetailStrMsg = SetBinderTransactionFormat();
187     dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg);
188     ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()),
189                                               dataSeg.seg->size());
190     dataSeg.protoData = cpuDetailBytesView;
191 
192     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
193     bool haveSplit = false;
194     ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData);
195     eventParser.ParseDataItem(dataSeg, tracePluginResult, haveSplit);
196     eventParser.FilterAllEvents();
197     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1);
198     EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 7);
199 
200     PbreaderDataSegment dataSeg2;
201     dataSeg2.clockId = TS_CLOCK_BOOTTIME;
202     cpuDetailStrMsg = SetBinderTransactionAllocBufFormat();
203     dataSeg2.seg = std::make_shared<std::string>(cpuDetailStrMsg);
204     ProtoReader::BytesView cpuDetailBytesView2(reinterpret_cast<const uint8_t *>(dataSeg2.seg->data()),
205                                                dataSeg2.seg->size());
206     dataSeg2.protoData = cpuDetailBytesView2;
207     ProtoReader::TracePluginResult_Reader tracePluginResult2(dataSeg2.protoData);
208     eventParser.ParseDataItem(dataSeg2, tracePluginResult2, haveSplit);
209     eventParser.FilterAllEvents();
210     EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 9);
211 
212     PbreaderDataSegment dataSeg3;
213     dataSeg3.clockId = TS_CLOCK_BOOTTIME;
214     cpuDetailStrMsg = SetBinderTransactionReceivedFormat();
215     dataSeg3.seg = std::make_shared<std::string>(cpuDetailStrMsg);
216     ProtoReader::BytesView cpuDetailBytesView3(reinterpret_cast<const uint8_t *>(dataSeg3.seg->data()),
217                                                dataSeg3.seg->size());
218     dataSeg3.protoData = cpuDetailBytesView3;
219     ProtoReader::TracePluginResult_Reader tracePluginResult3(dataSeg3.protoData);
220     eventParser.ParseDataItem(dataSeg3, tracePluginResult3, haveSplit);
221     eventParser.FilterAllEvents();
222     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2);
223     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0);
224     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[1] == 1);
225     EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 13);
226 }
227 
228 /**
229  * @tc.name: BinderSenderfilterNeedReplyAndReceiveNotmatch
230  * @tc.desc: Binary formate BinderTransaction event test, The binder event needs reply but received not match
231  * @tc.type: FUNC
232  */
233 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReplyAndReceiveNotmatch, TestSize.Level1)
234 {
235     TS_LOGI("test10-4");
236 
237     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
238     PbreaderDataSegment dataSeg;
239     dataSeg.clockId = TS_CLOCK_BOOTTIME;
240     std::string cpuDetailStrMsg = SetBinderTransactionFormat();
241     dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg);
242     ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()),
243                                               dataSeg.seg->size());
244     dataSeg.protoData = cpuDetailBytesView;
245     bool isSplit = false;
246     ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData);
247     eventParser.ParseDataItem(dataSeg, tracePluginResult, isSplit);
248     eventParser.FilterAllEvents();
249     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1);
250 
251     PbreaderDataSegment dataSeg2;
252     dataSeg2.clockId = TS_CLOCK_BOOTTIME;
253     cpuDetailStrMsg = SetBinderTransactionReceivedFormat(2);
254     dataSeg2.seg = std::make_shared<std::string>(cpuDetailStrMsg);
255     ProtoReader::BytesView cpuDetailBytesView2(reinterpret_cast<const uint8_t *>(dataSeg2.seg->data()),
256                                                dataSeg2.seg->size());
257     dataSeg2.protoData = cpuDetailBytesView2;
258     ProtoReader::TracePluginResult_Reader tracePluginResult2(dataSeg2.protoData);
259     eventParser.ParseDataItem(dataSeg2, tracePluginResult2, isSplit);
260     eventParser.FilterAllEvents();
261     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1);
262     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0);
263 }
264 
265 /**
266  * @tc.name: BinderSenderfilterNoNeedReply
267  * @tc.desc: Binary formate binder event test, The binder event needs no reply
268  * @tc.type: FUNC
269  */
270 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNoNeedReply, TestSize.Level1)
271 {
272     TS_LOGI("test10-5");
273 
274     PbreaderDataSegment dataSeg;
275     dataSeg.clockId = TS_CLOCK_BOOTTIME;
276     std::string cpuDetailStrMsg = SetBinderTransactionFormat();
277     dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg);
278     ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()),
279                                               dataSeg.seg->size());
280     dataSeg.protoData = cpuDetailBytesView;
281 
282     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
283     bool isSplit = false;
284     ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData);
285     eventParser.ParseDataItem(dataSeg, tracePluginResult, isSplit);
286     eventParser.FilterAllEvents();
287     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1);
288 }
289 
290 /**
291  * @tc.name: BinderSenderNoneedReplyAndReceivefilter
292  * @tc.desc: Binary formate binder event test, other party received and no need reply。
293  * @tc.type: FUNC
294  */
295 HWTEST_F(HtraceBinderEventTest, BinderSenderNoneedReplyAndReceivefilter, TestSize.Level1)
296 {
297     TS_LOGI("test10-6");
298 
299     PbreaderDataSegment dataSeg;
300     dataSeg.clockId = TS_CLOCK_BOOTTIME;
301     std::string cpuDetailStrMsg = SetBinderTransactionFormat();
302     dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg);
303     ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()),
304                                               dataSeg.seg->size());
305     dataSeg.protoData = cpuDetailBytesView;
306 
307     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
308     bool isSplit = false;
309     ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData);
310     eventParser.ParseDataItem(dataSeg, tracePluginResult, isSplit);
311     eventParser.FilterAllEvents();
312     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1);
313 
314     PbreaderDataSegment dataSeg2;
315     dataSeg2.clockId = TS_CLOCK_BOOTTIME;
316     cpuDetailStrMsg = SetBinderTransactionReceivedFormat();
317     dataSeg2.seg = std::make_shared<std::string>(cpuDetailStrMsg);
318     ProtoReader::BytesView cpuDetailBytesView2(reinterpret_cast<const uint8_t *>(dataSeg2.seg->data()),
319                                                dataSeg2.seg->size());
320     dataSeg2.protoData = cpuDetailBytesView2;
321     ProtoReader::TracePluginResult_Reader tracePluginResult2(dataSeg2.protoData);
322     eventParser.ParseDataItem(dataSeg2, tracePluginResult2, isSplit);
323     eventParser.FilterAllEvents();
324     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2);
325     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0);
326     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[1] == 1);
327 }
328 
329 /**
330  * @tc.name: BinderSenderNoneedReplyAndReceivefilterNotmatch
331  * @tc.desc: Binary formate binder event test, other party received but not match
332  * @tc.type: FUNC
333  */
334 HWTEST_F(HtraceBinderEventTest, BinderSenderNoneedReplyAndReceivefilterNotmatch, TestSize.Level1)
335 {
336     TS_LOGI("test10-7");
337 
338     PbreaderDataSegment dataSeg;
339     dataSeg.clockId = TS_CLOCK_BOOTTIME;
340     std::string cpuDetailStrMsg = SetBinderTransactionFormat();
341     dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg);
342     ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()),
343                                               dataSeg.seg->size());
344     dataSeg.protoData = cpuDetailBytesView;
345 
346     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
347     bool isSplit = false;
348     ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData);
349     eventParser.ParseDataItem(dataSeg, tracePluginResult, isSplit);
350     eventParser.FilterAllEvents();
351     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1);
352 
353     PbreaderDataSegment dataSeg2;
354     dataSeg2.clockId = TS_CLOCK_BOOTTIME;
355     cpuDetailStrMsg = SetBinderTransactionReceivedFormat(2);
356     dataSeg2.seg = std::make_shared<std::string>(cpuDetailStrMsg);
357     ProtoReader::BytesView cpuDetailBytesView2(reinterpret_cast<const uint8_t *>(dataSeg2.seg->data()),
358                                                dataSeg2.seg->size());
359     dataSeg2.protoData = cpuDetailBytesView2;
360     ProtoReader::TracePluginResult_Reader tracePluginResult2(dataSeg2.protoData);
361     eventParser.ParseDataItem(dataSeg2, tracePluginResult2, isSplit);
362     eventParser.FilterAllEvents();
363     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1);
364     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0);
365 }
366 
367 /**
368  * @tc.name: BinderSenderfilterWrongReply
369  * @tc.desc: Binary formate binder event test, other party replyed wrong Info
370  * @tc.type: FUNC
371  */
372 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterWrongReply, TestSize.Level1)
373 {
374     TS_LOGI("test10-8");
375 
376     PbreaderDataSegment dataSeg;
377     dataSeg.clockId = TS_CLOCK_BOOTTIME;
378     std::string cpuDetailStrMsg = SetBinderTransactionFormat(0x01, true);
379     dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg);
380     ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t *>(dataSeg.seg->data()),
381                                               dataSeg.seg->size());
382     dataSeg.protoData = cpuDetailBytesView;
383 
384     HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get());
385     bool isSplit = false;
386     ProtoReader::TracePluginResult_Reader tracePluginResult(dataSeg.protoData);
387     eventParser.ParseDataItem(dataSeg, tracePluginResult, isSplit);
388     eventParser.FilterAllEvents();
389     EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 0);
390     EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 0);
391 }
392 } // namespace TraceStreamer
393 } // namespace SysTuning
394