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 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 "htrace_event_parser.h" 22 #include "trace_plugin_result.pb.h" 23 #include "trace_plugin_result.pbreader.h" 24 #include "trace_streamer_selector.h" 25 #include "ts_common.h" 26 27 using namespace testing::ext; 28 using namespace SysTuning::TraceStreamer; 29 namespace SysTuning { 30 namespace TraceStreamer { 31 class HtraceBinderEventTest : public ::testing::Test { 32 public: SetUp()33 void SetUp() 34 { 35 stream_.InitFilter(); 36 } 37 TearDown()38 void TearDown() {} 39 40 public: 41 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 42 }; 43 44 /** 45 * @tc.name: BinderSenderfilterNeedReply 46 * @tc.desc: Binary formate binder event test, The binder event needs reply 47 * @tc.type: FUNC 48 */ 49 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReply, TestSize.Level1) 50 { 51 TS_LOGI("test10-1"); 52 std::string appName = "app1"; 53 int64_t ts1 = 100; 54 uint32_t tid1 = 1; 55 uint64_t transactionId1 = 1; 56 int32_t destNode1 = 1; 57 int32_t destTgid1 = 2; 58 int32_t destTid1 = 3; 59 bool isReply = false; 60 uint32_t flags = 0x02; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_); 0x01 61 uint32_t code = 0; // not important 62 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 63 binderEvent->set_to_proc(destTgid1); 64 binderEvent->set_target_node(destNode1); 65 binderEvent->set_to_thread(destTid1); 66 binderEvent->set_debug_id(transactionId1); 67 binderEvent->set_reply(static_cast<int32_t>(isReply)); 68 binderEvent->set_code(code); 69 binderEvent->set_flags(flags); 70 71 TracePluginResult tracePacket; 72 FtraceCpuDetailMsg* ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 73 ftraceCpuDetail->set_cpu(0); 74 ftraceCpuDetail->set_overwrite(0); 75 auto ftraceEvent = ftraceCpuDetail->add_event(); 76 77 ftraceEvent->set_timestamp(ts1); 78 ftraceEvent->set_tgid(tid1); 79 ftraceEvent->set_comm(appName); 80 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 81 82 HtraceDataSegment dataSeg; 83 dataSeg.clockId = TS_CLOCK_BOOTTIME; 84 std::string cpuDetailStrMsg = ""; 85 tracePacket.SerializeToString(&cpuDetailStrMsg); 86 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 87 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 88 cpuDetailStrMsg.size()); 89 dataSeg.protoData = cpuDetailBytesView; 90 91 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 92 eventParser.ParseDataItem(dataSeg, dataSeg.clockId); 93 eventParser.FilterAllEvents(); 94 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 95 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 96 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 7); 97 } 98 99 /** 100 * @tc.name: BinderSenderfilterNeedReplyAndReceive 101 * @tc.desc: Binary formate binder event test, The binder event needs reply and received reply 102 * @tc.type: FUNC 103 */ 104 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReplyAndReceive, TestSize.Level1) 105 { 106 TS_LOGI("test10-2"); 107 std::string appName = "app1"; 108 int64_t ts1 = 100; 109 uint32_t tid1 = 1; 110 uint64_t transactionId1 = 1; 111 int32_t destNode1 = 1; 112 int32_t destTgid1 = 2; 113 int32_t destTid1 = 3; 114 bool isReply = false; 115 uint32_t flags = 0x02; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_); 0x01 116 uint32_t code = 0; // not important 117 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 118 binderEvent->set_to_proc(destTgid1); 119 binderEvent->set_target_node(destNode1); 120 binderEvent->set_to_thread(destTid1); 121 binderEvent->set_debug_id(transactionId1); 122 binderEvent->set_reply(static_cast<int32_t>(isReply)); 123 binderEvent->set_code(code); 124 binderEvent->set_flags(flags); 125 126 TracePluginResult tracePacket; 127 FtraceCpuDetailMsg* ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 128 ftraceCpuDetail->set_cpu(0); 129 ftraceCpuDetail->set_overwrite(0); 130 auto ftraceEvent = ftraceCpuDetail->add_event(); 131 132 ftraceEvent->set_timestamp(ts1); 133 ftraceEvent->set_tgid(tid1); 134 ftraceEvent->set_comm(appName); 135 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 136 137 HtraceDataSegment dataSeg; 138 dataSeg.clockId = TS_CLOCK_BOOTTIME; 139 std::string cpuDetailStrMsg = ""; 140 tracePacket.SerializeToString(&cpuDetailStrMsg); 141 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 142 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 143 cpuDetailStrMsg.size()); 144 dataSeg.protoData = cpuDetailBytesView; 145 146 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 147 eventParser.ParseDataItem(dataSeg, dataSeg.clockId); 148 eventParser.FilterAllEvents(); 149 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 150 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 7); 151 152 ts1 = 200; 153 uint32_t pid1 = 1; 154 TracePluginResult tracePacket2; 155 FtraceCpuDetailMsg* ftraceCpuDetail2 = tracePacket2.add_ftrace_cpu_detail(); 156 ftraceCpuDetail2->set_cpu(0); 157 ftraceCpuDetail2->set_overwrite(0); 158 auto ftraceEvent2 = ftraceCpuDetail2->add_event(); 159 160 ftraceEvent2->set_timestamp(ts1); 161 ftraceEvent2->set_tgid(pid1); 162 std::string appName2 = "app2"; 163 ftraceEvent2->set_comm(appName2); 164 BinderTransactionReceivedFormat* binderReceivedEvent = new BinderTransactionReceivedFormat(); 165 binderReceivedEvent->set_debug_id(transactionId1); 166 ftraceEvent2->set_allocated_binder_transaction_received_format(binderReceivedEvent); 167 HtraceDataSegment dataSeg2; 168 dataSeg2.clockId = TS_CLOCK_BOOTTIME; 169 tracePacket2.SerializeToString(&cpuDetailStrMsg); 170 dataSeg2.seg = std::make_shared<std::string>(cpuDetailStrMsg); 171 ProtoReader::BytesView cpuDetailBytesView2(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 172 cpuDetailStrMsg.size()); 173 dataSeg2.protoData = cpuDetailBytesView2; 174 eventParser.ParseDataItem(dataSeg2, dataSeg2.clockId); 175 eventParser.FilterAllEvents(); 176 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2); 177 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 178 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[1] == 1); 179 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 11); 180 } 181 182 /** 183 * @tc.name: BinderSenderfilterNeedReplyAndReceiveWithAlloc 184 * @tc.desc: Binary formate BinderTransactionAllocBuf event test, The binder event needs reply and received reply 185 * @tc.type: FUNC 186 */ 187 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReplyAndReceiveWithAlloc, TestSize.Level1) 188 { 189 TS_LOGI("test10-3"); 190 int64_t ts1 = 100; 191 std::string appName = "app1"; 192 uint32_t tid1 = 1; 193 uint64_t transactionId1 = 1; 194 int32_t destNode1 = 1; 195 int32_t destTgid1 = 2; 196 int32_t destTid1 = 3; 197 bool isReply = false; 198 uint32_t flags = 0x02; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 199 uint32_t code = 0; // not important 200 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 201 binderEvent->set_to_proc(destTgid1); 202 binderEvent->set_target_node(destNode1); 203 binderEvent->set_to_thread(destTid1); 204 binderEvent->set_debug_id(transactionId1); 205 binderEvent->set_reply(static_cast<int32_t>(isReply)); 206 binderEvent->set_code(code); 207 binderEvent->set_flags(flags); 208 209 TracePluginResult tracePacket; 210 FtraceCpuDetailMsg* ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 211 ftraceCpuDetail->set_cpu(0); 212 ftraceCpuDetail->set_overwrite(0); 213 auto ftraceEvent = ftraceCpuDetail->add_event(); 214 215 ftraceEvent->set_timestamp(ts1); 216 ftraceEvent->set_tgid(tid1); 217 ftraceEvent->set_comm(appName); 218 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 219 220 HtraceDataSegment dataSeg; 221 dataSeg.clockId = TS_CLOCK_BOOTTIME; 222 std::string cpuDetailStrMsg = ""; 223 tracePacket.SerializeToString(&cpuDetailStrMsg); 224 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 225 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 226 cpuDetailStrMsg.size()); 227 dataSeg.protoData = cpuDetailBytesView; 228 229 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 230 eventParser.ParseDataItem(dataSeg, dataSeg.clockId); 231 eventParser.FilterAllEvents(); 232 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 233 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 7); 234 235 ts1 = 150; 236 uint64_t dataSize = 100; 237 uint64_t offsetSize = 200; 238 BinderTransactionAllocBufFormat* binderAllocEvent = new BinderTransactionAllocBufFormat(); 239 binderAllocEvent->set_data_size(dataSize); 240 binderAllocEvent->set_offsets_size(offsetSize); 241 242 TracePluginResult tracePacket2; 243 FtraceCpuDetailMsg* ftraceCpuDetail2 = tracePacket2.add_ftrace_cpu_detail(); 244 ftraceCpuDetail2->set_cpu(0); 245 ftraceCpuDetail2->set_overwrite(0); 246 auto ftraceEvent2 = ftraceCpuDetail2->add_event(); 247 248 ftraceEvent2->set_timestamp(ts1); 249 ftraceEvent2->set_tgid(tid1); 250 ftraceEvent2->set_comm(appName); 251 ftraceEvent2->set_allocated_binder_transaction_alloc_buf_format(binderAllocEvent); 252 253 HtraceDataSegment dataSeg2; 254 dataSeg2.clockId = TS_CLOCK_BOOTTIME; 255 tracePacket2.SerializeToString(&cpuDetailStrMsg); 256 dataSeg2.seg = std::make_shared<std::string>(cpuDetailStrMsg); 257 ProtoReader::BytesView cpuDetailBytesView2(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 258 cpuDetailStrMsg.size()); 259 dataSeg2.protoData = cpuDetailBytesView2; 260 eventParser.ParseDataItem(dataSeg2, dataSeg2.clockId); 261 eventParser.FilterAllEvents(); 262 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 9); 263 264 ts1 = 200; 265 uint32_t pid1 = 1; 266 TracePluginResult tracePacket3; 267 FtraceCpuDetailMsg* ftraceCpuDetail3 = tracePacket3.add_ftrace_cpu_detail(); 268 ftraceCpuDetail3->set_cpu(0); 269 ftraceCpuDetail3->set_overwrite(0); 270 auto ftraceEvent3 = ftraceCpuDetail3->add_event(); 271 272 ftraceEvent3->set_timestamp(ts1); 273 ftraceEvent3->set_tgid(pid1); 274 std::string appName2 = "app2"; 275 ftraceEvent3->set_comm(appName2); 276 BinderTransactionReceivedFormat* binderReceivedEvent = new BinderTransactionReceivedFormat(); 277 binderReceivedEvent->set_debug_id(transactionId1); 278 ftraceEvent3->set_allocated_binder_transaction_received_format(binderReceivedEvent); 279 HtraceDataSegment dataSeg3; 280 dataSeg3.clockId = TS_CLOCK_BOOTTIME; 281 tracePacket3.SerializeToString(&cpuDetailStrMsg); 282 dataSeg3.seg = std::make_shared<std::string>(cpuDetailStrMsg); 283 ProtoReader::BytesView cpuDetailBytesView3(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 284 cpuDetailStrMsg.size()); 285 dataSeg3.protoData = cpuDetailBytesView3; 286 eventParser.ParseDataItem(dataSeg3, dataSeg3.clockId); 287 eventParser.FilterAllEvents(); 288 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2); 289 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 290 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[1] == 1); 291 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 13); 292 } 293 294 /** 295 * @tc.name: BinderSenderfilterNeedReplyAndReceiveNotmatch 296 * @tc.desc: Binary formate BinderTransaction event test, The binder event needs reply but received not match 297 * @tc.type: FUNC 298 */ 299 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNeedReplyAndReceiveNotmatch, TestSize.Level1) 300 { 301 TS_LOGI("test10-4"); 302 std::string appName = "app1"; 303 int64_t ts1 = 100; 304 uint32_t tid1 = 1; 305 uint64_t transactionId1 = 1; 306 int32_t destNode1 = 1; 307 int32_t destTgid1 = 2; 308 int32_t destTid1 = 3; 309 bool isReply = false; 310 uint32_t flags = 0x02; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 311 uint32_t code = 0; // not important 312 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 313 binderEvent->set_to_proc(destTgid1); 314 binderEvent->set_target_node(destNode1); 315 binderEvent->set_to_thread(destTid1); 316 binderEvent->set_debug_id(transactionId1); 317 binderEvent->set_reply(static_cast<int32_t>(isReply)); 318 binderEvent->set_code(code); 319 binderEvent->set_flags(flags); 320 321 TracePluginResult tracePacket; 322 FtraceCpuDetailMsg* ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 323 ftraceCpuDetail->set_cpu(0); 324 ftraceCpuDetail->set_overwrite(0); 325 auto ftraceEvent = ftraceCpuDetail->add_event(); 326 327 ftraceEvent->set_timestamp(ts1); 328 ftraceEvent->set_tgid(tid1); 329 ftraceEvent->set_comm(appName); 330 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 331 332 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 333 HtraceDataSegment dataSeg; 334 dataSeg.clockId = TS_CLOCK_BOOTTIME; 335 std::string cpuDetailStrMsg = ""; 336 tracePacket.SerializeToString(&cpuDetailStrMsg); 337 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 338 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 339 cpuDetailStrMsg.size()); 340 dataSeg.protoData = cpuDetailBytesView; 341 342 eventParser.ParseDataItem(dataSeg, dataSeg.clockId); 343 eventParser.FilterAllEvents(); 344 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 345 346 ts1 = 200; 347 uint32_t pid1 = 1; 348 uint64_t transactionId2 = 2; 349 TracePluginResult tracePacket2; 350 FtraceCpuDetailMsg* ftraceCpuDetail2 = tracePacket2.add_ftrace_cpu_detail(); 351 ftraceCpuDetail2->set_cpu(0); 352 ftraceCpuDetail2->set_overwrite(0); 353 auto ftraceEvent2 = ftraceCpuDetail2->add_event(); 354 355 ftraceEvent2->set_timestamp(ts1); 356 ftraceEvent2->set_tgid(pid1); 357 std::string appName2 = "app2"; 358 ftraceEvent2->set_comm(appName2); 359 BinderTransactionReceivedFormat* binderReceivedEvent = new BinderTransactionReceivedFormat(); 360 binderReceivedEvent->set_debug_id(transactionId2); 361 ftraceEvent2->set_allocated_binder_transaction_received_format(binderReceivedEvent); 362 HtraceDataSegment dataSeg2; 363 dataSeg2.clockId = TS_CLOCK_BOOTTIME; 364 tracePacket2.SerializeToString(&cpuDetailStrMsg); 365 dataSeg2.seg = std::make_shared<std::string>(cpuDetailStrMsg); 366 ProtoReader::BytesView cpuDetailBytesView2(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 367 cpuDetailStrMsg.size()); 368 dataSeg2.protoData = cpuDetailBytesView2; 369 eventParser.ParseDataItem(dataSeg2, dataSeg2.clockId); 370 eventParser.FilterAllEvents(); 371 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 372 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 373 } 374 375 /** 376 * @tc.name: BinderSenderfilterNoNeedReply 377 * @tc.desc: Binary formate binder event test, The binder event needs no reply 378 * @tc.type: FUNC 379 */ 380 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterNoNeedReply, TestSize.Level1) 381 { 382 TS_LOGI("test10-5"); 383 std::string appName = "app1"; 384 int64_t ts1 = 100; 385 uint32_t tid1 = 1; 386 uint64_t transactionId1 = 1; 387 int32_t destNode1 = 1; 388 int32_t destTgid1 = 2; 389 int32_t destTid1 = 3; 390 bool isReply = false; 391 uint32_t flags = 0x01; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 392 uint32_t code = 0; // not important 393 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 394 binderEvent->set_to_proc(destTgid1); 395 binderEvent->set_target_node(destNode1); 396 binderEvent->set_to_thread(destTid1); 397 binderEvent->set_debug_id(transactionId1); 398 binderEvent->set_reply(static_cast<int32_t>(isReply)); 399 binderEvent->set_code(code); 400 binderEvent->set_flags(flags); 401 402 TracePluginResult tracePacket; 403 FtraceCpuDetailMsg* ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 404 ftraceCpuDetail->set_cpu(0); 405 ftraceCpuDetail->set_overwrite(0); 406 auto ftraceEvent = ftraceCpuDetail->add_event(); 407 408 ftraceEvent->set_timestamp(ts1); 409 ftraceEvent->set_tgid(tid1); 410 ftraceEvent->set_comm(appName); 411 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 412 413 HtraceDataSegment dataSeg; 414 dataSeg.clockId = TS_CLOCK_BOOTTIME; 415 std::string cpuDetailStrMsg = ""; 416 tracePacket.SerializeToString(&cpuDetailStrMsg); 417 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 418 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 419 cpuDetailStrMsg.size()); 420 dataSeg.protoData = cpuDetailBytesView; 421 422 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 423 eventParser.ParseDataItem(dataSeg, dataSeg.clockId); 424 eventParser.FilterAllEvents(); 425 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 426 } 427 428 /** 429 * @tc.name: BinderSenderNoneedReplyAndReceivefilter 430 * @tc.desc: Binary formate binder event test, other party received and no need reply。 431 * @tc.type: FUNC 432 */ 433 HWTEST_F(HtraceBinderEventTest, BinderSenderNoneedReplyAndReceivefilter, TestSize.Level1) 434 { 435 TS_LOGI("test10-6"); 436 std::string appName = "app1"; 437 int64_t ts1 = 100; 438 uint32_t tid1 = 1; 439 uint64_t transactionId1 = 1; 440 int32_t destNode1 = 1; 441 int32_t destTgid1 = 2; 442 int32_t destTid1 = 3; 443 bool isReply = false; 444 uint32_t flags = 0x01; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 445 uint32_t code = 0; // not important 446 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 447 binderEvent->set_to_proc(destTgid1); 448 binderEvent->set_target_node(destNode1); 449 binderEvent->set_to_thread(destTid1); 450 binderEvent->set_debug_id(transactionId1); 451 binderEvent->set_reply(static_cast<int32_t>(isReply)); 452 binderEvent->set_code(code); 453 binderEvent->set_flags(flags); 454 455 TracePluginResult tracePacket; 456 FtraceCpuDetailMsg* ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 457 ftraceCpuDetail->set_cpu(0); 458 ftraceCpuDetail->set_overwrite(0); 459 auto ftraceEvent = ftraceCpuDetail->add_event(); 460 461 ftraceEvent->set_timestamp(ts1); 462 ftraceEvent->set_tgid(tid1); 463 ftraceEvent->set_comm(appName); 464 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 465 466 HtraceDataSegment dataSeg; 467 dataSeg.clockId = TS_CLOCK_BOOTTIME; 468 std::string cpuDetailStrMsg = ""; 469 tracePacket.SerializeToString(&cpuDetailStrMsg); 470 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 471 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 472 cpuDetailStrMsg.size()); 473 dataSeg.protoData = cpuDetailBytesView; 474 475 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 476 eventParser.ParseDataItem(dataSeg, dataSeg.clockId); 477 eventParser.FilterAllEvents(); 478 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 479 480 ts1 = 200; 481 uint32_t pid1 = 1; 482 TracePluginResult tracePacket2; 483 FtraceCpuDetailMsg* ftraceCpuDetail2 = tracePacket2.add_ftrace_cpu_detail(); 484 ftraceCpuDetail2->set_cpu(0); 485 ftraceCpuDetail2->set_overwrite(0); 486 auto ftraceEvent2 = ftraceCpuDetail2->add_event(); 487 488 ftraceEvent2->set_timestamp(ts1); 489 ftraceEvent2->set_tgid(pid1); 490 std::string appName2 = "app2"; 491 ftraceEvent2->set_comm(appName2); 492 BinderTransactionReceivedFormat* binderReceivedEvent = new BinderTransactionReceivedFormat(); 493 binderReceivedEvent->set_debug_id(transactionId1); 494 ftraceEvent2->set_allocated_binder_transaction_received_format(binderReceivedEvent); 495 HtraceDataSegment dataSeg2; 496 dataSeg2.clockId = TS_CLOCK_BOOTTIME; 497 tracePacket2.SerializeToString(&cpuDetailStrMsg); 498 dataSeg2.seg = std::make_shared<std::string>(cpuDetailStrMsg); 499 ProtoReader::BytesView cpuDetailBytesView2(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 500 cpuDetailStrMsg.size()); 501 dataSeg2.protoData = cpuDetailBytesView2; 502 eventParser.ParseDataItem(dataSeg2, dataSeg2.clockId); 503 eventParser.FilterAllEvents(); 504 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 2); 505 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 506 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[1] == 0); 507 } 508 509 /** 510 * @tc.name: BinderSenderNoneedReplyAndReceivefilterNotmatch 511 * @tc.desc: Binary formate binder event test, other party received but not match 512 * @tc.type: FUNC 513 */ 514 HWTEST_F(HtraceBinderEventTest, BinderSenderNoneedReplyAndReceivefilterNotmatch, TestSize.Level1) 515 { 516 TS_LOGI("test10-7"); 517 std::string appName = "app1"; 518 int64_t ts1 = 100; 519 uint32_t tid1 = 1; 520 uint64_t transactionId1 = 1; 521 int32_t destNode1 = 1; 522 int32_t destTgid1 = 2; 523 int32_t destTid1 = 3; 524 bool isReply = false; 525 uint32_t flags = 0x01; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 526 uint32_t code = 0; // not importent 527 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 528 binderEvent->set_to_proc(destTgid1); 529 binderEvent->set_target_node(destNode1); 530 binderEvent->set_to_thread(destTid1); 531 binderEvent->set_debug_id(transactionId1); 532 binderEvent->set_reply(static_cast<int32_t>(isReply)); 533 binderEvent->set_code(code); 534 binderEvent->set_flags(flags); 535 536 TracePluginResult tracePacket; 537 FtraceCpuDetailMsg* ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 538 ftraceCpuDetail->set_cpu(0); 539 ftraceCpuDetail->set_overwrite(0); 540 auto ftraceEvent = ftraceCpuDetail->add_event(); 541 542 ftraceEvent->set_timestamp(ts1); 543 ftraceEvent->set_tgid(tid1); 544 ftraceEvent->set_comm(appName); 545 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 546 547 HtraceDataSegment dataSeg; 548 dataSeg.clockId = TS_CLOCK_BOOTTIME; 549 std::string cpuDetailStrMsg = ""; 550 tracePacket.SerializeToString(&cpuDetailStrMsg); 551 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 552 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 553 cpuDetailStrMsg.size()); 554 dataSeg.protoData = cpuDetailBytesView; 555 556 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 557 eventParser.ParseDataItem(dataSeg, dataSeg.clockId); 558 eventParser.FilterAllEvents(); 559 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 560 561 ts1 = 200; 562 uint32_t pid1 = 1; 563 uint64_t transactionId2 = 2; 564 TracePluginResult tracePacket2; 565 FtraceCpuDetailMsg* ftraceCpuDetail2 = tracePacket2.add_ftrace_cpu_detail(); 566 ftraceCpuDetail2->set_cpu(0); 567 ftraceCpuDetail2->set_overwrite(0); 568 auto ftraceEvent2 = ftraceCpuDetail2->add_event(); 569 570 ftraceEvent2->set_timestamp(ts1); 571 ftraceEvent2->set_tgid(pid1); 572 std::string appName2 = "app2"; 573 ftraceEvent2->set_comm(appName2); 574 BinderTransactionReceivedFormat* binderReceivedEvent = new BinderTransactionReceivedFormat(); 575 binderReceivedEvent->set_debug_id(transactionId2); 576 ftraceEvent2->set_allocated_binder_transaction_received_format(binderReceivedEvent); 577 HtraceDataSegment dataSeg2; 578 dataSeg2.clockId = TS_CLOCK_BOOTTIME; 579 tracePacket2.SerializeToString(&cpuDetailStrMsg); 580 dataSeg2.seg = std::make_shared<std::string>(cpuDetailStrMsg); 581 ProtoReader::BytesView cpuDetailBytesView2(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 582 cpuDetailStrMsg.size()); 583 dataSeg2.protoData = cpuDetailBytesView2; 584 eventParser.ParseDataItem(dataSeg2, dataSeg2.clockId); 585 eventParser.FilterAllEvents(); 586 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 1); 587 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().ArgSetIdsData()[0] == 0); 588 } 589 590 /** 591 * @tc.name: BinderSenderfilterWrongReply 592 * @tc.desc: Binary formate binder event test, other party replyed wrong Info 593 * @tc.type: FUNC 594 */ 595 HWTEST_F(HtraceBinderEventTest, BinderSenderfilterWrongReply, TestSize.Level1) 596 { 597 TS_LOGI("test10-8"); 598 std::string appName = "app1"; 599 int64_t ts1 = 100; 600 uint32_t tid1 = 1; 601 uint64_t transactionId1 = 1; 602 int32_t destNode1 = 1; 603 int32_t destTgid1 = 2; 604 int32_t destTid1 = 3; 605 bool isReply = true; 606 uint32_t flags = 0x01; // if need reply bool needReply = !isReply && !(flags & noReturnMsgFlag_) 607 uint32_t code = 0; // not important 608 BinderTransactionFormat* binderEvent = new BinderTransactionFormat(); 609 binderEvent->set_to_proc(destTgid1); 610 binderEvent->set_target_node(destNode1); 611 binderEvent->set_to_thread(destTid1); 612 binderEvent->set_debug_id(transactionId1); 613 binderEvent->set_reply(static_cast<int32_t>(isReply)); 614 binderEvent->set_code(code); 615 binderEvent->set_flags(flags); 616 617 TracePluginResult tracePacket; 618 FtraceCpuDetailMsg* ftraceCpuDetail = tracePacket.add_ftrace_cpu_detail(); 619 ftraceCpuDetail->set_cpu(0); 620 ftraceCpuDetail->set_overwrite(0); 621 auto ftraceEvent = ftraceCpuDetail->add_event(); 622 623 ftraceEvent->set_timestamp(ts1); 624 ftraceEvent->set_tgid(tid1); 625 ftraceEvent->set_comm(appName); 626 ftraceEvent->set_allocated_binder_transaction_format(binderEvent); 627 628 HtraceDataSegment dataSeg; 629 dataSeg.clockId = TS_CLOCK_BOOTTIME; 630 std::string cpuDetailStrMsg = ""; 631 tracePacket.SerializeToString(&cpuDetailStrMsg); 632 dataSeg.seg = std::make_shared<std::string>(cpuDetailStrMsg); 633 ProtoReader::BytesView cpuDetailBytesView(reinterpret_cast<const uint8_t*>(cpuDetailStrMsg.data()), 634 cpuDetailStrMsg.size()); 635 dataSeg.protoData = cpuDetailBytesView; 636 637 HtraceEventParser eventParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 638 eventParser.ParseDataItem(dataSeg, dataSeg.clockId); 639 eventParser.FilterAllEvents(); 640 EXPECT_TRUE(stream_.traceDataCache_->GetConstInternalSlicesData().Size() == 0); 641 EXPECT_TRUE(stream_.traceDataCache_->GetConstArgSetData().Size() == 0); 642 } 643 } // namespace TraceStreamer 644 } // namespace SysTuning 645