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 <fcntl.h> 17 #include <hwext/gtest-ext.h> 18 #include <hwext/gtest-tag.h> 19 #include <memory> 20 21 #include "htrace_native_hook_parser.h" 22 #include "native_hook_result.pb.h" 23 #include "parser/bytrace_parser/bytrace_parser.h" 24 #include "parser/common_types.h" 25 #include "trace_streamer_selector.h" 26 27 using namespace testing::ext; 28 using namespace SysTuning::TraceStreamer; 29 30 namespace SysTuning { 31 namespace TraceStreamer { 32 const uint64_t TV_SEC_01 = 1632675525; 33 const uint64_t TV_SEC_02 = 1632675526; 34 const uint64_t TV_SEC_03 = 1632675527; 35 const uint64_t TV_SEC_04 = 1632675528; 36 const uint64_t TV_NSEC_01 = 996560701; 37 const uint64_t TV_NSEC_02 = 999560702; 38 const uint64_t TV_NSEC_03 = 996560703; 39 const uint64_t TV_NSEC_04 = 999560704; 40 const uint64_t TIMESTAMP_01 = TV_NSEC_01 + TV_SEC_01 * SEC_TO_NS; 41 const uint64_t TIMESTAMP_02 = TV_NSEC_02 + TV_SEC_02 * SEC_TO_NS; 42 const uint64_t TIMESTAMP_03 = TV_NSEC_03 + TV_SEC_03 * SEC_TO_NS; 43 const uint64_t TIMESTAMP_04 = TV_NSEC_04 + TV_SEC_04 * SEC_TO_NS; 44 const int32_t PID = 2716; 45 const int32_t TID_01 = 1532; 46 const int32_t TID_02 = 1532; 47 const uint64_t MEM_ADDR_01 = 10453088; 48 const uint64_t MEM_ADDR_02 = 10453089; 49 const uint64_t MEM_ADDR_03 = 10453090; 50 const int64_t MEM_SIZE_01 = 4096; 51 const int64_t MEM_SIZE_02 = 2048; 52 const uint64_t CALL_STACK_IP_01 = 4154215627; 53 const uint64_t CALL_STACK_IP_02 = 4154215630; 54 const uint64_t CALL_STACK_SP_01 = 4146449696; 55 const uint64_t CALL_STACK_SP_02 = 4146449698; 56 const std::string SYMBOL_NAME_01 = "__aeabi_read_tp"; 57 const std::string SYMBOL_NAME_02 = "ThreadMmap"; 58 const std::string FILE_PATH_01 = "/system/lib/ld-musl-arm.so.1"; 59 const std::string FILE_PATH_02 = "/system/bin/nativetest_c"; 60 const uint64_t OFFSET_01 = 359372; 61 const uint64_t OFFSET_02 = 17865; 62 const uint64_t SYMBOL_OFFSET_01 = 255; 63 const uint64_t SYMBOL_OFFSET_02 = 33; 64 const std::string ALLOCEVENT = "AllocEvent"; 65 const std::string FREEEVENT = "FreeEvent"; 66 const std::string MMAPEVENT = "MmapEvent"; 67 const std::string MUNMAPEVENT = "MunmapEvent"; 68 const std::string MMAP_SUB_TYPE_01 = "mmapType1"; 69 const std::string MMAP_SUB_TYPE_02 = "mmapType2"; 70 class NativeHookParserTest : public ::testing::Test { 71 public: SetUp()72 void SetUp() 73 { 74 stream_.InitFilter(); 75 } 76 TearDown()77 void TearDown() {} 78 79 public: 80 SysTuning::TraceStreamer::TraceStreamerSelector stream_ = {}; 81 }; 82 83 class NativeHookCache { 84 public: NativeHookCache(const uint64_t callChainId,const uint32_t ipid,const uint32_t itid,const std::string eventType,const uint64_t subType,const uint64_t startTimeStamp,const uint64_t endTimeStamp,const uint64_t duration,const uint64_t address,const int64_t memSize,const int64_t allMemSize,const uint64_t currentSizeDurations)85 NativeHookCache(const uint64_t callChainId, 86 const uint32_t ipid, 87 const uint32_t itid, 88 const std::string eventType, 89 const uint64_t subType, 90 const uint64_t startTimeStamp, 91 const uint64_t endTimeStamp, 92 const uint64_t duration, 93 const uint64_t address, 94 const int64_t memSize, 95 const int64_t allMemSize, 96 const uint64_t currentSizeDurations) 97 : callChainId_(callChainId), 98 ipid_(ipid), 99 itid_(itid), 100 eventType_(eventType), 101 subType_(subType), 102 startTimeStamp_(startTimeStamp), 103 endTimeStamp_(endTimeStamp), 104 duration_(duration), 105 address_(address), 106 memSize_(memSize), 107 allMemSize_(allMemSize), 108 currentSizeDurations_(currentSizeDurations) 109 { 110 } 111 NativeHookCache(const NativeHook & nativeHook,uint64_t index)112 NativeHookCache(const NativeHook& nativeHook, uint64_t index) 113 { 114 if (nativeHook.Size() <= index) { 115 TS_LOGE("index out of deque bounds! nativeHook.Size() = %lu, index = %lu", nativeHook.Size(), index); 116 return; 117 } 118 callChainId_ = nativeHook.CallChainIds()[index]; 119 ipid_ = nativeHook.Ipids()[index]; 120 itid_ = nativeHook.Itids()[index]; 121 eventType_ = nativeHook.EventTypes()[index]; 122 subType_ = nativeHook.SubTypes()[index]; 123 startTimeStamp_ = nativeHook.TimeStamData()[index]; 124 endTimeStamp_ = nativeHook.EndTimeStamps()[index]; 125 duration_ = nativeHook.Durations()[index]; 126 address_ = nativeHook.Addrs()[index]; 127 memSize_ = nativeHook.MemSizes()[index]; 128 allMemSize_ = nativeHook.AllMemSizes()[index]; 129 currentSizeDurations_ = nativeHook.CurrentSizeDurs()[index]; 130 } 131 ~NativeHookCache() = default; 132 NativeHookCache(const NativeHookCache&) = delete; 133 NativeHookCache& operator=(const NativeHookCache&) = delete; operator ==(const NativeHookCache & nativeHookCache) const134 bool operator==(const NativeHookCache& nativeHookCache) const 135 { 136 if (nativeHookCache.GetCallChainId() != callChainId_) { 137 TS_LOGE("callChainId_ = %lu, nativeHookCache.GetCallChainId() = %lu", callChainId_, 138 nativeHookCache.GetCallChainId()); 139 return false; 140 } 141 if (nativeHookCache.GetPid() != ipid_) { 142 TS_LOGE("ipid_ = %u, nativeHookCache.GetPid() = %u", ipid_, nativeHookCache.GetPid()); 143 return false; 144 } 145 if (nativeHookCache.GetTid() != itid_) { 146 TS_LOGE("itid_ = %u, nativeHookCache.GetTid() = %u", nativeHookCache.GetTid(), itid_); 147 return false; 148 } 149 if (nativeHookCache.GetEventType() != eventType_) { 150 TS_LOGE("eventType_ = %s, nativeHookCache.GetEventType() = %s", eventType_.c_str(), 151 nativeHookCache.GetEventType().c_str()); 152 return false; 153 } 154 if (nativeHookCache.GetSubType() != subType_) { 155 TS_LOGE("subType_ = %lu, nativeHookCache.GetSubType() = %lu", subType_, nativeHookCache.GetSubType()); 156 return false; 157 } 158 if (nativeHookCache.GetStartTimeStamp() != startTimeStamp_) { 159 TS_LOGE("startTimeStamp_ = %lu, nativeHookCache.GetStartTimeStamp() = %lu", startTimeStamp_, 160 nativeHookCache.GetStartTimeStamp()); 161 return false; 162 } 163 if (nativeHookCache.GetEndTimeStamp() != endTimeStamp_) { 164 TS_LOGE(" endTimeStamp_ = %lu, nativeHookCache.GetEndTimeStamp() = %lu", endTimeStamp_, 165 nativeHookCache.GetEndTimeStamp()); 166 return false; 167 } 168 if (nativeHookCache.GetDuration() != duration_) { 169 TS_LOGE("duration_ = %lu, nativeHookCache.GetDuration() = %lu", duration_, nativeHookCache.GetDuration()); 170 return false; 171 } 172 if (nativeHookCache.GetEndTimeStamp() != endTimeStamp_) { 173 TS_LOGE("address_ = %lu, nativeHookCache.GetAddress() = %lu", address_, nativeHookCache.GetAddress()); 174 return false; 175 } 176 if (nativeHookCache.GetMemSize() != memSize_) { 177 TS_LOGE("memSize_ = %ld, nativeHookCache.GetMemSize() = %ld", memSize_, nativeHookCache.GetMemSize()); 178 return false; 179 } 180 if (nativeHookCache.GetAllMemSize() != allMemSize_) { 181 TS_LOGE("allMemSize_ = %lu, nativeHookCache.GetAllMemSize() = %lu", allMemSize_, 182 nativeHookCache.GetAllMemSize()); 183 return false; 184 } 185 if (nativeHookCache.GetCurrentSizeDuration() != currentSizeDurations_) { 186 TS_LOGE("currentSizeDurations_ = %lu, nativeHookCache.GetCurrentSizeDuration() = %lu", 187 currentSizeDurations_, nativeHookCache.GetCurrentSizeDuration()); 188 return false; 189 } 190 return true; 191 } GetCallChainId() const192 inline uint64_t GetCallChainId() const 193 { 194 return callChainId_; 195 } GetPid() const196 inline uint32_t GetPid() const 197 { 198 return ipid_; 199 } GetTid() const200 inline uint32_t GetTid() const 201 { 202 return itid_; 203 } GetEventType() const204 inline std::string GetEventType() const 205 { 206 return eventType_; 207 } GetSubType() const208 inline uint64_t GetSubType() const 209 { 210 return subType_; 211 } GetStartTimeStamp() const212 inline uint64_t GetStartTimeStamp() const 213 { 214 return startTimeStamp_; 215 } GetEndTimeStamp() const216 inline uint64_t GetEndTimeStamp() const 217 { 218 return endTimeStamp_; 219 } GetDuration() const220 inline uint64_t GetDuration() const 221 { 222 return duration_; 223 } GetAddress() const224 inline uint64_t GetAddress() const 225 { 226 return address_; 227 } GetMemSize() const228 inline int64_t GetMemSize() const 229 { 230 return memSize_; 231 } GetAllMemSize() const232 inline int64_t GetAllMemSize() const 233 { 234 return allMemSize_; 235 } GetCurrentSizeDuration() const236 inline uint64_t GetCurrentSizeDuration() const 237 { 238 return currentSizeDurations_; 239 } 240 241 private: 242 uint64_t callChainId_; 243 uint32_t ipid_; 244 uint32_t itid_; 245 std::string eventType_; 246 uint64_t subType_; 247 uint64_t startTimeStamp_; 248 uint64_t endTimeStamp_; 249 uint64_t duration_; 250 uint64_t address_; 251 int64_t memSize_; 252 int64_t allMemSize_; 253 uint64_t currentSizeDurations_; 254 }; 255 256 class NativeHookFrameCache { 257 public: NativeHookFrameCache(const uint64_t callChainId,const uint64_t depth,const uint64_t ip,const uint64_t sp,const uint64_t symbolName,const uint64_t filePath,const uint64_t offset,const uint64_t symbolOffset)258 NativeHookFrameCache(const uint64_t callChainId, 259 const uint64_t depth, 260 const uint64_t ip, 261 const uint64_t sp, 262 const uint64_t symbolName, 263 const uint64_t filePath, 264 const uint64_t offset, 265 const uint64_t symbolOffset) 266 : callChainId_(callChainId), 267 depth_(depth), 268 ip_(ip), 269 sp_(sp), 270 symbolName_(symbolName), 271 filePath_(filePath), 272 offset_(offset), 273 symbolOffset_(symbolOffset) 274 { 275 } 276 NativeHookFrameCache(const NativeHookFrame & nativeHookFrame,const uint64_t index)277 NativeHookFrameCache(const NativeHookFrame& nativeHookFrame, const uint64_t index) 278 { 279 if (nativeHookFrame.Size() <= index) { 280 TS_LOGE("index out of deque bounds! nativeHookFrame.Size() = %lu, index = %lu", nativeHookFrame.Size(), 281 index); 282 return; 283 } 284 callChainId_ = nativeHookFrame.CallChainIds()[index]; 285 depth_ = nativeHookFrame.Depths()[index]; 286 ip_ = nativeHookFrame.Ips()[index]; 287 sp_ = nativeHookFrame.Sps()[index]; 288 symbolName_ = nativeHookFrame.SymbolNames()[index]; 289 filePath_ = nativeHookFrame.FilePaths()[index]; 290 offset_ = nativeHookFrame.Offsets()[index]; 291 symbolOffset_ = nativeHookFrame.SymbolOffsets()[index]; 292 } 293 294 ~NativeHookFrameCache() = default; 295 NativeHookFrameCache(const NativeHookFrameCache&) = delete; 296 NativeHookFrameCache& operator=(const NativeHookFrameCache&) = delete; operator ==(const NativeHookFrameCache & frameCache) const297 bool operator==(const NativeHookFrameCache& frameCache) const 298 { 299 if (frameCache.GetCallChainId() != callChainId_) { 300 TS_LOGE("callChainId_ = %lu, frameCache.GetCallChainId() = %lu", callChainId_, frameCache.GetCallChainId()); 301 return false; 302 } 303 if (frameCache.GetDepth() != depth_) { 304 TS_LOGE("depth_ = %lu, frameCache.GetDepth() = %lu", depth_, frameCache.GetDepth()); 305 return false; 306 } 307 if (frameCache.GetIp() != ip_) { 308 TS_LOGE("ip_ = %lu, frameCache.GetIp() = %lu", ip_, frameCache.GetIp()); 309 return false; 310 } 311 if (frameCache.GetSp() != sp_) { 312 TS_LOGE("sp_ = %lu, frameCache.GetSp() = %lu", sp_, frameCache.GetSp()); 313 return false; 314 } 315 if (frameCache.GetSymbolName() != symbolName_) { 316 TS_LOGE("symbolName_ = %lu, frameCache.GetSymbolName() = %lu", symbolName_, frameCache.GetSymbolName()); 317 return false; 318 } 319 if (frameCache.GetFilePath() != filePath_) { 320 TS_LOGE("filePath_ = %lu, frameCache.GetFilePath() = %lu", filePath_, frameCache.GetFilePath()); 321 return false; 322 } 323 if (frameCache.GetOffset() != offset_) { 324 TS_LOGE("offset_ = %lu, frameCache.GetOffset() = %lu", offset_, frameCache.GetOffset()); 325 return false; 326 } 327 if (frameCache.GetSymbolOffset() != symbolOffset_) { 328 TS_LOGE("symbolOffset_ = %lu, frameCache.GetSymbolName() = %lu", symbolOffset_, frameCache.GetSymbolName()); 329 return false; 330 } 331 return true; 332 } GetCallChainId() const333 inline uint64_t GetCallChainId() const 334 { 335 return callChainId_; 336 } GetDepth() const337 inline uint64_t GetDepth() const 338 { 339 return depth_; 340 } GetIp() const341 inline uint64_t GetIp() const 342 { 343 return ip_; 344 } GetSp() const345 inline uint64_t GetSp() const 346 { 347 return sp_; 348 } GetSymbolName() const349 inline uint64_t GetSymbolName() const 350 { 351 return symbolName_; 352 } GetFilePath() const353 inline uint64_t GetFilePath() const 354 { 355 return filePath_; 356 } GetOffset() const357 inline uint64_t GetOffset() const 358 { 359 return offset_; 360 } GetSymbolOffset() const361 inline uint64_t GetSymbolOffset() const 362 { 363 return symbolOffset_; 364 } 365 366 private: 367 uint64_t callChainId_; 368 uint64_t depth_; 369 uint64_t ip_; 370 uint64_t sp_; 371 uint64_t symbolName_; 372 uint64_t filePath_; 373 uint64_t offset_; 374 uint64_t symbolOffset_; 375 }; 376 377 /** 378 * @tc.name: ParseBatchNativeHookWithOutNativeHookData 379 * @tc.desc: Parse a BatchNativeHookData that does not contain any NativeHookData 380 * @tc.type: FUNC 381 */ 382 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithOutNativeHookData, TestSize.Level1) 383 { 384 TS_LOGI("test24-1"); 385 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 386 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 387 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 388 auto size = stream_.traceDataCache_->GetConstHilogData().Size(); 389 EXPECT_FALSE(size); 390 } 391 392 /** 393 * @tc.name: ParseBatchNativeHookWithOneMalloc 394 * @tc.desc: Parse a BatchNativeHookData with only one Malloc 395 * @tc.type: FUNC 396 */ 397 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithOneMalloc, TestSize.Level1) 398 { 399 TS_LOGI("test24-2"); 400 // construct AllocEvent 401 AllocEvent* allocEvent = new AllocEvent(); 402 allocEvent->set_pid(PID); 403 allocEvent->set_tid(TID_01); 404 allocEvent->set_addr(MEM_ADDR_01); 405 allocEvent->set_size(MEM_SIZE_01); 406 // construct AllocEvent's Frame 407 auto frame = allocEvent->add_frame_info(); 408 frame->set_ip(CALL_STACK_IP_01); 409 frame->set_sp(CALL_STACK_SP_01); 410 frame->set_symbol_name(SYMBOL_NAME_01); 411 frame->set_file_path(FILE_PATH_01); 412 frame->set_offset(OFFSET_01); 413 frame->set_symbol_offset(SYMBOL_OFFSET_01); 414 415 // construct BatchNativeHookData 416 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 417 418 // add NativeHookData 419 auto nativeHookData = batchNativeHookData->add_events(); 420 nativeHookData->set_tv_sec(TV_SEC_01); 421 nativeHookData->set_tv_nsec(TV_NSEC_01); 422 nativeHookData->set_allocated_alloc_event(allocEvent); 423 424 // start parse 425 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 426 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 427 htraceNativeHookParser.FinishParseNativeHookData(); 428 429 // Verification parse NativeHook results 430 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 431 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 432 NativeHookCache expectNativeHookCache(1, expect_ipid, expect_itid, ALLOCEVENT.c_str(), INVALID_UINT64, TIMESTAMP_01, 433 0, 0, MEM_ADDR_01, MEM_SIZE_01, MEM_SIZE_01, 0); 434 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 435 NativeHookCache resultNativeHookCache(nativeHook, 0); 436 EXPECT_TRUE(expectNativeHookCache == resultNativeHookCache); 437 438 auto size = stream_.traceDataCache_->GetConstNativeHookData().Size(); 439 EXPECT_EQ(1, size); 440 441 // Verification parse NativeHook Frame results 442 const NativeHookFrame& nativeHookFrame = stream_.traceDataCache_->GetConstNativeHookFrameData(); 443 auto expectSymbolData = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_01); 444 auto expectFilePathData = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_01); 445 NativeHookFrameCache expectFrameCache(1, 0, 0, 0, expectSymbolData, expectFilePathData, OFFSET_01, 446 SYMBOL_OFFSET_01); 447 NativeHookFrameCache resultFrameCache(nativeHookFrame, 0); 448 EXPECT_TRUE(expectFrameCache == resultFrameCache); 449 450 size = nativeHookFrame.Size(); 451 EXPECT_EQ(1, size); 452 453 auto eventCount = 454 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MALLOC, STAT_EVENT_RECEIVED); 455 EXPECT_TRUE(1 == eventCount); 456 } 457 458 /** 459 * @tc.name: ParseBatchNativeHookWithMultipleMalloc 460 * @tc.desc: Parse a NativeHook with multiple Malloc and Frame 461 * @tc.type: FUNC 462 */ 463 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithMultipleMalloc, TestSize.Level1) 464 { 465 TS_LOGI("test24-3"); 466 // constructs first AllocEvent with two Frame 467 AllocEvent* firstAllocEvent = new AllocEvent(); 468 firstAllocEvent->set_pid(PID); 469 firstAllocEvent->set_tid(TID_01); 470 firstAllocEvent->set_addr(MEM_ADDR_01); 471 firstAllocEvent->set_size(MEM_SIZE_01); 472 // construct first AllocEvent's first Frame 473 auto firstAllocFirstFrame = firstAllocEvent->add_frame_info(); 474 firstAllocFirstFrame->set_ip(CALL_STACK_IP_01); 475 firstAllocFirstFrame->set_sp(CALL_STACK_SP_01); 476 firstAllocFirstFrame->set_symbol_name(SYMBOL_NAME_01); 477 firstAllocFirstFrame->set_file_path(FILE_PATH_01); 478 firstAllocFirstFrame->set_offset(OFFSET_01); 479 firstAllocFirstFrame->set_symbol_offset(SYMBOL_OFFSET_01); 480 // construct first AllocEvent's second Frame 481 auto firstAllocSecondFrame = firstAllocEvent->add_frame_info(); 482 firstAllocSecondFrame->set_ip(CALL_STACK_IP_02); 483 firstAllocSecondFrame->set_sp(CALL_STACK_SP_02); 484 firstAllocSecondFrame->set_symbol_name(SYMBOL_NAME_02); 485 firstAllocSecondFrame->set_file_path(FILE_PATH_02); 486 firstAllocSecondFrame->set_offset(OFFSET_02); 487 firstAllocSecondFrame->set_symbol_offset(SYMBOL_OFFSET_02); 488 489 // constructs second AllocEvent with two Frame 490 AllocEvent* secondAllocEvent = new AllocEvent(); 491 secondAllocEvent->set_pid(PID); 492 secondAllocEvent->set_tid(TID_02); 493 secondAllocEvent->set_addr(MEM_ADDR_02); 494 secondAllocEvent->set_size(MEM_SIZE_02); 495 // construct second AllocEvent's first Frame 496 auto secondAllocFirstFrame = secondAllocEvent->add_frame_info(); 497 secondAllocFirstFrame->set_ip(CALL_STACK_IP_01); 498 secondAllocFirstFrame->set_sp(CALL_STACK_SP_01); 499 secondAllocFirstFrame->set_symbol_name(SYMBOL_NAME_01); 500 secondAllocFirstFrame->set_file_path(FILE_PATH_01); 501 secondAllocFirstFrame->set_offset(OFFSET_01); 502 secondAllocFirstFrame->set_symbol_offset(SYMBOL_OFFSET_01); 503 // construct second AllocEvent's second Frame 504 auto secondAllocSecondFrame = secondAllocEvent->add_frame_info(); 505 secondAllocSecondFrame->set_ip(CALL_STACK_IP_02); 506 secondAllocSecondFrame->set_sp(CALL_STACK_SP_02); 507 secondAllocSecondFrame->set_symbol_name(SYMBOL_NAME_02); 508 secondAllocSecondFrame->set_file_path(FILE_PATH_02); 509 secondAllocSecondFrame->set_offset(OFFSET_02); 510 secondAllocSecondFrame->set_symbol_offset(SYMBOL_OFFSET_02); 511 512 // construct BatchNativeHookData 513 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 514 515 // add first NativeHookData 516 auto firstNativeHookData = batchNativeHookData->add_events(); 517 firstNativeHookData->set_tv_sec(TV_SEC_01); 518 firstNativeHookData->set_tv_nsec(TV_NSEC_01); 519 firstNativeHookData->set_allocated_alloc_event(firstAllocEvent); 520 // add second NativeHookData 521 auto secondNativeHookData = batchNativeHookData->add_events(); 522 secondNativeHookData->set_tv_sec(TV_SEC_02); 523 secondNativeHookData->set_tv_nsec(TV_NSEC_02); 524 secondNativeHookData->set_allocated_alloc_event(secondAllocEvent); 525 526 // start parse 527 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 528 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 529 htraceNativeHookParser.FinishParseNativeHookData(); 530 531 // Verification parse NativeHook results 532 // Calculate partial expectations 533 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 534 const NativeHookFrame& nativeHookFrame = stream_.traceDataCache_->GetConstNativeHookFrameData(); 535 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 536 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 537 EXPECT_TRUE(MEM_SIZE_01 == nativeHook.AllMemSizes()[0]); 538 EXPECT_TRUE(nativeHook.CurrentSizeDurs()[0] == TIMESTAMP_02 - TIMESTAMP_01); 539 540 // Construct the nativehookcache object using the element with subscript 0 in nativehook and compare it with the 541 // expected value 542 NativeHookCache firstExpectNativeHookCache(1, expect_ipid, expect_itid, ALLOCEVENT.c_str(), INVALID_UINT64, 543 TIMESTAMP_01, 0, 0, MEM_ADDR_01, MEM_SIZE_01, MEM_SIZE_01, 544 TIMESTAMP_02 - TIMESTAMP_01); 545 NativeHookCache firstResultNativeHookCache(nativeHook, 0); 546 EXPECT_TRUE(firstExpectNativeHookCache == firstResultNativeHookCache); 547 548 // construct first Malloc event's first frame expect value. 549 // Note: the nativehookframe data is parsed in reverse order 550 auto firstExpectSymbol = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_02); 551 auto firstExpectFilePath = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_02); 552 auto secondExpectSymbol = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_01); 553 auto secondExpectFilePath = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_01); 554 NativeHookFrameCache firstMallocExpectFirstFrame(1, 0, 0, 0, firstExpectSymbol, firstExpectFilePath, OFFSET_02, 555 SYMBOL_OFFSET_02); 556 // Construct the NativeHookFrameCache object using the element with subscript 0 in NativeHookFrame and compare it 557 // with the expected value 558 NativeHookFrameCache firstMallocResultFirstFrame(nativeHookFrame, 0); 559 EXPECT_TRUE(firstMallocExpectFirstFrame == firstMallocResultFirstFrame); 560 561 // construct first Malloc event's second frame expect value. 562 NativeHookFrameCache firstMallocExpectSecondFrame(1, 1, 0, 0, secondExpectSymbol, secondExpectFilePath, OFFSET_01, 563 SYMBOL_OFFSET_01); 564 NativeHookFrameCache firstMallocResultSecondFrame(nativeHookFrame, 1); 565 EXPECT_TRUE(firstMallocExpectSecondFrame == firstMallocResultSecondFrame); 566 567 // Construct the nativehookcache object using the element with subscript 1 in nativehook and compare it with the 568 // expected value 569 expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_02); 570 NativeHookCache secondExpectNativeHookCache(1, expect_ipid, expect_itid, ALLOCEVENT.c_str(), INVALID_UINT64, 571 TIMESTAMP_02, 0, 0, MEM_ADDR_02, MEM_SIZE_02, MEM_SIZE_01 + MEM_SIZE_02, 572 0); 573 NativeHookCache secondResultNativeHookCache(nativeHook, 1); 574 EXPECT_TRUE(secondExpectNativeHookCache == secondResultNativeHookCache); 575 576 // construct second Malloc event's first frame expect value. 577 // Note: the nativehookframe data is parsed in reverse order 578 NativeHookFrameCache secondMallocExpectFirstFrame(1, 0, 0, 0, firstExpectSymbol, firstExpectFilePath, OFFSET_02, 579 SYMBOL_OFFSET_02); 580 // Construct the NativeHookFrameCache object using the element with subscript 2 in NativeHookFrame and compare it 581 // Verify the compression algorithm here= 582 EXPECT_EQ(nativeHookFrame.CallChainIds()[1], 1); 583 EXPECT_EQ(nativeHookFrame.Depths()[1], 1); 584 EXPECT_EQ(nativeHookFrame.Ips()[1], 0); 585 EXPECT_EQ(nativeHookFrame.Sps()[1], 0); 586 EXPECT_EQ(nativeHookFrame.SymbolNames()[1], secondExpectSymbol); 587 EXPECT_EQ(nativeHookFrame.FilePaths()[1], secondExpectFilePath); 588 EXPECT_EQ(nativeHookFrame.Offsets()[1], OFFSET_01); 589 EXPECT_EQ(nativeHookFrame.SymbolOffsets()[1], SYMBOL_OFFSET_01); 590 } 591 592 /** 593 * @tc.name: ParseBatchNativeHookWithOneFree 594 * @tc.desc: Parse a BatchNativeHookData with only one Free 595 * @tc.type: FUNC 596 */ 597 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithOneFree, TestSize.Level1) 598 { 599 TS_LOGI("test24-4"); 600 // construct FreeEvent 601 FreeEvent* freeEvent = new FreeEvent(); 602 freeEvent->set_pid(PID); 603 freeEvent->set_tid(TID_01); 604 freeEvent->set_addr(MEM_ADDR_01); 605 // construct FreeEvent's Frame 606 auto frame = freeEvent->add_frame_info(); 607 frame->set_ip(CALL_STACK_IP_01); 608 frame->set_sp(CALL_STACK_SP_01); 609 frame->set_symbol_name(SYMBOL_NAME_01); 610 frame->set_file_path(FILE_PATH_01); 611 frame->set_offset(OFFSET_01); 612 frame->set_symbol_offset(SYMBOL_OFFSET_01); 613 614 // construct BatchNativeHookData 615 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 616 617 // add NativeHookData 618 auto nativeHookData = batchNativeHookData->add_events(); 619 nativeHookData->set_tv_sec(TV_SEC_01); 620 nativeHookData->set_tv_nsec(TV_NSEC_01); 621 nativeHookData->set_allocated_free_event(freeEvent); 622 623 // start parse 624 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 625 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 626 htraceNativeHookParser.FinishParseNativeHookData(); 627 auto size = stream_.traceDataCache_->GetConstNativeHookData().Size(); 628 EXPECT_EQ(0, size); 629 size = stream_.traceDataCache_->GetConstNativeHookFrameData().Size(); 630 EXPECT_EQ(0, size); 631 auto eventCount = 632 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_FREE, STAT_EVENT_RECEIVED); 633 EXPECT_TRUE(1 == eventCount); 634 } 635 636 /** 637 * @tc.name: ParseBatchNativeHookWithMultipleFree 638 * @tc.desc: Parse a NativeHook with multiple Free and Frame 639 * @tc.type: FUNC 640 */ 641 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithMultipleFree, TestSize.Level1) 642 { 643 TS_LOGI("test24-5"); 644 // constructs first FreeEvent with two Frame 645 FreeEvent* firstFreeEvent = new FreeEvent(); 646 firstFreeEvent->set_pid(PID); 647 firstFreeEvent->set_tid(TID_01); 648 firstFreeEvent->set_addr(MEM_ADDR_01); 649 // construct first FreeEvent's first Frame 650 auto firstFreeFirstFrame = firstFreeEvent->add_frame_info(); 651 firstFreeFirstFrame->set_ip(CALL_STACK_IP_01); 652 firstFreeFirstFrame->set_sp(CALL_STACK_SP_01); 653 firstFreeFirstFrame->set_symbol_name(SYMBOL_NAME_01); 654 firstFreeFirstFrame->set_file_path(FILE_PATH_01); 655 firstFreeFirstFrame->set_offset(OFFSET_01); 656 firstFreeFirstFrame->set_symbol_offset(SYMBOL_OFFSET_01); 657 // construct first FreeEvent's second Frame 658 auto firstFreeSecondFrame = firstFreeEvent->add_frame_info(); 659 firstFreeSecondFrame->set_ip(CALL_STACK_IP_02); 660 firstFreeSecondFrame->set_sp(CALL_STACK_SP_02); 661 firstFreeSecondFrame->set_symbol_name(SYMBOL_NAME_02); 662 firstFreeSecondFrame->set_file_path(FILE_PATH_02); 663 firstFreeSecondFrame->set_offset(OFFSET_02); 664 firstFreeSecondFrame->set_symbol_offset(SYMBOL_OFFSET_02); 665 666 // constructs second FreeEvent with two Frame 667 FreeEvent* secondFreeEvent = new FreeEvent(); 668 secondFreeEvent->set_pid(PID); 669 secondFreeEvent->set_tid(TID_02); 670 secondFreeEvent->set_addr(MEM_ADDR_02); 671 // construct second FreeEvent's first Frame 672 auto secondFreeFirstFrame = secondFreeEvent->add_frame_info(); 673 secondFreeFirstFrame->set_ip(CALL_STACK_IP_01); 674 secondFreeFirstFrame->set_sp(CALL_STACK_SP_01); 675 secondFreeFirstFrame->set_symbol_name(SYMBOL_NAME_01); 676 secondFreeFirstFrame->set_file_path(FILE_PATH_01); 677 secondFreeFirstFrame->set_offset(OFFSET_01); 678 secondFreeFirstFrame->set_symbol_offset(SYMBOL_OFFSET_01); 679 // construct second FreeEvent's second Frame 680 auto secondFreeSecondFrame = secondFreeEvent->add_frame_info(); 681 secondFreeSecondFrame->set_ip(CALL_STACK_IP_02); 682 secondFreeSecondFrame->set_sp(CALL_STACK_SP_02); 683 secondFreeSecondFrame->set_symbol_name(SYMBOL_NAME_02); 684 secondFreeSecondFrame->set_file_path(FILE_PATH_02); 685 secondFreeSecondFrame->set_offset(OFFSET_02); 686 secondFreeSecondFrame->set_symbol_offset(SYMBOL_OFFSET_02); 687 688 // construct BatchNativeHookData 689 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 690 691 // add first NativeHookData 692 auto firstNativeHookData = batchNativeHookData->add_events(); 693 firstNativeHookData->set_tv_sec(TV_SEC_01); 694 firstNativeHookData->set_tv_nsec(TV_NSEC_01); 695 firstNativeHookData->set_allocated_free_event(firstFreeEvent); 696 // add second NativeHookData 697 auto secondNativeHookData = batchNativeHookData->add_events(); 698 secondNativeHookData->set_tv_sec(TV_SEC_02); 699 secondNativeHookData->set_tv_nsec(TV_NSEC_02); 700 secondNativeHookData->set_allocated_free_event(secondFreeEvent); 701 702 // start parse 703 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 704 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 705 htraceNativeHookParser.FinishParseNativeHookData(); 706 707 // Verification parse NativeHook results 708 // Calculate partial expectations 709 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 710 const NativeHookFrame& nativeHookFrame = stream_.traceDataCache_->GetConstNativeHookFrameData(); 711 EXPECT_TRUE(0 == nativeHook.Size()); 712 EXPECT_TRUE(0 == nativeHookFrame.Size()); 713 714 auto eventCount = 715 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_FREE, STAT_EVENT_RECEIVED); 716 EXPECT_TRUE(2 == eventCount); 717 } 718 719 /** 720 * @tc.name: ParseBatchNativeHookWithOnePairsMallocAndFree 721 * @tc.desc: Parse a BatchNativeHookData with a pair of matching Malloc and Free Event 722 * @tc.type: FUNC 723 */ 724 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithOnePairsMallocAndFree, TestSize.Level1) 725 { 726 TS_LOGI("test24-6"); 727 // construct AllocEvent 728 AllocEvent* allocEvent = new AllocEvent(); 729 allocEvent->set_pid(PID); 730 allocEvent->set_tid(TID_01); 731 allocEvent->set_addr(MEM_ADDR_01); 732 allocEvent->set_size(MEM_SIZE_01); 733 // construct AllocEvent's Frame 734 auto allocframe = allocEvent->add_frame_info(); 735 allocframe->set_ip(CALL_STACK_IP_01); 736 allocframe->set_sp(CALL_STACK_SP_01); 737 allocframe->set_symbol_name(SYMBOL_NAME_01); 738 allocframe->set_file_path(FILE_PATH_01); 739 allocframe->set_offset(OFFSET_01); 740 allocframe->set_symbol_offset(SYMBOL_OFFSET_01); 741 742 // construct FreeEvent 743 FreeEvent* freeEvent = new FreeEvent(); 744 freeEvent->set_pid(PID); 745 freeEvent->set_tid(TID_02); 746 freeEvent->set_addr(MEM_ADDR_01); 747 // construct FreeEvent's Frame 748 auto freeframe = freeEvent->add_frame_info(); 749 freeframe->set_ip(CALL_STACK_IP_02); 750 freeframe->set_sp(CALL_STACK_SP_02); 751 freeframe->set_symbol_name(SYMBOL_NAME_02); 752 freeframe->set_file_path(FILE_PATH_02); 753 freeframe->set_offset(OFFSET_02); 754 freeframe->set_symbol_offset(SYMBOL_OFFSET_02); 755 756 // construct BatchNativeHookData 757 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 758 759 // add NativeHookData 760 auto nativeHookMallocData = batchNativeHookData->add_events(); 761 nativeHookMallocData->set_tv_sec(TV_SEC_01); 762 nativeHookMallocData->set_tv_nsec(TV_NSEC_01); 763 nativeHookMallocData->set_allocated_alloc_event(allocEvent); 764 auto nativeHookFreeData = batchNativeHookData->add_events(); 765 nativeHookFreeData->set_tv_sec(TV_SEC_02); 766 nativeHookFreeData->set_tv_nsec(TV_NSEC_02); 767 nativeHookFreeData->set_allocated_free_event(freeEvent); 768 769 // start parse 770 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 771 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 772 htraceNativeHookParser.FinishParseNativeHookData(); 773 774 // Verification parse Malloc event results 775 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 776 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 777 NativeHookCache firstExpectNativeHookCache(1, expect_ipid, expect_itid, ALLOCEVENT.c_str(), INVALID_UINT64, 778 TIMESTAMP_01, TIMESTAMP_02, TIMESTAMP_02 - TIMESTAMP_01, MEM_ADDR_01, 779 MEM_SIZE_01, MEM_SIZE_01, TIMESTAMP_02 - TIMESTAMP_01); 780 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 781 NativeHookCache firstResultNativeHookCache(nativeHook, 0); 782 EXPECT_TRUE(firstExpectNativeHookCache == firstResultNativeHookCache); 783 784 // Verification parse Malloc Frame results 785 const NativeHookFrame& nativeHookFrame = stream_.traceDataCache_->GetConstNativeHookFrameData(); 786 auto expectSymbolData = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_01); 787 auto expectFilePathData = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_01); 788 NativeHookFrameCache secondExpectFrameCache(1, 0, 0, 0, expectSymbolData, expectFilePathData, OFFSET_01, 789 SYMBOL_OFFSET_01); 790 NativeHookFrameCache secondResultFrameCache(nativeHookFrame, 0); 791 EXPECT_TRUE(secondExpectFrameCache == secondResultFrameCache); 792 793 // Verification parse Free event results 794 expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_02); 795 NativeHookCache expectNativeHookCache(2, expect_ipid, expect_itid, FREEEVENT.c_str(), INVALID_UINT64, TIMESTAMP_02, 796 0, 0, MEM_ADDR_01, MEM_SIZE_01, 0, 0); 797 NativeHookCache resultNativeHookCache(nativeHook, 1); 798 EXPECT_TRUE(expectNativeHookCache == resultNativeHookCache); 799 800 // Verification parse Free Event Frame results 801 expectSymbolData = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_02); 802 expectFilePathData = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_02); 803 NativeHookFrameCache expectFrameCache(2, 0, 0, 0, expectSymbolData, expectFilePathData, OFFSET_02, 804 SYMBOL_OFFSET_02); 805 NativeHookFrameCache resultFrameCache(nativeHookFrame, 1); 806 EXPECT_TRUE(expectFrameCache == resultFrameCache); 807 808 auto size = nativeHookFrame.Size(); 809 EXPECT_EQ(2, size); 810 811 auto eventCount = 812 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_FREE, STAT_EVENT_RECEIVED); 813 EXPECT_TRUE(1 == eventCount); 814 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MALLOC, STAT_EVENT_RECEIVED); 815 EXPECT_TRUE(1 == eventCount); 816 } 817 818 /** 819 * @tc.name: ParseBatchNativeHookWithNotMatchMallocAndFree 820 * @tc.desc: Parse a BatchNativeHookData with Not Match Malloc and Free Event 821 * @tc.type: FUNC 822 */ 823 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithNotMatchMallocAndFree, TestSize.Level1) 824 { 825 TS_LOGI("test24-7"); 826 // construct AllocEvent 827 AllocEvent* allocEvent = new AllocEvent(); 828 allocEvent->set_pid(PID); 829 allocEvent->set_tid(TID_01); 830 allocEvent->set_addr(MEM_ADDR_01); 831 allocEvent->set_size(MEM_SIZE_01); 832 // construct AllocEvent's Frame 833 auto allocframe = allocEvent->add_frame_info(); 834 allocframe->set_ip(CALL_STACK_IP_01); 835 allocframe->set_sp(CALL_STACK_SP_01); 836 allocframe->set_symbol_name(SYMBOL_NAME_01); 837 allocframe->set_file_path(FILE_PATH_01); 838 allocframe->set_offset(OFFSET_01); 839 allocframe->set_symbol_offset(SYMBOL_OFFSET_01); 840 841 // construct FreeEvent 842 FreeEvent* freeEvent = new FreeEvent(); 843 freeEvent->set_pid(PID); 844 freeEvent->set_tid(TID_02); 845 freeEvent->set_addr(MEM_ADDR_02); 846 auto freeframe = freeEvent->add_frame_info(); 847 // construct FreeEvent's Frame 848 freeframe->set_ip(CALL_STACK_IP_02); 849 freeframe->set_sp(CALL_STACK_SP_02); 850 freeframe->set_symbol_name(SYMBOL_NAME_02); 851 freeframe->set_file_path(FILE_PATH_02); 852 freeframe->set_offset(OFFSET_02); 853 freeframe->set_symbol_offset(SYMBOL_OFFSET_02); 854 855 // construct BatchNativeHookData 856 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 857 858 // add NativeHookData 859 auto nativeHookMallocData = batchNativeHookData->add_events(); 860 nativeHookMallocData->set_tv_sec(TV_SEC_01); 861 nativeHookMallocData->set_tv_nsec(TV_NSEC_01); 862 nativeHookMallocData->set_allocated_alloc_event(allocEvent); 863 auto nativeHookFreeData = batchNativeHookData->add_events(); 864 nativeHookFreeData->set_tv_sec(TV_SEC_02); 865 nativeHookFreeData->set_tv_nsec(TV_NSEC_02); 866 nativeHookFreeData->set_allocated_free_event(freeEvent); 867 868 // start parse 869 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 870 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 871 htraceNativeHookParser.FinishParseNativeHookData(); 872 873 // Verification parse Malloc event results 874 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 875 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 876 NativeHookCache firstExpectNativeHookCache(1, expect_ipid, expect_itid, ALLOCEVENT.c_str(), INVALID_UINT64, 877 TIMESTAMP_01, 0, 0, MEM_ADDR_01, MEM_SIZE_01, MEM_SIZE_01, 0); 878 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 879 NativeHookCache firstResultNativeHookCache(nativeHook, 0); 880 EXPECT_TRUE(firstExpectNativeHookCache == firstResultNativeHookCache); 881 882 // Verification parse Malloc Frame results 883 const NativeHookFrame& nativeHookFrame = stream_.traceDataCache_->GetConstNativeHookFrameData(); 884 auto expectSymbolData = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_01); 885 auto expectFilePathData = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_01); 886 NativeHookFrameCache firstExpectFrameCache(1, 0, 0, 0, expectSymbolData, expectFilePathData, OFFSET_01, 887 SYMBOL_OFFSET_01); 888 NativeHookFrameCache firstResultFrameCache(nativeHookFrame, 0); 889 EXPECT_TRUE(firstExpectFrameCache == firstResultFrameCache); 890 891 auto size = nativeHookFrame.Size(); 892 EXPECT_EQ(1, size); 893 894 auto eventCount = 895 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_FREE, STAT_EVENT_RECEIVED); 896 EXPECT_TRUE(1 == eventCount); 897 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MALLOC, STAT_EVENT_RECEIVED); 898 EXPECT_TRUE(1 == eventCount); 899 } 900 901 /** 902 * @tc.name: ParseTwoMallocAndFreeEventMatched 903 * @tc.desc: Parse a BatchNativeHookData with two Malloc and two Free Event, that Malloc and Free was matched. 904 * @tc.type: FUNC 905 */ 906 HWTEST_F(NativeHookParserTest, ParseTwoMallocAndFreeEventMatched, TestSize.Level1) 907 { 908 TS_LOGI("test24-8"); 909 // construct first AllocEvent 910 AllocEvent* firstAllocEvent = new AllocEvent(); 911 firstAllocEvent->set_pid(PID); 912 firstAllocEvent->set_tid(TID_01); 913 firstAllocEvent->set_addr(MEM_ADDR_01); 914 firstAllocEvent->set_size(MEM_SIZE_01); 915 916 // construct second AllocEvent 917 AllocEvent* secondAllocEvent = new AllocEvent(); 918 secondAllocEvent->set_pid(PID); 919 secondAllocEvent->set_tid(TID_02); 920 secondAllocEvent->set_addr(MEM_ADDR_02); 921 secondAllocEvent->set_size(MEM_SIZE_02); 922 923 // construct first FreeEvent 924 FreeEvent* firstFreeEvent = new FreeEvent(); 925 firstFreeEvent->set_pid(PID); 926 firstFreeEvent->set_tid(TID_01); 927 firstFreeEvent->set_addr(MEM_ADDR_01); 928 929 // construct second FreeEvent 930 FreeEvent* secondFreeEvent = new FreeEvent(); 931 secondFreeEvent->set_pid(PID); 932 secondFreeEvent->set_tid(TID_02); 933 secondFreeEvent->set_addr(MEM_ADDR_02); 934 935 // construct BatchNativeHookData 936 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 937 938 // add NativeHookData 939 auto firstMallocData = batchNativeHookData->add_events(); 940 firstMallocData->set_tv_sec(TV_SEC_01); 941 firstMallocData->set_tv_nsec(TV_NSEC_01); 942 firstMallocData->set_allocated_alloc_event(firstAllocEvent); 943 auto firstFreeData = batchNativeHookData->add_events(); 944 firstFreeData->set_tv_sec(TV_SEC_02); 945 firstFreeData->set_tv_nsec(TV_NSEC_02); 946 firstFreeData->set_allocated_free_event(firstFreeEvent); 947 auto secondMallocData = batchNativeHookData->add_events(); 948 secondMallocData->set_tv_sec(TV_SEC_03); 949 secondMallocData->set_tv_nsec(TV_NSEC_03); 950 secondMallocData->set_allocated_alloc_event(secondAllocEvent); 951 auto secondFreeData = batchNativeHookData->add_events(); 952 secondFreeData->set_tv_sec(TV_SEC_04); 953 secondFreeData->set_tv_nsec(TV_NSEC_04); 954 secondFreeData->set_allocated_free_event(secondFreeEvent); 955 956 // start parse 957 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 958 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 959 htraceNativeHookParser.FinishParseNativeHookData(); 960 961 // Verification parse first Malloc event results 962 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 963 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 964 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 965 NativeHookCache firstExpectMallocCache(INVALID_UINT64, expect_ipid, expect_itid, ALLOCEVENT.c_str(), INVALID_UINT64, 966 TIMESTAMP_01, TIMESTAMP_02, TIMESTAMP_02 - TIMESTAMP_01, MEM_ADDR_01, 967 MEM_SIZE_01, MEM_SIZE_01, TIMESTAMP_02 - TIMESTAMP_01); 968 NativeHookCache firstResultMallocCache(nativeHook, 0); 969 EXPECT_TRUE(firstExpectMallocCache == firstResultMallocCache); 970 971 // Verification parse first Free event results 972 NativeHookCache firstExpectFreeCache(INVALID_UINT64, expect_ipid, expect_itid, FREEEVENT.c_str(), 973 INVALID_UINT64, TIMESTAMP_02, 0, 0, MEM_ADDR_01, MEM_SIZE_01, 0, TIMESTAMP_03 - TIMESTAMP_02); 974 NativeHookCache firstResultFreeCache(nativeHook, 1); 975 EXPECT_TRUE(firstExpectFreeCache == firstResultFreeCache); 976 977 expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_02); 978 NativeHookCache secondExpectMallocCache(INVALID_UINT64, expect_ipid, expect_itid, ALLOCEVENT.c_str(), 979 INVALID_UINT64, TIMESTAMP_03, TIMESTAMP_04, TIMESTAMP_04 - TIMESTAMP_03, MEM_ADDR_02, 980 MEM_SIZE_02, MEM_SIZE_02, TIMESTAMP_04 - TIMESTAMP_03); 981 NativeHookCache secondResultMallocCache(nativeHook, 2); 982 EXPECT_TRUE(secondExpectMallocCache == secondResultMallocCache); 983 984 // Verification parse first Free event results 985 NativeHookCache secondExpectFreeCache(INVALID_UINT64, expect_ipid, expect_itid, FREEEVENT.c_str(), 986 INVALID_UINT64, TIMESTAMP_04, 0, 0, MEM_ADDR_02, MEM_SIZE_02, 0, 0); 987 NativeHookCache secondResultFreeCache(nativeHook, 3); 988 EXPECT_TRUE(secondExpectFreeCache == secondResultFreeCache); 989 990 auto eventCount = 991 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_FREE, STAT_EVENT_RECEIVED); 992 EXPECT_TRUE(2 == eventCount); 993 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MALLOC, STAT_EVENT_RECEIVED); 994 EXPECT_TRUE(2 == eventCount); 995 } 996 997 /** 998 * @tc.name: ParseTwoMallocAndFreeEventPartialMatched 999 * @tc.desc: Parse a BatchNativeHookData with two Malloc and two Free Event, that Malloc and Free was partial matched. 1000 * @tc.type: FUNC 1001 */ 1002 HWTEST_F(NativeHookParserTest, ParseTwoMallocAndFreeEventPartialMatched, TestSize.Level1) 1003 { 1004 TS_LOGI("test24-9"); 1005 // construct first AllocEvent 1006 AllocEvent* firstAllocEvent = new AllocEvent(); 1007 firstAllocEvent->set_pid(PID); 1008 firstAllocEvent->set_tid(TID_01); 1009 firstAllocEvent->set_addr(MEM_ADDR_01); 1010 firstAllocEvent->set_size(MEM_SIZE_01); 1011 1012 // construct second AllocEvent 1013 AllocEvent* secondAllocEvent = new AllocEvent(); 1014 secondAllocEvent->set_pid(PID); 1015 secondAllocEvent->set_tid(TID_02); 1016 secondAllocEvent->set_addr(MEM_ADDR_02); 1017 secondAllocEvent->set_size(MEM_SIZE_02); 1018 1019 // construct first FreeEvent 1020 FreeEvent* firstFreeEvent = new FreeEvent(); 1021 firstFreeEvent->set_pid(PID); 1022 firstFreeEvent->set_tid(TID_01); 1023 firstFreeEvent->set_addr(MEM_ADDR_01); 1024 1025 // construct second FreeEvent 1026 FreeEvent* secondFreeEvent = new FreeEvent(); 1027 secondFreeEvent->set_pid(PID); 1028 secondFreeEvent->set_tid(TID_02); 1029 secondFreeEvent->set_addr(MEM_ADDR_03); 1030 1031 // construct BatchNativeHookData 1032 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 1033 1034 // add NativeHookData 1035 auto firstMallocData = batchNativeHookData->add_events(); 1036 firstMallocData->set_tv_sec(TV_SEC_01); 1037 firstMallocData->set_tv_nsec(TV_NSEC_01); 1038 firstMallocData->set_allocated_alloc_event(firstAllocEvent); 1039 auto firstFreeData = batchNativeHookData->add_events(); 1040 firstFreeData->set_tv_sec(TV_SEC_02); 1041 firstFreeData->set_tv_nsec(TV_NSEC_02); 1042 firstFreeData->set_allocated_free_event(firstFreeEvent); 1043 auto secondMallocData = batchNativeHookData->add_events(); 1044 secondMallocData->set_tv_sec(TV_SEC_03); 1045 secondMallocData->set_tv_nsec(TV_NSEC_03); 1046 secondMallocData->set_allocated_alloc_event(secondAllocEvent); 1047 auto secondFreeData = batchNativeHookData->add_events(); 1048 secondFreeData->set_tv_sec(TV_SEC_04); 1049 secondFreeData->set_tv_nsec(TV_NSEC_04); 1050 secondFreeData->set_allocated_free_event(secondFreeEvent); 1051 1052 // start parse 1053 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1054 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 1055 htraceNativeHookParser.FinishParseNativeHookData(); 1056 1057 // Verification parse first Malloc event results 1058 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 1059 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 1060 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 1061 NativeHookCache firstExpectMallocCache(INVALID_UINT64, expect_ipid, expect_itid, ALLOCEVENT.c_str(), INVALID_UINT64, 1062 TIMESTAMP_01, TIMESTAMP_02, TIMESTAMP_02 - TIMESTAMP_01, MEM_ADDR_01, 1063 MEM_SIZE_01, MEM_SIZE_01, TIMESTAMP_02 - TIMESTAMP_01); 1064 NativeHookCache firstResultMallocCache(nativeHook, 0); 1065 EXPECT_TRUE(firstExpectMallocCache == firstResultMallocCache); 1066 1067 // Verification parse first Free event results 1068 NativeHookCache firstExpectFreeCache(INVALID_UINT64, expect_ipid, expect_itid, FREEEVENT.c_str(), 1069 INVALID_UINT64, TIMESTAMP_02, 0, 0, MEM_ADDR_01, MEM_SIZE_01, 0, TIMESTAMP_03 - TIMESTAMP_02); 1070 NativeHookCache firstResultFreeCache(nativeHook, 1); 1071 EXPECT_TRUE(firstExpectFreeCache == firstResultFreeCache); 1072 1073 // Verification parse second Malloc event results 1074 expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_02); 1075 NativeHookCache secondExpectMallocCache(INVALID_UINT64, expect_ipid, expect_itid, ALLOCEVENT.c_str(), 1076 INVALID_UINT64, TIMESTAMP_03, 0, 0, MEM_ADDR_02, MEM_SIZE_02, MEM_SIZE_02, 0); 1077 NativeHookCache secondResultMallocCache(nativeHook, 2); 1078 EXPECT_TRUE(secondExpectMallocCache == secondResultMallocCache); 1079 1080 auto eventCount = 1081 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_FREE, STAT_EVENT_RECEIVED); 1082 EXPECT_TRUE(2 == eventCount); 1083 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MALLOC, STAT_EVENT_RECEIVED); 1084 EXPECT_TRUE(2 == eventCount); 1085 } 1086 1087 /** 1088 * @tc.name: ParseBatchNativeHookWithOneMmap 1089 * @tc.desc: Parse a BatchNativeHookData with only one MMAP 1090 * @tc.type: FUNC 1091 */ 1092 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithOneMmap, TestSize.Level1) 1093 { 1094 TS_LOGI("test24-10"); 1095 // construct MmapEvent 1096 MmapEvent* mmapEvent = new MmapEvent(); 1097 mmapEvent->set_pid(PID); 1098 mmapEvent->set_tid(TID_01); 1099 mmapEvent->set_addr(MEM_ADDR_01); 1100 mmapEvent->set_size(MEM_SIZE_01); 1101 mmapEvent->set_type(MMAP_SUB_TYPE_01); 1102 // construct MmapEvent's Frame 1103 auto frame = mmapEvent->add_frame_info(); 1104 frame->set_ip(CALL_STACK_IP_01); 1105 frame->set_sp(CALL_STACK_SP_01); 1106 frame->set_symbol_name(SYMBOL_NAME_01); 1107 frame->set_file_path(FILE_PATH_01); 1108 frame->set_offset(OFFSET_01); 1109 frame->set_symbol_offset(SYMBOL_OFFSET_01); 1110 1111 // construct BatchNativeHookData 1112 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 1113 1114 // add NativeHookData 1115 auto nativeHookData = batchNativeHookData->add_events(); 1116 nativeHookData->set_tv_sec(TV_SEC_01); 1117 nativeHookData->set_tv_nsec(TV_NSEC_01); 1118 nativeHookData->set_allocated_mmap_event(mmapEvent); 1119 1120 // start parse 1121 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1122 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 1123 htraceNativeHookParser.FinishParseNativeHookData(); 1124 1125 // Verification parse NativeHook results 1126 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 1127 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 1128 auto mmapSubType = stream_.traceDataCache_->dataDict_.GetStringIndex(MMAP_SUB_TYPE_01); 1129 NativeHookCache expectNativeHookCache(1, expect_ipid, expect_itid, MMAPEVENT.c_str(), mmapSubType, TIMESTAMP_01, 0, 1130 0, MEM_ADDR_01, MEM_SIZE_01, MEM_SIZE_01, 0); 1131 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 1132 NativeHookCache resultNativeHookCache(nativeHook, 0); 1133 EXPECT_TRUE(expectNativeHookCache == resultNativeHookCache); 1134 1135 auto size = stream_.traceDataCache_->GetConstNativeHookData().Size(); 1136 EXPECT_EQ(1, size); 1137 1138 // Verification parse NativeHook Frame results 1139 const NativeHookFrame& nativeHookFrame = stream_.traceDataCache_->GetConstNativeHookFrameData(); 1140 auto expectSymbolData = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_01); 1141 auto expectFilePathData = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_01); 1142 NativeHookFrameCache expectFrameCache(1, 0, 0, 0, expectSymbolData, expectFilePathData, OFFSET_01, 1143 SYMBOL_OFFSET_01); 1144 NativeHookFrameCache resultFrameCache(nativeHookFrame, 0); 1145 EXPECT_TRUE(expectFrameCache == resultFrameCache); 1146 1147 size = nativeHookFrame.Size(); 1148 EXPECT_EQ(1, size); 1149 1150 auto eventCount = 1151 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MMAP, STAT_EVENT_RECEIVED); 1152 EXPECT_TRUE(1 == eventCount); 1153 } 1154 1155 /** 1156 * @tc.name: ParseBatchNativeHookWithOneMunmap 1157 * @tc.desc: Parse a BatchNativeHookData with only one MMAP 1158 * @tc.type: FUNC 1159 */ 1160 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithOneMunmap, TestSize.Level1) 1161 { 1162 TS_LOGI("test24-11"); 1163 // construct MunmapEvent 1164 MunmapEvent* munmapEvent = new MunmapEvent(); 1165 munmapEvent->set_pid(PID); 1166 munmapEvent->set_tid(TID_01); 1167 munmapEvent->set_addr(MEM_ADDR_01); 1168 munmapEvent->set_size(MEM_SIZE_01); 1169 // construct MunmapEvent's Frame 1170 auto frame = munmapEvent->add_frame_info(); 1171 frame->set_ip(CALL_STACK_IP_01); 1172 frame->set_sp(CALL_STACK_SP_01); 1173 frame->set_symbol_name(SYMBOL_NAME_01); 1174 frame->set_file_path(FILE_PATH_01); 1175 frame->set_offset(OFFSET_01); 1176 frame->set_symbol_offset(SYMBOL_OFFSET_01); 1177 1178 // construct BatchNativeHookData 1179 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 1180 1181 // add NativeHookData 1182 auto nativeHookData = batchNativeHookData->add_events(); 1183 nativeHookData->set_tv_sec(TV_SEC_01); 1184 nativeHookData->set_tv_nsec(TV_NSEC_01); 1185 nativeHookData->set_allocated_munmap_event(munmapEvent); 1186 1187 // start parse 1188 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1189 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 1190 htraceNativeHookParser.FinishParseNativeHookData(); 1191 1192 auto size = stream_.traceDataCache_->GetConstNativeHookData().Size(); 1193 EXPECT_EQ(0, size); 1194 1195 // Verification parse NativeHook Frame results 1196 const NativeHookFrame& nativeHookFrame = stream_.traceDataCache_->GetConstNativeHookFrameData(); 1197 1198 size = nativeHookFrame.Size(); 1199 EXPECT_EQ(0, size); 1200 1201 auto eventCount = 1202 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MUNMAP, STAT_EVENT_RECEIVED); 1203 EXPECT_TRUE(1 == eventCount); 1204 } 1205 1206 /** 1207 * @tc.name: ParseBatchNativeHookWithMultipleMmap 1208 * @tc.desc: Parse a BatchNativeHookData with multiple MMAP 1209 * @tc.type: FUNC 1210 */ 1211 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithMultipleMmap, TestSize.Level1) 1212 { 1213 TS_LOGI("test24-12"); 1214 // construct first MmapEvent 1215 MmapEvent* firstMmapEvent = new MmapEvent(); 1216 firstMmapEvent->set_pid(PID); 1217 firstMmapEvent->set_tid(TID_01); 1218 firstMmapEvent->set_addr(MEM_ADDR_01); 1219 firstMmapEvent->set_size(MEM_SIZE_01); 1220 firstMmapEvent->set_type(MMAP_SUB_TYPE_01); 1221 // construct first MmapEvent's Frame 1222 auto firstFrame = firstMmapEvent->add_frame_info(); 1223 firstFrame->set_ip(CALL_STACK_IP_01); 1224 firstFrame->set_sp(CALL_STACK_SP_01); 1225 firstFrame->set_symbol_name(SYMBOL_NAME_01); 1226 firstFrame->set_file_path(FILE_PATH_01); 1227 firstFrame->set_offset(OFFSET_01); 1228 firstFrame->set_symbol_offset(SYMBOL_OFFSET_01); 1229 1230 // construct second MmapEvent 1231 MmapEvent* secondMmapEvent = new MmapEvent(); 1232 secondMmapEvent->set_pid(PID); 1233 secondMmapEvent->set_tid(TID_02); 1234 secondMmapEvent->set_addr(MEM_ADDR_02); 1235 secondMmapEvent->set_size(MEM_SIZE_02); 1236 secondMmapEvent->set_type(MMAP_SUB_TYPE_02); 1237 // construct second MmapEvent's Frame 1238 auto secondFrame = secondMmapEvent->add_frame_info(); 1239 secondFrame->set_ip(CALL_STACK_IP_02); 1240 secondFrame->set_sp(CALL_STACK_SP_02); 1241 secondFrame->set_symbol_name(SYMBOL_NAME_02); 1242 secondFrame->set_file_path(FILE_PATH_02); 1243 secondFrame->set_offset(OFFSET_02); 1244 secondFrame->set_symbol_offset(SYMBOL_OFFSET_02); 1245 1246 // construct BatchNativeHookData 1247 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 1248 1249 // add NativeHookData 1250 auto firstNativeHookData = batchNativeHookData->add_events(); 1251 firstNativeHookData->set_tv_sec(TV_SEC_01); 1252 firstNativeHookData->set_tv_nsec(TV_NSEC_01); 1253 firstNativeHookData->set_allocated_mmap_event(firstMmapEvent); 1254 auto secondNativeHookData = batchNativeHookData->add_events(); 1255 secondNativeHookData->set_tv_sec(TV_SEC_02); 1256 secondNativeHookData->set_tv_nsec(TV_NSEC_02); 1257 secondNativeHookData->set_allocated_mmap_event(secondMmapEvent); 1258 1259 // start parse 1260 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1261 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 1262 htraceNativeHookParser.FinishParseNativeHookData(); 1263 1264 // Verification parse NativeHook results 1265 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 1266 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 1267 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 1268 auto mmapSubType = stream_.traceDataCache_->dataDict_.GetStringIndex(MMAP_SUB_TYPE_01); 1269 1270 NativeHookCache firstExpectNativeHookCache(1, expect_ipid, expect_itid, MMAPEVENT.c_str(), mmapSubType, 1271 TIMESTAMP_01, 0, 0, MEM_ADDR_01, MEM_SIZE_01, MEM_SIZE_01, 1272 TIMESTAMP_02 - TIMESTAMP_01); 1273 NativeHookCache firstResultNativeHookCache(nativeHook, 0); 1274 EXPECT_TRUE(firstExpectNativeHookCache == firstResultNativeHookCache); 1275 1276 expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_02); 1277 mmapSubType = stream_.traceDataCache_->dataDict_.GetStringIndex(MMAP_SUB_TYPE_02); 1278 NativeHookCache secondExpectNativeHookCache(2, expect_ipid, expect_itid, MMAPEVENT.c_str(), mmapSubType, 1279 TIMESTAMP_02, 0, 0, MEM_ADDR_02, MEM_SIZE_02, MEM_SIZE_01 + MEM_SIZE_02, 1280 0); 1281 NativeHookCache secondResultNativeHookCache(nativeHook, 1); 1282 EXPECT_TRUE(secondExpectNativeHookCache == secondResultNativeHookCache); 1283 auto size = stream_.traceDataCache_->GetConstNativeHookData().Size(); 1284 EXPECT_EQ(2, size); 1285 1286 // Verification parse NativeHook Frame results 1287 const NativeHookFrame& nativeHookFrame = stream_.traceDataCache_->GetConstNativeHookFrameData(); 1288 auto expectSymbolData = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_01); 1289 auto expectFilePathData = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_01); 1290 NativeHookFrameCache firstExpectFrameCache(1, 0, 0, 0, expectSymbolData, expectFilePathData, OFFSET_01, 1291 SYMBOL_OFFSET_01); 1292 NativeHookFrameCache firstResultFrameCache(nativeHookFrame, 0); 1293 EXPECT_TRUE(firstExpectFrameCache == firstResultFrameCache); 1294 1295 expectSymbolData = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_02); 1296 expectFilePathData = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_02); 1297 NativeHookFrameCache expectFrameCache(2, 0, 0, 0, expectSymbolData, expectFilePathData, OFFSET_02, 1298 SYMBOL_OFFSET_02); 1299 NativeHookFrameCache resultFrameCache(nativeHookFrame, 1); 1300 EXPECT_TRUE(expectFrameCache == resultFrameCache); 1301 1302 size = nativeHookFrame.Size(); 1303 EXPECT_EQ(2, size); 1304 1305 auto eventCount = 1306 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MMAP, STAT_EVENT_RECEIVED); 1307 EXPECT_TRUE(2 == eventCount); 1308 } 1309 1310 /** 1311 * @tc.name: ParseBatchNativeHookWithMultipleMunmap 1312 * @tc.desc: Parse a BatchNativeHookData with multiple munmap 1313 * @tc.type: FUNC 1314 */ 1315 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithMultipleMunmap, TestSize.Level1) 1316 { 1317 TS_LOGI("test24-13"); 1318 // construct first MunmapEvent 1319 MunmapEvent* firstMunmapEvent = new MunmapEvent(); 1320 firstMunmapEvent->set_pid(PID); 1321 firstMunmapEvent->set_tid(TID_01); 1322 firstMunmapEvent->set_addr(MEM_ADDR_01); 1323 firstMunmapEvent->set_size(MEM_SIZE_01); 1324 // construct MunmapEvent's Frame 1325 auto firstFrame = firstMunmapEvent->add_frame_info(); 1326 firstFrame->set_ip(CALL_STACK_IP_01); 1327 firstFrame->set_sp(CALL_STACK_SP_01); 1328 firstFrame->set_symbol_name(SYMBOL_NAME_01); 1329 firstFrame->set_file_path(FILE_PATH_01); 1330 firstFrame->set_offset(OFFSET_01); 1331 firstFrame->set_symbol_offset(SYMBOL_OFFSET_01); 1332 1333 // construct second MunmapEvent 1334 MunmapEvent* secondMunmapEvent = new MunmapEvent(); 1335 secondMunmapEvent->set_pid(PID); 1336 secondMunmapEvent->set_tid(TID_02); 1337 secondMunmapEvent->set_addr(MEM_ADDR_02); 1338 secondMunmapEvent->set_size(MEM_SIZE_02); 1339 // construct MunmapEvent's Frame 1340 auto secondFrame = secondMunmapEvent->add_frame_info(); 1341 secondFrame->set_ip(CALL_STACK_IP_02); 1342 secondFrame->set_sp(CALL_STACK_SP_02); 1343 secondFrame->set_symbol_name(SYMBOL_NAME_02); 1344 secondFrame->set_file_path(FILE_PATH_02); 1345 secondFrame->set_offset(OFFSET_02); 1346 secondFrame->set_symbol_offset(SYMBOL_OFFSET_02); 1347 1348 // construct BatchNativeHookData 1349 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 1350 1351 // add NativeHookData 1352 auto firstNativeHookData = batchNativeHookData->add_events(); 1353 firstNativeHookData->set_tv_sec(TV_SEC_01); 1354 firstNativeHookData->set_tv_nsec(TV_NSEC_01); 1355 firstNativeHookData->set_allocated_munmap_event(firstMunmapEvent); 1356 auto secondNativeHookData = batchNativeHookData->add_events(); 1357 secondNativeHookData->set_tv_sec(TV_SEC_02); 1358 secondNativeHookData->set_tv_nsec(TV_NSEC_02); 1359 secondNativeHookData->set_allocated_munmap_event(secondMunmapEvent); 1360 1361 // start parse 1362 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1363 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 1364 htraceNativeHookParser.FinishParseNativeHookData(); 1365 1366 auto size = stream_.traceDataCache_->GetConstNativeHookData().Size(); 1367 EXPECT_EQ(0, size); 1368 1369 // Verification parse NativeHook Frame results 1370 const NativeHookFrame& nativeHookFrame = stream_.traceDataCache_->GetConstNativeHookFrameData(); 1371 1372 size = nativeHookFrame.Size(); 1373 EXPECT_EQ(0, size); 1374 1375 auto eventCount = 1376 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MUNMAP, STAT_EVENT_RECEIVED); 1377 EXPECT_TRUE(2 == eventCount); 1378 } 1379 1380 /** 1381 * @tc.name: ParseOnePairsMmapAndMunmapEvent 1382 * @tc.desc: Parse a BatchNativeHookData with one pairs Mmap and MunmapEvent 1383 * @tc.type: FUNC 1384 */ 1385 HWTEST_F(NativeHookParserTest, ParseOnePairsMmapAndMunmapEvent, TestSize.Level1) 1386 { 1387 TS_LOGI("test24-14"); 1388 // construct MmapEvent 1389 MmapEvent* mmapEvent = new MmapEvent(); 1390 mmapEvent->set_pid(PID); 1391 mmapEvent->set_tid(TID_01); 1392 mmapEvent->set_addr(MEM_ADDR_01); 1393 mmapEvent->set_size(MEM_SIZE_01); 1394 mmapEvent->set_type(MMAP_SUB_TYPE_01); 1395 // construct MmapEvent's Frame 1396 auto firstFrame = mmapEvent->add_frame_info(); 1397 firstFrame->set_ip(CALL_STACK_IP_01); 1398 firstFrame->set_sp(CALL_STACK_SP_01); 1399 firstFrame->set_symbol_name(SYMBOL_NAME_01); 1400 firstFrame->set_file_path(FILE_PATH_01); 1401 firstFrame->set_offset(OFFSET_01); 1402 firstFrame->set_symbol_offset(SYMBOL_OFFSET_01); 1403 auto secondFrame = mmapEvent->add_frame_info(); 1404 secondFrame->set_ip(CALL_STACK_IP_02); 1405 secondFrame->set_sp(CALL_STACK_SP_02); 1406 secondFrame->set_symbol_name(SYMBOL_NAME_02); 1407 secondFrame->set_file_path(FILE_PATH_02); 1408 secondFrame->set_offset(OFFSET_02); 1409 secondFrame->set_symbol_offset(SYMBOL_OFFSET_02); 1410 1411 // construct first MunmapEvent 1412 MunmapEvent* munmapEvent = new MunmapEvent(); 1413 munmapEvent->set_pid(PID); 1414 munmapEvent->set_tid(TID_01); 1415 munmapEvent->set_addr(MEM_ADDR_01); 1416 munmapEvent->set_size(MEM_SIZE_01); 1417 1418 // construct BatchNativeHookData 1419 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 1420 1421 // add NativeHookData 1422 auto nativeHookMmapData = batchNativeHookData->add_events(); 1423 nativeHookMmapData->set_tv_sec(TV_SEC_01); 1424 nativeHookMmapData->set_tv_nsec(TV_NSEC_01); 1425 nativeHookMmapData->set_allocated_mmap_event(mmapEvent); 1426 auto nativeHookMunmapData = batchNativeHookData->add_events(); 1427 nativeHookMunmapData->set_tv_sec(TV_SEC_02); 1428 nativeHookMunmapData->set_tv_nsec(TV_NSEC_02); 1429 nativeHookMunmapData->set_allocated_munmap_event(munmapEvent); 1430 1431 // start parse 1432 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1433 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 1434 htraceNativeHookParser.FinishParseNativeHookData(); 1435 1436 // Verification parse NativeHook results 1437 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 1438 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 1439 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 1440 auto mmapSubType = stream_.traceDataCache_->dataDict_.GetStringIndex(MMAP_SUB_TYPE_01); 1441 NativeHookCache firstExpectNativeHookCache(1, expect_ipid, expect_itid, MMAPEVENT.c_str(), mmapSubType, 1442 TIMESTAMP_01, TIMESTAMP_02, TIMESTAMP_02 - TIMESTAMP_01, MEM_ADDR_01, 1443 MEM_SIZE_01, MEM_SIZE_01, TIMESTAMP_02 - TIMESTAMP_01); 1444 NativeHookCache firstResultNativeHookCache(nativeHook, 0); 1445 EXPECT_TRUE(firstExpectNativeHookCache == firstResultNativeHookCache); 1446 1447 NativeHookCache secondExpectNativeHookCache(INVALID_UINT64, expect_ipid, expect_itid, MUNMAPEVENT.c_str(), 1448 INVALID_UINT64, TIMESTAMP_02, 0, 0, MEM_ADDR_01, MEM_SIZE_01, 0, 0); 1449 NativeHookCache secondResultNativeHookCache(nativeHook, 1); 1450 EXPECT_TRUE(secondExpectNativeHookCache == secondResultNativeHookCache); 1451 1452 auto size = stream_.traceDataCache_->GetConstNativeHookData().Size(); 1453 EXPECT_EQ(2, size); 1454 1455 // Verification parse NativeHook Frame results 1456 const NativeHookFrame& nativeHookFrame = stream_.traceDataCache_->GetConstNativeHookFrameData(); 1457 auto expectSymbolData = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_02); 1458 auto expectFilePathData = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_02); 1459 NativeHookFrameCache firstExpectFrameCache(1, 0, 0, 0, expectSymbolData, expectFilePathData, OFFSET_02, 1460 SYMBOL_OFFSET_02); 1461 NativeHookFrameCache firstResultFrameCache(nativeHookFrame, 0); 1462 EXPECT_TRUE(firstExpectFrameCache == firstResultFrameCache); 1463 1464 expectSymbolData = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_01); 1465 expectFilePathData = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_01); 1466 NativeHookFrameCache secondExpectFrameCache(1, 1, 0, 0, expectSymbolData, expectFilePathData, OFFSET_01, 1467 SYMBOL_OFFSET_01); 1468 NativeHookFrameCache secondResultFrameCache(nativeHookFrame, 1); 1469 EXPECT_TRUE(secondExpectFrameCache == secondResultFrameCache); 1470 1471 size = nativeHookFrame.Size(); 1472 EXPECT_EQ(2, size); 1473 1474 auto eventCount = 1475 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MMAP, STAT_EVENT_RECEIVED); 1476 EXPECT_TRUE(1 == eventCount); 1477 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MUNMAP, STAT_EVENT_RECEIVED); 1478 EXPECT_TRUE(1 == eventCount); 1479 } 1480 1481 /** 1482 * @tc.name: ParseNotMatchMmapAndMunmapEvent 1483 * @tc.desc: Parse a BatchNativeHookData with not match Mmap and MunmapEvent 1484 * @tc.type: FUNC 1485 */ 1486 HWTEST_F(NativeHookParserTest, ParseNotMatchMmapAndMunmapEvent, TestSize.Level1) 1487 { 1488 TS_LOGI("test24-15"); 1489 // construct MmapEvent 1490 MmapEvent* mmapEvent = new MmapEvent(); 1491 mmapEvent->set_pid(PID); 1492 mmapEvent->set_tid(TID_01); 1493 mmapEvent->set_addr(MEM_ADDR_01); 1494 mmapEvent->set_size(MEM_SIZE_01); 1495 mmapEvent->set_type(MMAP_SUB_TYPE_01); 1496 // construct MmapEvent's Frame 1497 auto firstFrame = mmapEvent->add_frame_info(); 1498 firstFrame->set_ip(CALL_STACK_IP_01); 1499 firstFrame->set_sp(CALL_STACK_SP_01); 1500 firstFrame->set_symbol_name(SYMBOL_NAME_01); 1501 firstFrame->set_file_path(FILE_PATH_01); 1502 firstFrame->set_offset(OFFSET_01); 1503 firstFrame->set_symbol_offset(SYMBOL_OFFSET_01); 1504 auto secondFrame = mmapEvent->add_frame_info(); 1505 secondFrame->set_ip(CALL_STACK_IP_02); 1506 secondFrame->set_sp(CALL_STACK_SP_02); 1507 secondFrame->set_symbol_name(SYMBOL_NAME_02); 1508 secondFrame->set_file_path(FILE_PATH_02); 1509 secondFrame->set_offset(OFFSET_02); 1510 secondFrame->set_symbol_offset(SYMBOL_OFFSET_02); 1511 1512 // construct MunmapEvent 1513 MunmapEvent* munmapEvent = new MunmapEvent(); 1514 munmapEvent->set_pid(PID); 1515 munmapEvent->set_tid(TID_01); 1516 munmapEvent->set_addr(MEM_ADDR_02); 1517 munmapEvent->set_size(MEM_SIZE_01); 1518 1519 // construct BatchNativeHookData 1520 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 1521 1522 // add NativeHookData 1523 auto nativeHookMmapData = batchNativeHookData->add_events(); 1524 nativeHookMmapData->set_tv_sec(TV_SEC_01); 1525 nativeHookMmapData->set_tv_nsec(TV_NSEC_01); 1526 nativeHookMmapData->set_allocated_mmap_event(mmapEvent); 1527 auto nativeHookMunmapData = batchNativeHookData->add_events(); 1528 nativeHookMunmapData->set_tv_sec(TV_SEC_02); 1529 nativeHookMunmapData->set_tv_nsec(TV_NSEC_02); 1530 nativeHookMunmapData->set_allocated_munmap_event(munmapEvent); 1531 1532 // start parse 1533 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1534 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 1535 htraceNativeHookParser.FinishParseNativeHookData(); 1536 1537 // Verification parse NativeHook results 1538 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 1539 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 1540 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 1541 auto mmapSubType = stream_.traceDataCache_->dataDict_.GetStringIndex(MMAP_SUB_TYPE_01); 1542 NativeHookCache firstExpectNativeHookCache(1, expect_ipid, expect_itid, MMAPEVENT.c_str(), mmapSubType, 1543 TIMESTAMP_01, 0, 0, MEM_ADDR_01, MEM_SIZE_01, MEM_SIZE_01, 0); 1544 NativeHookCache firstResultNativeHookCache(nativeHook, 0); 1545 EXPECT_TRUE(firstExpectNativeHookCache == firstResultNativeHookCache); 1546 1547 auto size = stream_.traceDataCache_->GetConstNativeHookData().Size(); 1548 EXPECT_EQ(1, size); 1549 1550 // Verification parse NativeHook Frame results 1551 const NativeHookFrame& nativeHookFrame = stream_.traceDataCache_->GetConstNativeHookFrameData(); 1552 auto expectSymbolData = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_02); 1553 auto expectFilePathData = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_02); 1554 NativeHookFrameCache firstExpectFrameCache(1, 0, 0, 0, expectSymbolData, expectFilePathData, OFFSET_02, 1555 SYMBOL_OFFSET_02); 1556 NativeHookFrameCache firstResultFrameCache(nativeHookFrame, 0); 1557 EXPECT_TRUE(firstExpectFrameCache == firstResultFrameCache); 1558 1559 expectSymbolData = stream_.traceDataCache_->dataDict_.GetStringIndex(SYMBOL_NAME_01); 1560 expectFilePathData = stream_.traceDataCache_->dataDict_.GetStringIndex(FILE_PATH_01); 1561 NativeHookFrameCache secondExpectFrameCache(1, 1, 0, 0, expectSymbolData, expectFilePathData, OFFSET_01, 1562 SYMBOL_OFFSET_01); 1563 NativeHookFrameCache secondResultFrameCache(nativeHookFrame, 1); 1564 EXPECT_TRUE(secondExpectFrameCache == secondResultFrameCache); 1565 1566 size = nativeHookFrame.Size(); 1567 EXPECT_EQ(2, size); 1568 1569 auto eventCount = 1570 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MMAP, STAT_EVENT_RECEIVED); 1571 EXPECT_TRUE(1 == eventCount); 1572 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MUNMAP, STAT_EVENT_RECEIVED); 1573 EXPECT_TRUE(1 == eventCount); 1574 } 1575 1576 /** 1577 * @tc.name: ParseTwoPairsMatchedMmapAndMunmapEvent 1578 * @tc.desc: Parse a BatchNativeHookData with two pairs matched Mmap and MunmapEvent 1579 * @tc.type: FUNC 1580 */ 1581 HWTEST_F(NativeHookParserTest, ParseTwoPairsMatchedMmapAndMunmapEvent, TestSize.Level1) 1582 { 1583 TS_LOGI("test24-16"); 1584 // construct first MmapEvent 1585 MmapEvent* firstMmapEvent = new MmapEvent(); 1586 firstMmapEvent->set_pid(PID); 1587 firstMmapEvent->set_tid(TID_01); 1588 firstMmapEvent->set_addr(MEM_ADDR_01); 1589 firstMmapEvent->set_size(MEM_SIZE_01); 1590 firstMmapEvent->set_type(MMAP_SUB_TYPE_01); 1591 // construct second MmapEvent 1592 MmapEvent* secondMmapEvent = new MmapEvent(); 1593 secondMmapEvent->set_pid(PID); 1594 secondMmapEvent->set_tid(TID_02); 1595 secondMmapEvent->set_addr(MEM_ADDR_02); 1596 secondMmapEvent->set_size(MEM_SIZE_02); 1597 secondMmapEvent->set_type(MMAP_SUB_TYPE_02); 1598 1599 // construct first MunmapEvent 1600 MunmapEvent* firstMunmapEvent = new MunmapEvent(); 1601 firstMunmapEvent->set_pid(PID); 1602 firstMunmapEvent->set_tid(TID_01); 1603 firstMunmapEvent->set_addr(MEM_ADDR_01); 1604 firstMunmapEvent->set_size(MEM_SIZE_01); 1605 // construct second MunmapEvent 1606 MunmapEvent* secondMunmapEvent = new MunmapEvent(); 1607 secondMunmapEvent->set_pid(PID); 1608 secondMunmapEvent->set_tid(TID_02); 1609 secondMunmapEvent->set_addr(MEM_ADDR_02); 1610 secondMunmapEvent->set_size(MEM_SIZE_02); 1611 1612 // construct BatchNativeHookData 1613 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 1614 1615 // add NativeHookData 1616 auto firstNativeHookMmapData = batchNativeHookData->add_events(); 1617 firstNativeHookMmapData->set_tv_sec(TV_SEC_01); 1618 firstNativeHookMmapData->set_tv_nsec(TV_NSEC_01); 1619 firstNativeHookMmapData->set_allocated_mmap_event(firstMmapEvent); 1620 auto firstNativeHookMunmapData = batchNativeHookData->add_events(); 1621 firstNativeHookMunmapData->set_tv_sec(TV_SEC_02); 1622 firstNativeHookMunmapData->set_tv_nsec(TV_NSEC_02); 1623 firstNativeHookMunmapData->set_allocated_munmap_event(firstMunmapEvent); 1624 auto secondNativeHookMmapData = batchNativeHookData->add_events(); 1625 secondNativeHookMmapData->set_tv_sec(TV_SEC_03); 1626 secondNativeHookMmapData->set_tv_nsec(TV_NSEC_03); 1627 secondNativeHookMmapData->set_allocated_mmap_event(secondMmapEvent); 1628 auto secondNativeHookMunmapData = batchNativeHookData->add_events(); 1629 secondNativeHookMunmapData->set_tv_sec(TV_SEC_04); 1630 secondNativeHookMunmapData->set_tv_nsec(TV_NSEC_04); 1631 secondNativeHookMunmapData->set_allocated_munmap_event(secondMunmapEvent); 1632 1633 // start parse 1634 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1635 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 1636 htraceNativeHookParser.FinishParseNativeHookData(); 1637 1638 // Verification parse NativeHook results 1639 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 1640 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 1641 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 1642 auto mmapSubType = stream_.traceDataCache_->dataDict_.GetStringIndex(MMAP_SUB_TYPE_01); 1643 NativeHookCache firstExpectNativeHookCache(INVALID_UINT64, expect_ipid, expect_itid, MMAPEVENT.c_str(), mmapSubType, 1644 TIMESTAMP_01, TIMESTAMP_02, TIMESTAMP_02 - TIMESTAMP_01, MEM_ADDR_01, 1645 MEM_SIZE_01, MEM_SIZE_01, TIMESTAMP_02 - TIMESTAMP_01); 1646 NativeHookCache firstResultNativeHookCache(nativeHook, 0); 1647 EXPECT_TRUE(firstExpectNativeHookCache == firstResultNativeHookCache); 1648 1649 NativeHookCache secondExpectNativeHookCache(INVALID_UINT64, expect_ipid, expect_itid, MUNMAPEVENT.c_str(), 1650 INVALID_UINT64, TIMESTAMP_02, 0, 0, MEM_ADDR_01, MEM_SIZE_01, 0, 1651 TIMESTAMP_03 - TIMESTAMP_02); 1652 NativeHookCache secondResultNativeHookCache(nativeHook, 1); 1653 EXPECT_TRUE(secondExpectNativeHookCache == secondResultNativeHookCache); 1654 1655 expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_02); 1656 mmapSubType = stream_.traceDataCache_->dataDict_.GetStringIndex(MMAP_SUB_TYPE_02); 1657 NativeHookCache thirdExpectNativeHookCache(INVALID_UINT64, expect_ipid, expect_itid, MMAPEVENT.c_str(), mmapSubType, 1658 TIMESTAMP_03, TIMESTAMP_04, TIMESTAMP_04 - TIMESTAMP_03, MEM_ADDR_02, 1659 MEM_SIZE_02, MEM_SIZE_02, TIMESTAMP_04 - TIMESTAMP_03); 1660 NativeHookCache thirdResultNativeHookCache(nativeHook, 2); 1661 EXPECT_TRUE(thirdExpectNativeHookCache == thirdResultNativeHookCache); 1662 1663 NativeHookCache fourthExpectNativeHookCache(INVALID_UINT64, expect_ipid, expect_itid, MUNMAPEVENT.c_str(), 1664 INVALID_UINT64, TIMESTAMP_04, 0, 0, MEM_ADDR_02, MEM_SIZE_02, 0, 0); 1665 NativeHookCache fourthResultNativeHookCache(nativeHook, 3); 1666 EXPECT_TRUE(secondExpectNativeHookCache == secondResultNativeHookCache); 1667 1668 auto size = stream_.traceDataCache_->GetConstNativeHookData().Size(); 1669 EXPECT_EQ(4, size); 1670 1671 auto eventCount = 1672 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MMAP, STAT_EVENT_RECEIVED); 1673 EXPECT_TRUE(2 == eventCount); 1674 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MUNMAP, STAT_EVENT_RECEIVED); 1675 EXPECT_TRUE(2 == eventCount); 1676 } 1677 1678 /** 1679 * @tc.name: ParsePartialMatchedMmapAndMunmapEvent 1680 * @tc.desc: Parse a BatchNativeHookData with partial matched Mmap and MunmapEvent 1681 * @tc.type: FUNC 1682 */ 1683 HWTEST_F(NativeHookParserTest, ParsePartialMatchedMmapAndMunmapEvent, TestSize.Level1) 1684 { 1685 TS_LOGI("test24-17"); 1686 // construct AllocEvent 1687 MmapEvent* firstMmapEvent = new MmapEvent(); 1688 firstMmapEvent->set_pid(PID); 1689 firstMmapEvent->set_tid(TID_01); 1690 firstMmapEvent->set_addr(MEM_ADDR_01); 1691 firstMmapEvent->set_size(MEM_SIZE_01); 1692 firstMmapEvent->set_type(MMAP_SUB_TYPE_01); 1693 MmapEvent* secondMmapEvent = new MmapEvent(); 1694 secondMmapEvent->set_pid(PID); 1695 secondMmapEvent->set_tid(TID_02); 1696 secondMmapEvent->set_addr(MEM_ADDR_02); 1697 secondMmapEvent->set_size(MEM_SIZE_02); 1698 secondMmapEvent->set_type(MMAP_SUB_TYPE_02); 1699 1700 // construct first MunmapEvent 1701 MunmapEvent* firstMunmapEvent = new MunmapEvent(); 1702 firstMunmapEvent->set_pid(PID); 1703 firstMunmapEvent->set_tid(TID_01); 1704 firstMunmapEvent->set_addr(MEM_ADDR_01); 1705 firstMunmapEvent->set_size(MEM_SIZE_01); 1706 MunmapEvent* secondMunmapEvent = new MunmapEvent(); 1707 secondMunmapEvent->set_pid(PID); 1708 secondMunmapEvent->set_tid(TID_02); 1709 secondMunmapEvent->set_addr(MEM_ADDR_03); 1710 secondMunmapEvent->set_size(MEM_SIZE_02); 1711 1712 // construct BatchNativeHookData 1713 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 1714 1715 // add NativeHookData 1716 auto firstNativeHookMmapData = batchNativeHookData->add_events(); 1717 firstNativeHookMmapData->set_tv_sec(TV_SEC_01); 1718 firstNativeHookMmapData->set_tv_nsec(TV_NSEC_01); 1719 firstNativeHookMmapData->set_allocated_mmap_event(firstMmapEvent); 1720 auto firstNativeHookMunmapData = batchNativeHookData->add_events(); 1721 firstNativeHookMunmapData->set_tv_sec(TV_SEC_02); 1722 firstNativeHookMunmapData->set_tv_nsec(TV_NSEC_02); 1723 firstNativeHookMunmapData->set_allocated_munmap_event(firstMunmapEvent); 1724 auto secondNativeHookMmapData = batchNativeHookData->add_events(); 1725 secondNativeHookMmapData->set_tv_sec(TV_SEC_03); 1726 secondNativeHookMmapData->set_tv_nsec(TV_NSEC_03); 1727 secondNativeHookMmapData->set_allocated_mmap_event(secondMmapEvent); 1728 auto secondNativeHookMunmapData = batchNativeHookData->add_events(); 1729 secondNativeHookMunmapData->set_tv_sec(TV_SEC_04); 1730 secondNativeHookMunmapData->set_tv_nsec(TV_NSEC_04); 1731 secondNativeHookMunmapData->set_allocated_munmap_event(secondMunmapEvent); 1732 1733 // start parse 1734 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1735 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 1736 htraceNativeHookParser.FinishParseNativeHookData(); 1737 1738 // Verification parse NativeHook results 1739 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 1740 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 1741 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 1742 auto mmapSubType = stream_.traceDataCache_->dataDict_.GetStringIndex(MMAP_SUB_TYPE_01); 1743 NativeHookCache firstExpectNativeHookCache(INVALID_UINT64, expect_ipid, expect_itid, MMAPEVENT.c_str(), mmapSubType, 1744 TIMESTAMP_01, TIMESTAMP_02, TIMESTAMP_02 - TIMESTAMP_01, MEM_ADDR_01, 1745 MEM_SIZE_01, MEM_SIZE_01, TIMESTAMP_02 - TIMESTAMP_01); 1746 NativeHookCache firstResultNativeHookCache(nativeHook, 0); 1747 EXPECT_TRUE(firstExpectNativeHookCache == firstResultNativeHookCache); 1748 1749 NativeHookCache secondExpectNativeHookCache(INVALID_UINT64, expect_ipid, expect_itid, MUNMAPEVENT.c_str(), 1750 INVALID_UINT64, TIMESTAMP_02, 0, 0, MEM_ADDR_01, MEM_SIZE_01, 0, 1751 TIMESTAMP_03 - TIMESTAMP_02); 1752 NativeHookCache secondResultNativeHookCache(nativeHook, 1); 1753 EXPECT_TRUE(secondExpectNativeHookCache == secondResultNativeHookCache); 1754 1755 expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_02); 1756 mmapSubType = stream_.traceDataCache_->dataDict_.GetStringIndex(MMAP_SUB_TYPE_02); 1757 NativeHookCache thirdExpectNativeHookCache(INVALID_UINT64, expect_ipid, expect_itid, MMAPEVENT.c_str(), mmapSubType, 1758 TIMESTAMP_03, 0, 0, MEM_ADDR_02, MEM_SIZE_02, MEM_SIZE_02, 0); 1759 NativeHookCache thirdResultNativeHookCache(nativeHook, 2); 1760 EXPECT_TRUE(thirdExpectNativeHookCache == thirdResultNativeHookCache); 1761 1762 NativeHookCache fourthExpectNativeHookCache(INVALID_UINT64, expect_ipid, expect_itid, MUNMAPEVENT.c_str(), 1763 INVALID_UINT64, TIMESTAMP_04, 0, 0, MEM_ADDR_03, MEM_SIZE_02, MEM_SIZE_02, 0); 1764 NativeHookCache fourthResultNativeHookCache(nativeHook, 3); 1765 EXPECT_TRUE(secondExpectNativeHookCache == secondResultNativeHookCache); 1766 1767 auto size = stream_.traceDataCache_->GetConstNativeHookData().Size(); 1768 EXPECT_EQ(3, size); 1769 1770 auto eventCount = 1771 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MMAP, STAT_EVENT_RECEIVED); 1772 EXPECT_TRUE(2 == eventCount); 1773 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MUNMAP, STAT_EVENT_RECEIVED); 1774 EXPECT_TRUE(2 == eventCount); 1775 } 1776 1777 /** 1778 * @tc.name: ParseBatchNativeHookWithAllTypesEvents 1779 * @tc.desc: Parse a BatchNativeHookData with one pairs Mmap and MunmapEvent and one pairs Malloc and Free 1780 * @tc.type: FUNC 1781 */ 1782 HWTEST_F(NativeHookParserTest, ParseBatchNativeHookWithAllTypesEvents, TestSize.Level1) 1783 { 1784 TS_LOGI("test24-18"); 1785 // construct MmapEvent 1786 MmapEvent* mmapEvent = new MmapEvent(); 1787 mmapEvent->set_pid(PID); 1788 mmapEvent->set_tid(TID_01); 1789 mmapEvent->set_addr(MEM_ADDR_01); 1790 mmapEvent->set_size(MEM_SIZE_01); 1791 mmapEvent->set_type(MMAP_SUB_TYPE_01); 1792 // construct MmapEvent's Frame 1793 auto mmapframe = mmapEvent->add_frame_info(); 1794 mmapframe->set_ip(CALL_STACK_IP_01); 1795 mmapframe->set_sp(CALL_STACK_SP_01); 1796 mmapframe->set_symbol_name(SYMBOL_NAME_01); 1797 mmapframe->set_file_path(FILE_PATH_01); 1798 mmapframe->set_offset(OFFSET_01); 1799 mmapframe->set_symbol_offset(SYMBOL_OFFSET_01); 1800 1801 // construct MunmapEvent 1802 MunmapEvent* munmapEvent = new MunmapEvent(); 1803 munmapEvent->set_pid(PID); 1804 munmapEvent->set_tid(TID_01); 1805 munmapEvent->set_addr(MEM_ADDR_01); 1806 munmapEvent->set_size(MEM_SIZE_01); 1807 // construct MunmapEvent's Frame 1808 auto munmapframe = munmapEvent->add_frame_info(); 1809 munmapframe->set_ip(CALL_STACK_IP_01); 1810 munmapframe->set_sp(CALL_STACK_SP_01); 1811 munmapframe->set_symbol_name(SYMBOL_NAME_01); 1812 munmapframe->set_file_path(FILE_PATH_01); 1813 munmapframe->set_offset(OFFSET_01); 1814 munmapframe->set_symbol_offset(SYMBOL_OFFSET_01); 1815 1816 // construct AllocEvent 1817 AllocEvent* allocEvent = new AllocEvent(); 1818 allocEvent->set_pid(PID); 1819 allocEvent->set_tid(TID_02); 1820 allocEvent->set_addr(MEM_ADDR_02); 1821 allocEvent->set_size(MEM_SIZE_02); 1822 // construct AllocEvent's Frame 1823 auto allocframe = allocEvent->add_frame_info(); 1824 allocframe->set_ip(CALL_STACK_IP_02); 1825 allocframe->set_sp(CALL_STACK_SP_02); 1826 allocframe->set_symbol_name(SYMBOL_NAME_02); 1827 allocframe->set_file_path(FILE_PATH_02); 1828 allocframe->set_offset(OFFSET_02); 1829 allocframe->set_symbol_offset(SYMBOL_OFFSET_02); 1830 1831 // construct FreeEvent 1832 FreeEvent* freeEvent = new FreeEvent(); 1833 freeEvent->set_pid(PID); 1834 freeEvent->set_tid(TID_02); 1835 freeEvent->set_addr(MEM_ADDR_02); 1836 // construct FreeEvent's Frame 1837 auto freeframe = freeEvent->add_frame_info(); 1838 freeframe->set_ip(CALL_STACK_IP_02); 1839 freeframe->set_sp(CALL_STACK_SP_02); 1840 freeframe->set_symbol_name(SYMBOL_NAME_02); 1841 freeframe->set_file_path(FILE_PATH_02); 1842 freeframe->set_offset(OFFSET_02); 1843 freeframe->set_symbol_offset(SYMBOL_OFFSET_02); 1844 1845 // construct BatchNativeHookData 1846 BatchNativeHookData* batchNativeHookData = new BatchNativeHookData(); 1847 1848 // add NativeHookData 1849 auto nativeHookMmapData = batchNativeHookData->add_events(); 1850 nativeHookMmapData->set_tv_sec(TV_SEC_01); 1851 nativeHookMmapData->set_tv_nsec(TV_NSEC_01); 1852 nativeHookMmapData->set_allocated_mmap_event(mmapEvent); 1853 auto nativeHookMunmapData = batchNativeHookData->add_events(); 1854 nativeHookMunmapData->set_tv_sec(TV_SEC_02); 1855 nativeHookMunmapData->set_tv_nsec(TV_NSEC_02); 1856 nativeHookMunmapData->set_allocated_munmap_event(munmapEvent); 1857 auto nativeHookAllocData = batchNativeHookData->add_events(); 1858 nativeHookAllocData->set_tv_sec(TV_SEC_03); 1859 nativeHookAllocData->set_tv_nsec(TV_NSEC_03); 1860 nativeHookAllocData->set_allocated_alloc_event(allocEvent); 1861 auto nativeHookFreeData = batchNativeHookData->add_events(); 1862 nativeHookFreeData->set_tv_sec(TV_SEC_04); 1863 nativeHookFreeData->set_tv_nsec(TV_NSEC_04); 1864 nativeHookFreeData->set_allocated_free_event(freeEvent); 1865 1866 // start parse 1867 HtraceNativeHookParser htraceNativeHookParser(stream_.traceDataCache_.get(), stream_.streamFilters_.get()); 1868 htraceNativeHookParser.SortNativeHookData(*batchNativeHookData); 1869 htraceNativeHookParser.FinishParseNativeHookData(); 1870 1871 // Verification parse NativeHook results 1872 const NativeHook& nativeHook = stream_.traceDataCache_->GetConstNativeHookData(); 1873 auto expect_ipid = stream_.streamFilters_->processFilter_->GetInternalPid(PID); 1874 auto expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_01); 1875 auto mmapSubType = stream_.traceDataCache_->dataDict_.GetStringIndex(MMAP_SUB_TYPE_01); 1876 NativeHookCache firstExpectNativeHookCache(1, expect_ipid, expect_itid, MMAPEVENT.c_str(), mmapSubType, 1877 TIMESTAMP_01, TIMESTAMP_02, TIMESTAMP_02 - TIMESTAMP_01, MEM_ADDR_01, 1878 MEM_SIZE_01, MEM_SIZE_01, TIMESTAMP_02 - TIMESTAMP_01); 1879 NativeHookCache firstResultNativeHookCache(nativeHook, 0); 1880 EXPECT_TRUE(firstExpectNativeHookCache == firstResultNativeHookCache); 1881 1882 NativeHookCache secondExpectNativeHookCache(1, expect_ipid, expect_itid, MUNMAPEVENT.c_str(), INVALID_UINT64, 1883 TIMESTAMP_02, 0, 0, MEM_ADDR_01, MEM_SIZE_01, 0, 0); 1884 NativeHookCache secondResultNativeHookCache(nativeHook, 1); 1885 EXPECT_TRUE(secondExpectNativeHookCache == secondResultNativeHookCache); 1886 1887 expect_itid = stream_.streamFilters_->processFilter_->GetInternalTid(TID_02); 1888 NativeHookCache thirdExpectNativeHookCache(2, expect_ipid, expect_itid, ALLOCEVENT.c_str(), INVALID_UINT64, 1889 TIMESTAMP_03, TIMESTAMP_04, TIMESTAMP_04 - TIMESTAMP_03, MEM_ADDR_02, 1890 MEM_SIZE_02, MEM_SIZE_02, TIMESTAMP_04 - TIMESTAMP_03); 1891 NativeHookCache thirdResultNativeHookCache(nativeHook, 2); 1892 EXPECT_TRUE(thirdExpectNativeHookCache == thirdResultNativeHookCache); 1893 1894 NativeHookCache fourthExpectNativeHookCache(2, expect_ipid, expect_itid, FREEEVENT.c_str(), INVALID_UINT64, 1895 TIMESTAMP_04, 0, 0, MEM_ADDR_02, MEM_SIZE_02, 0, 0); 1896 NativeHookCache fourthResultNativeHookCache(nativeHook, 3); 1897 EXPECT_TRUE(fourthExpectNativeHookCache == fourthResultNativeHookCache); 1898 1899 auto size = stream_.traceDataCache_->GetConstNativeHookData().Size(); 1900 EXPECT_EQ(4, size); 1901 1902 auto eventCount = 1903 stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MMAP, STAT_EVENT_RECEIVED); 1904 EXPECT_TRUE(1 == eventCount); 1905 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MUNMAP, STAT_EVENT_RECEIVED); 1906 EXPECT_TRUE(1 == eventCount); 1907 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_MALLOC, STAT_EVENT_RECEIVED); 1908 EXPECT_TRUE(1 == eventCount); 1909 eventCount = stream_.traceDataCache_->GetConstStatAndInfo().GetValue(TRACE_NATIVE_HOOK_FREE, STAT_EVENT_RECEIVED); 1910 EXPECT_TRUE(1 == eventCount); 1911 } 1912 } // namespace TraceStreamer 1913 } // namespace SysTuning