1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "native_memory_stdtype.h"
16
17 namespace SysTuning {
18 namespace TraceStdtype {
AppendNativeHookSampleBase(uint32_t callChainId,uint32_t ipid,uint32_t itid,uint64_t timeStamp)19 void NativeHookSampleBase::AppendNativeHookSampleBase(uint32_t callChainId,
20 uint32_t ipid,
21 uint32_t itid,
22 uint64_t timeStamp)
23 {
24 ids_.emplace_back(id_++);
25 callChainIds_.emplace_back(callChainId);
26 ipids_.emplace_back(ipid);
27 internalTids_.emplace_back(itid);
28 timeStamps_.emplace_back(timeStamp);
29 lastCallerPathIndexs_.emplace_back(INVALID_DATAINDEX);
30 lastSymbolIndexs_.emplace_back(INVALID_DATAINDEX);
31 }
AppendNativeHookSampleBase(uint32_t callChainId,uint32_t ipid,uint64_t timeStamp)32 void NativeHookSampleBase::AppendNativeHookSampleBase(uint32_t callChainId, uint32_t ipid, uint64_t timeStamp)
33 {
34 ids_.emplace_back(id_++);
35 callChainIds_.emplace_back(callChainId);
36 ipids_.emplace_back(ipid);
37 timeStamps_.emplace_back(timeStamp);
38 lastCallerPathIndexs_.emplace_back(INVALID_DATAINDEX);
39 lastSymbolIndexs_.emplace_back(INVALID_DATAINDEX);
40 }
CallChainIds() const41 const std::deque<uint32_t>& NativeHookSampleBase::CallChainIds() const
42 {
43 return callChainIds_;
44 }
Ipids() const45 const std::deque<uint32_t>& NativeHookSampleBase::Ipids() const
46 {
47 return ipids_;
48 }
LastCallerPathIndexs() const49 const std::deque<uint64_t>& NativeHookSampleBase::LastCallerPathIndexs() const
50 {
51 return lastCallerPathIndexs_;
52 }
LastSymbolIndexs() const53 const std::deque<uint64_t>& NativeHookSampleBase::LastSymbolIndexs() const
54 {
55 return lastSymbolIndexs_;
56 }
UpdateLastCallerPathAndSymbolIndexs(std::unordered_map<uint32_t,std::tuple<DataIndex,DataIndex>> & callIdToLasLibId)57 void NativeHookSampleBase::UpdateLastCallerPathAndSymbolIndexs(
58 std::unordered_map<uint32_t, std::tuple<DataIndex, DataIndex>>& callIdToLasLibId)
59 {
60 if (callIdToLasLibId.empty()) {
61 return;
62 }
63 for (auto i = 0; i < Size(); ++i) {
64 auto symbolIt = callIdToLasLibId.find(callChainIds_[i]);
65 if (symbolIt != callIdToLasLibId.end()) {
66 std::tie(lastCallerPathIndexs_[i], lastSymbolIndexs_[i]) = symbolIt->second;
67 } else {
68 lastCallerPathIndexs_[i] = INVALID_DATAINDEX;
69 lastSymbolIndexs_[i] = INVALID_DATAINDEX;
70 }
71 }
72 }
AppendNewNativeHookData(uint32_t callChainId,uint32_t ipid,uint32_t itid,std::string eventType,DataIndex subType,uint64_t timeStamp,uint64_t endTimeStamp,uint64_t duration,uint64_t addr,int64_t memSize)73 size_t NativeHook::AppendNewNativeHookData(uint32_t callChainId,
74 uint32_t ipid,
75 uint32_t itid,
76 std::string eventType,
77 DataIndex subType,
78 uint64_t timeStamp,
79 uint64_t endTimeStamp,
80 uint64_t duration,
81 uint64_t addr,
82 int64_t memSize)
83 {
84 AppendNativeHookSampleBase(callChainId, ipid, itid, timeStamp);
85 eventTypes_.emplace_back(eventType);
86 subTypes_.emplace_back(subType);
87 endTimeStamps_.emplace_back(endTimeStamp);
88 durations_.emplace_back(duration);
89 addrs_.emplace_back(addr);
90 memSizes_.emplace_back(memSize);
91 if (eventType == ALLOC_EVET) {
92 countHeapSizes_ += memSize;
93 allMemSizes_.emplace_back(countHeapSizes_);
94 } else if (eventType == FREE_EVENT) {
95 countHeapSizes_ -= memSize;
96 allMemSizes_.emplace_back(countHeapSizes_);
97 } else if (eventType == MMAP_EVENT) {
98 countMmapSizes_ += memSize;
99 allMemSizes_.emplace_back(countMmapSizes_);
100 } else if (eventType == MUNMAP_EVENT) {
101 countMmapSizes_ -= memSize;
102 allMemSizes_.emplace_back(countMmapSizes_);
103 }
104 currentSizeDurs_.emplace_back(0);
105 return Size() - 1;
106 }
UpdateCallChainId(size_t row,uint32_t callChainId)107 void NativeHook::UpdateCallChainId(size_t row, uint32_t callChainId)
108 {
109 if (row < Size()) {
110 callChainIds_[row] = callChainId;
111 } else {
112 TS_LOGE("Native hook update callChainId failed!!!");
113 }
114 }
UpdateEndTimeStampAndDuration(size_t row,uint64_t endTimeStamp)115 void NativeHook::UpdateEndTimeStampAndDuration(size_t row, uint64_t endTimeStamp)
116 {
117 endTimeStamps_[row] = endTimeStamp;
118 durations_[row] = endTimeStamp - timeStamps_[row];
119 }
UpdateCurrentSizeDur(size_t row,uint64_t timeStamp)120 void NativeHook::UpdateCurrentSizeDur(size_t row, uint64_t timeStamp)
121 {
122 currentSizeDurs_[row] = timeStamp - timeStamps_[row];
123 }
UpdateMemMapSubType(uint64_t row,uint64_t tagId)124 void NativeHook::UpdateMemMapSubType(uint64_t row, uint64_t tagId)
125 {
126 if (row < subTypes_.size()) {
127 subTypes_[row] = tagId;
128 } else {
129 TS_LOGE("subTypes_ row is invalid!");
130 }
131 }
EventTypes() const132 const std::deque<std::string>& NativeHook::EventTypes() const
133 {
134 return eventTypes_;
135 }
SubTypes() const136 const std::deque<DataIndex>& NativeHook::SubTypes() const
137 {
138 return subTypes_;
139 }
EndTimeStamps() const140 const std::deque<uint64_t>& NativeHook::EndTimeStamps() const
141 {
142 return endTimeStamps_;
143 }
Durations() const144 const std::deque<uint64_t>& NativeHook::Durations() const
145 {
146 return durations_;
147 }
Addrs() const148 const std::deque<uint64_t>& NativeHook::Addrs() const
149 {
150 return addrs_;
151 }
MemSizes() const152 const std::deque<int64_t>& NativeHook::MemSizes() const
153 {
154 return memSizes_;
155 }
AllMemSizes() const156 const std::deque<int64_t>& NativeHook::AllMemSizes() const
157 {
158 return allMemSizes_;
159 }
CurrentSizeDurs() const160 const std::deque<uint64_t>& NativeHook::CurrentSizeDurs() const
161 {
162 return currentSizeDurs_;
163 }
AppendNewNativeHookFrame(uint32_t callChainId,uint16_t depth,uint64_t ip,DataIndex symbolName,DataIndex filePath,uint64_t offset,uint64_t symbolOffset,const std::string & vaddr)164 size_t NativeHookFrame::AppendNewNativeHookFrame(uint32_t callChainId,
165 uint16_t depth,
166 uint64_t ip,
167 DataIndex symbolName,
168 DataIndex filePath,
169 uint64_t offset,
170 uint64_t symbolOffset,
171 const std::string& vaddr)
172 {
173 callChainIds_.emplace_back(callChainId);
174 ips_.emplace_back(ip);
175 depths_.emplace_back(depth);
176 symbolNames_.emplace_back(symbolName);
177 filePaths_.emplace_back(filePath);
178 offsets_.emplace_back(offset);
179 symbolOffsets_.emplace_back(symbolOffset);
180 vaddrs_.emplace_back(vaddr);
181 return Size() - 1;
182 }
AppendNewNativeHookFrame(uint32_t callChainId,uint16_t depth,uint64_t ip,DataIndex symbolName,DataIndex filePath,uint64_t offset,uint64_t symbolOffset)183 size_t NativeHookFrame::AppendNewNativeHookFrame(uint32_t callChainId,
184 uint16_t depth,
185 uint64_t ip,
186 DataIndex symbolName,
187 DataIndex filePath,
188 uint64_t offset,
189 uint64_t symbolOffset)
190 {
191 callChainIds_.emplace_back(callChainId);
192 ips_.emplace_back(ip);
193 depths_.emplace_back(depth);
194 symbolNames_.emplace_back(symbolName);
195 filePaths_.emplace_back(filePath);
196 offsets_.emplace_back(offset);
197 symbolOffsets_.emplace_back(symbolOffset);
198 return Size() - 1;
199 }
UpdateSymbolIdToNameMap(uint64_t originSymbolId,uint64_t symbolId)200 void NativeHookFrame::UpdateSymbolIdToNameMap(uint64_t originSymbolId, uint64_t symbolId)
201 {
202 symbolIdToSymbolName_.insert(std::make_pair(originSymbolId, symbolId));
203 }
UpdateFrameInfo(size_t row,DataIndex symbolIndex,DataIndex filePathIndex,uint64_t offset,uint64_t symbolOffset)204 void NativeHookFrame::UpdateFrameInfo(size_t row,
205 DataIndex symbolIndex,
206 DataIndex filePathIndex,
207 uint64_t offset,
208 uint64_t symbolOffset)
209 {
210 if (row >= Size()) {
211 TS_LOGE("The updated row does not exist!");
212 return;
213 }
214 symbolNames_[row] = symbolIndex;
215 filePaths_[row] = filePathIndex;
216 offsets_[row] = offset;
217 symbolOffsets_[row] = symbolOffset;
218 }
219
UpdateSymbolId()220 void NativeHookFrame::UpdateSymbolId()
221 {
222 if (symbolIdToSymbolName_.empty()) {
223 return;
224 }
225 for (auto i = 0; i < Size(); ++i) {
226 auto symbolIt = symbolIdToSymbolName_.find(symbolNames_[i]);
227 if (symbolIt != symbolIdToSymbolName_.end()) {
228 symbolNames_[i] = symbolIt->second;
229 }
230 }
231 }
UpdateSymbolId(size_t index,DataIndex symbolId)232 void NativeHookFrame::UpdateSymbolId(size_t index, DataIndex symbolId)
233 {
234 if (index < Size()) {
235 symbolNames_[index] = symbolId;
236 }
237 }
UpdateFileId(std::map<uint32_t,uint64_t> & filePathIdToFilePathName)238 void NativeHookFrame::UpdateFileId(std::map<uint32_t, uint64_t>& filePathIdToFilePathName)
239 {
240 if (filePathIdToFilePathName.empty()) {
241 return;
242 }
243 for (auto i = 0; i < Size(); ++i) {
244 auto symbolIt = filePathIdToFilePathName.find(filePaths_[i]);
245 if (symbolIt != filePathIdToFilePathName.end()) {
246 filePaths_[i] = symbolIt->second;
247 }
248 }
249 }
UpdateVaddrs(std::deque<std::string> & vaddrs)250 void NativeHookFrame::UpdateVaddrs(std::deque<std::string>& vaddrs)
251 {
252 vaddrs_.assign(vaddrs.begin(), vaddrs.end());
253 }
CallChainIds() const254 const std::deque<uint32_t>& NativeHookFrame::CallChainIds() const
255 {
256 return callChainIds_;
257 }
Depths() const258 const std::deque<uint16_t>& NativeHookFrame::Depths() const
259 {
260 return depths_;
261 }
Ips() const262 const std::deque<uint64_t>& NativeHookFrame::Ips() const
263 {
264 return ips_;
265 }
SymbolNames() const266 const std::deque<DataIndex>& NativeHookFrame::SymbolNames() const
267 {
268 return symbolNames_;
269 }
FilePaths() const270 const std::deque<DataIndex>& NativeHookFrame::FilePaths() const
271 {
272 return filePaths_;
273 }
Offsets() const274 const std::deque<uint64_t>& NativeHookFrame::Offsets() const
275 {
276 return offsets_;
277 }
SymbolOffsets() const278 const std::deque<uint64_t>& NativeHookFrame::SymbolOffsets() const
279 {
280 return symbolOffsets_;
281 }
Vaddrs() const282 const std::deque<std::string>& NativeHookFrame::Vaddrs() const
283 {
284 return vaddrs_;
285 }
286
AppendNewNativeHookStatistic(uint32_t ipid,uint64_t timeStamp,uint32_t callChainId,uint32_t memoryType,DataIndex subMemType,uint64_t applyCount,uint64_t releaseCount,uint64_t applySize,uint64_t releaseSize)287 size_t NativeHookStatistic::AppendNewNativeHookStatistic(uint32_t ipid,
288 uint64_t timeStamp,
289 uint32_t callChainId,
290 uint32_t memoryType,
291 DataIndex subMemType,
292 uint64_t applyCount,
293 uint64_t releaseCount,
294 uint64_t applySize,
295 uint64_t releaseSize)
296 {
297 AppendNativeHookSampleBase(callChainId, ipid, timeStamp);
298 memoryTypes_.emplace_back(memoryType);
299 applyCounts_.emplace_back(applyCount);
300 memSubTypes_.emplace_back(subMemType);
301 releaseCounts_.emplace_back(releaseCount);
302 applySizes_.emplace_back(applySize);
303 releaseSizes_.emplace_back(releaseSize);
304 return Size() - 1;
305 }
306
MemoryTypes() const307 const std::deque<uint32_t>& NativeHookStatistic::MemoryTypes() const
308 {
309 return memoryTypes_;
310 }
MemorySubTypes() const311 const std::deque<DataIndex>& NativeHookStatistic::MemorySubTypes() const
312 {
313 return memSubTypes_;
314 }
ApplyCounts() const315 const std::deque<uint64_t>& NativeHookStatistic::ApplyCounts() const
316 {
317 return applyCounts_;
318 }
ReleaseCounts() const319 const std::deque<uint64_t>& NativeHookStatistic::ReleaseCounts() const
320 {
321 return releaseCounts_;
322 }
ApplySizes() const323 const std::deque<uint64_t>& NativeHookStatistic::ApplySizes() const
324 {
325 return applySizes_;
326 }
ReleaseSizes() const327 const std::deque<uint64_t>& NativeHookStatistic::ReleaseSizes() const
328 {
329 return releaseSizes_;
330 }
331 } // namespace TraceStdtype
332 } // namespace SysTuning
333