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 "dump_utils.h"
16
17 #include <cerrno>
18 #include <csignal>
19 #include <fcntl.h>
20 #include <poll.h>
21 #include <set>
22 #include <map>
23 #include <sys/stat.h>
24 #include <sys/utsname.h>
25 #include <unistd.h>
26 #include <fstream>
27 #include <iostream>
28
29 #include <sys/prctl.h>
30 #include <sys/resource.h>
31 #include <sys/times.h>
32 #include <sys/types.h>
33 #include <sys/wait.h>
34
35 #include "common.h"
36 #include "datetime_ex.h"
37 #include "file_ex.h"
38 #include "iservice_registry.h"
39 #include "parameters.h"
40 #include "securec.h"
41 #include "string_ex.h"
42
43 #include "system_ability_definition.h"
44 #include "hilog_wrapper.h"
45
46 #ifdef HIDUMPER_BUNDLEMANAGER_FRAMEWORK_ENABLE
47 #include "application_info.h"
48 #include "bundlemgr/bundle_mgr_proxy.h"
49 #endif
50
51 namespace OHOS {
52 inline const std::map<int, std::string> saNameMap_ = {
53 { 0, "SystemAbilityManager" },
54 { 200, "AccountMgr" },
55 { 301, "AIEngine" },
56 { ABILITY_MGR_SERVICE_ID, "AbilityManagerService" },
57 { DATAOBS_MGR_SERVICE_SA_ID, "DataObserverMgr" },
58 { APP_MGR_SERVICE_ID, "ApplicationManagerService" },
59 { URI_PERMISSION_MGR_SERVICE_ID, "UriPermissionMgr" },
60 { QUICK_FIX_MGR_SERVICE_ID, "QuickFixMgrService"},
61 { BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, "BundleMgr" },
62 { SERVICE_ROUTER_MGR_SERVICE_ID, "ServiceRouterMgr" },
63 { INSTALLD_SERVICE_ID, "Installd" },
64 { FORM_MGR_SERVICE_ID, "FormMgr" },
65 { WIFI_DEVICE_SYS_ABILITY_ID, "WifiDevice" },
66 { WIFI_HOTSPOT_SYS_ABILITY_ID, "WifiHotspot" },
67 { WIFI_ENHANCER_SYS_ABILITY_ID, "WifiEnhancer" },
68 { WIFI_P2P_SYS_ABILITY_ID, "WifiP2p" },
69 { WIFI_SCAN_SYS_ABILITY_ID, "WifiScan" },
70 { BLUETOOTH_HOST_SYS_ABILITY_ID, "BluetoothHost" },
71 { NFC_MANAGER_SYS_ABILITY_ID, "NfcManager" },
72 { SE_MANAGER_SYS_ABILITY_ID, "SeManager" },
73 { NET_MANAGER_SYS_ABILITY_ID, "NetManager" },
74 { DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID, "DistributedKvData" },
75 { DISTRIBUTED_SCHED_SA_ID, "DistributedSched" },
76 { DISTRIBUTED_SCHED_ADAPTER_SA_ID, "DistributedSchedAdapter" },
77 { DISTRIBUTED_SCENARIO_MGR_SA_ID, "DistributedScenarioMgr" },
78 { CONTINUATION_MANAGER_SA_ID, "ContinuationManagerService" },
79 { RES_SCHED_SYS_ABILITY_ID, "ResourceSched" },
80 { RESSCHEDD_SA_ID, "ResourceSchedDamon" },
81 { BACKGROUND_TASK_MANAGER_SERVICE_ID, "BackgroundTaskManager" },
82 { WORK_SCHEDULE_SERVICE_ID, "WorkSchedule" },
83 { CONCURRENT_TASK_SERVICE_ID, "ConcurrentTaskService" },
84 { RESOURCE_QUOTA_CONTROL_SYSTEM_ABILITY_ID, "ResourceQuotaControl"},
85 { DEVICE_STANDBY_SERVICE_SYSTEM_ABILITY_ID, "DeviceStandbyService"},
86 { TASK_HEARTBEAT_MGR_SYSTEM_ABILITY_ID, "TaskHeartbeatMgrService"},
87 { COMPONENT_SCHEDULE_SERVICE_ID, "ComponentSchedServer" },
88 { SOC_PERF_SERVICE_SA_ID, "SocPerfService" },
89 { SUSPEND_MANAGER_SYSTEM_ABILITY_ID, "SuspendManager" },
90 { APP_NAP_SYSTEM_ABILITY_ID, "AppNap" },
91 { ABNORMAL_EFFICIENCY_MGR_SYSTEM_ABILITY_ID, "AbnormalEfficiencyManager" },
92 { LOCATION_GEO_CONVERT_SA_ID, "LocationGeoConvert" },
93 { LOCATION_LOCATOR_SA_ID, "LocationLocator" },
94 { LOCATION_GNSS_SA_ID, "LocationGnss" },
95 { LOCATION_NETWORK_LOCATING_SA_ID, "LocationNetworkLocating" },
96 { LOCATION_NOPOWER_LOCATING_SA_ID, "LocationNopowerLocating" },
97 { AUDIO_DISTRIBUTED_SERVICE_ID, "AudioDistributed" },
98 { COMMON_EVENT_SERVICE_ABILITY_ID, "CommonEventService" },
99 { ADVANCED_NOTIFICATION_SERVICE_ABILITY_ID, "DistributedNotificationService" },
100 { REMINDER_AGENT_SERVICE_ABILITY_ID, "ReminderAgentService" },
101 { COMMON_EVENT_SERVICE_ID, "CommonEventService" },
102 { POWER_MANAGER_SERVICE_ID, "PowerManagerService" },
103 { POWER_MANAGER_BATT_SERVICE_ID, "BatteryService" },
104 { POWER_MANAGER_BATT_STATS_SERVICE_ID, "BatteryStatisticsService" },
105 { POWER_MANAGER_THERMAL_SERVICE_ID, "ThermalService" },
106 { DISPLAY_MANAGER_SERVICE_ID, "DisplayPowerManagerService" },
107 { 3502, "DpmsService" },
108 { 3510, "KeystoreService" },
109 { DEVICE_SECURITY_LEVEL_MANAGER_SA_ID, "DslmService" },
110 { CERT_MANAGER_SERVICE_SA_ID, "CertManagerService"},
111 { DEVICE_THREAT_DETECTION_SERVICE_SA_ID, "DeviceThreatDetectionService" },
112 { SENSOR_SERVICE_ABILITY_ID, "SensorService" },
113 { MISCDEVICE_SERVICE_ABILITY_ID, "MiscDeviceService" },
114 { PASTEBOARD_SERVICE_ID, "PasteboardService" },
115 { SCREENLOCK_SERVICE_ID, "ScreenlockService" },
116 { WALLPAPER_MANAGER_SERVICE_ID, "WallpaperManagerService" },
117 { PRINT_SERVICE_ID, "PrintFramework" },
118 { SCAN_SERVICE_ID, "ScanFramework" },
119 { TELEPHONY_SYS_ABILITY_ID, "Telephony" },
120 { DCALL_SYS_ABILITY_ID, "DistributedCallMgr" },
121 { TELEPHONY_CALL_MANAGER_SYS_ABILITY_ID, "TelephonyCallManager" },
122 { TELEPHONY_CELLULAR_CALL_SYS_ABILITY_ID, "TelephonyCellularCall" },
123 { TELEPHONY_CELLULAR_DATA_SYS_ABILITY_ID, "TelephonyCellularData" },
124 { TELEPHONY_SMS_MMS_SYS_ABILITY_ID, "TelephonySmsMms" },
125 { TELEPHONY_STATE_REGISTRY_SYS_ABILITY_ID, "TelephonyStateRegistry" },
126 { TELEPHONY_CORE_SERVICE_SYS_ABILITY_ID, "TelephonyCoreService" },
127 { TELEPHONY_DATA_STORAGE_SYS_ABILITY_ID, "TelephonyDataStorage" },
128 { TELEPHONY_IMS_SYS_ABILITY_ID, "TelephonyIms" },
129 { DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID, "DeviceManagerService" },
130 { DISTRIBUTED_HARDWARE_SA_ID, "DistributedHardwareFramework" },
131 { DISTRIBUTED_HARDWARE_CAMERA_SOURCE_SA_ID, "DistributedCameraSourceService" },
132 { DISTRIBUTED_HARDWARE_CAMERA_SINK_SA_ID, "DistributedCameraSinkService" },
133 { DISTRIBUTED_HARDWARE_AUDIO_SOURCE_SA_ID, "DistributedAudioSourceService" },
134 { DISTRIBUTED_HARDWARE_AUDIO_SINK_SA_ID, "DistributedAudioSinkService" },
135 { DISTRIBUTED_HARDWARE_SCREEN_SOURCE_SA_ID, "DistributedScreenSourceService" },
136 { DISTRIBUTED_HARDWARE_SCREEN_SINK_SA_ID, "DistributedScreenSinkService" },
137 { DISTRIBUTED_HARDWARE_INPUT_SOURCE_SA_ID, "DistributedInputSourceService" },
138 { DISTRIBUTED_HARDWARE_INPUT_SINK_SA_ID, "DistributedInputSinkService" },
139 { INPUT_METHOD_SYSTEM_ABILITY_ID, "InputMethodService" },
140 { MEDICAL_SENSOR_SERVICE_ABILITY_ID, "MedicalSensorService" },
141 { USB_SYSTEM_ABILITY_ID, "UsbService" },
142 { STORAGE_MANAGER_DAEMON_ID, "StorageDaemon" },
143 { STORAGE_MANAGER_MANAGER_ID, "StorageManager"},
144 { FILEMANAGEMENT_DISTRIBUTED_FILE_DAEMON_SA_ID, "DistributedFileDaemon"},
145 { FILEMANAGEMENT_CLOUD_SYNC_SERVICE_SA_ID, "CloudFileSyncService"},
146 { FILEMANAGEMENT_CLOUD_DAEMON_SERVICE_SA_ID, "CloudFileDaemonService"},
147 { DEVICE_SERVICE_MANAGER_SA_ID, "HdfDeviceServiceManager" },
148 { HDF_EXTERNAL_DEVICE_MANAGER_SA_ID, "HdfExternalDeviceManager" },
149 { DISTRIBUTED_DEVICE_PROFILE_SA_ID, "DistributedDeviceProfile" },
150 { WINDOW_MANAGER_SERVICE_ID, "WindowManagerService" },
151 { DISPLAY_MANAGER_SERVICE_SA_ID, "DisplayManagerService" },
152 { SOFTBUS_SERVER_SA_ID, "DSoftbus" },
153 { DEVICE_AUTH_SERVICE_ID, "DeviceAuthService" },
154 { WINDOW_MANAGER_ID, "WindowManager" },
155 { VSYNC_MANAGER_ID, "VsyncManager" },
156 { VSYNC_MANAGER_TEST_ID, "VsyncManagerTest" },
157 { GRAPHIC_DUMPER_SERVICE_SA_ID, "GraphicDumperService" },
158 { GRAPHIC_DUMPER_COMMAND_SA_ID, "GraphicDumperCommand" },
159 { ANIMATION_SERVER_SA_ID, "AnimationServer" },
160 { CA_DAEMON_ID, "CaDaemon" },
161 { ACCESSIBILITY_MANAGER_SERVICE_ID, "AccessibilityManagerService" },
162 { DEVICE_USAGE_STATISTICS_SYS_ABILITY_ID, "DeviceUsageStatistics" },
163 { MEMORY_MANAGER_SA_ID, "MemoryManagerService" },
164 { AVSESSION_SERVICE_ID, "AVSessionService" },
165 { SYS_INSTALLER_DISTRIBUTED_SERVICE_ID, "SysInstallerService" },
166 { MODULE_UPDATE_SERVICE_ID, "ModuleUpdateService" },
167 { SUBSYS_ACE_SYS_ABILITY_ID_BEGIN, "UiService" },
168 { ARKUI_UI_APPEARANCE_SERVICE_ID, "UiAppearanceService" },
169 { SUBSYS_USERIAM_SYS_ABILITY_USERIDM, "UserIdmService" },
170 { SUBSYS_USERIAM_SYS_ABILITY_AUTHEXECUTORMGR, "AuthExecutorMgrService" },
171 { RENDER_SERVICE, "RenderService" },
172 { ACCESS_TOKEN_MANAGER_SERVICE_ID, "AccessTokenManagerService" },
173 { TOKEN_SYNC_MANAGER_SERVICE_ID, "TokenSyncManagerService" },
174 { SANDBOX_MANAGER_SERVICE_ID, "SandboxManagerService" },
175 { DLP_PERMISSION_SERVICE_ID, "DlpPermissionService" },
176 { RISK_ANALYSIS_MANAGER_SA_ID, "RiskAnalysisManagerService" },
177 { DATA_COLLECT_MANAGER_SA_ID, "DataCollectManagerService" },
178 { MSDP_DEVICESTATUS_SERVICE_ID, "DeviceStatusService" },
179 { MULTIMODAL_INPUT_SERVICE_ID, "MultimodalInput" },
180 { DFX_SYS_HIVIEW_ABILITY_ID, "HiviewService" },
181 { PRIVACY_MANAGER_SERVICE_ID, "PrivacyManagerService"},
182 { DFX_FAULT_LOGGER_ABILITY_ID, "HiviewFaultLogger" },
183 { DFX_SYS_EVENT_SERVICE_ABILITY_ID, "HiviewSysEventService" },
184 { DFX_SYS_NATIVE_MEMORY_PROFILER_SERVICE_ABILITY_ID, "HiviewSysNativeMemoryProfilerService"},
185 { XPERF_SYS_TRACE_SERVICE_ABILITY_ID, "XperfTraceService" },
186 { XPERF_SYS_IO_SERVICE_ABILITY_ID, "XperfIoService" },
187 { XPERF_BIGDATA_MANAGER_SERVICE_ABILITY_ID, "XperfBigDataManagerService" },
188 { DFX_HI_DUMPER_SERVICE_ABILITY_ID, "HiDumperService" },
189 { XPOWER_MANAGER_SYSTEM_ABILITY_ID, "XpowerManager"},
190 { DFX_HI_PERF_SERVICE_ABILITY_ID, "HiPerfService"},
191 { DFX_HI_DUMPER_CPU_SERVICE_ABILITY_ID, "HiDumperCpuService" },
192 { SUBSYS_USERIAM_SYS_ABILITY_USERAUTH, "UserAuthService" },
193 { SUBSYS_USERIAM_SYS_ABILITY_PINAUTH, "PinAuthService" },
194 { SUBSYS_USERIAM_SYS_ABILITY_FACEAUTH, "FaceAuthService" },
195 { SUBSYS_USERIAM_SYS_ABILITY_FINGERPRINTAUTH, "FingerprintAuthService" },
196 { SUBSYS_USERIAM_SYS_ABILITY_FINGERPRINTAUTH_EX, "FingerprintAuthServiceEx" },
197 { NET_MANAGER_SYS_ABILITY_ID, "NetManager" },
198 { COMM_NET_CONN_MANAGER_SYS_ABILITY_ID, "NetConnManager" },
199 { COMM_NET_POLICY_MANAGER_SYS_ABILITY_ID, "NetPolicyManager" },
200 { COMM_NET_STATS_MANAGER_SYS_ABILITY_ID, "NetStatsManager" },
201 { COMM_NET_TETHERING_MANAGER_SYS_ABILITY_ID, "NetTetheringManager" },
202 { COMM_VPN_MANAGER_SYS_ABILITY_ID, "VPNManager" },
203 { COMM_DNS_MANAGER_SYS_ABILITY_ID, "DNSManager"},
204 { COMM_ETHERNET_MANAGER_SYS_ABILITY_ID, "EthernetManager" },
205 { COMM_NETSYS_NATIVE_SYS_ABILITY_ID, "NetsysNative" },
206 { COMM_MDNS_MANAGER_SYS_ABILITY_ID, "MDNSManager"},
207 { COMM_NETSYS_EXT_SYS_ABILITY_ID, "NetsysExtService"},
208 { COMM_DISTRIBUTED_NET_ABILITY_ID, "DistributedNet"},
209 { COMM_WEARABLE_DISTRIBUTED_NET_ABILITY_ID, "WearableDistributedNet"},
210 { ENTERPRISE_DEVICE_MANAGER_SA_ID, "EnterpriseDeviceManagerService" },
211 { I18N_SA_ID, "I18nService" },
212 { PARAM_WATCHER_DISTRIBUTED_SERVICE_ID, "ParamWatcher" },
213 { SYSPARAM_DEVICE_SERVICE_ID, "SysParamDevice" },
214 { TIME_SERVICE_ID, "TimeService" },
215 { PLAYER_DISTRIBUTED_SERVICE_ID, "PlayerDistributedService"},
216 { AV_CODEC_SERVICE_ID, "AVCodecService"},
217 { CAMERA_SERVICE_ID, "CameraService"},
218 { MEDIA_KEY_SYSTEM_SERVICE_ID, "MediaKeySystemService"},
219 { AUDIO_POLICY_SERVICE_ID, "AudioPolicyService"},
220 { DLP_CREDENTIAL_SERVICE_ID, "DlpCreService"},
221 { QUICKFIX_ENGINE_SERVICE_ID, "QuickfixEngineService"},
222 { DEVICE_ATTEST_PROFILE_SA_ID, "devattest_service" },
223 { AIDISPATCHER_ENGINE_SERVICE, "AIDispatcherEngineService" },
224 { SECURITY_COMPONENT_SERVICE_ID, "SecurityComponentService" },
225 { ADVERTISING_SA_ID, "Advertising" },
226 { LOCAL_CODE_SIGN_SERVICE_ID, "LocalCodeSignService" },
227 { INTELL_VOICE_SERVICE_ID, "IntellVoiceService" },
228 { FILE_ACCESS_SERVICE_ID, "FileAccessService" },
229 { MSDP_USER_STATUS_SERVICE_ID, "UserStatusAwarenessService" },
230 { NEARLINK_HOST_SYS_ABILITY_ID, "NearLinkHost" },
231 { ECOLOGICAL_RULE_MANAGER_SA_ID, "EcologicalRuleManager" },
232 { ASSET_SERVICE_ID, "AssetService" },
233 { TEST_SERVER_SA_ID, "TestServer" },
234 { APP_DOMAIN_VERIFY_MANAGER_SA_ID, "AppDomainVerifyManager" },
235 { APP_DOMAIN_VERIFY_AGENT_SA_ID, "AppDomainVerifyAgent" },
236 { AOT_COMPILER_SERVICE_ID, "AotCompilerService" },
237 { EL5_FILEKEY_MANAGER_SERVICE_ID, "El5FilekeyManager"},
238 { COMM_FIREWALL_MANAGER_SYS_ABILITY_ID, "NetFirewallManager" },
239 { SUBSYS_WEBVIEW_SYS_UPDATE_SERVICE_ID, "AppFwkUpdateService"},
240 };
241
242 namespace HiviewDFX {
IgnorePipeQuit()243 void DumpUtils::IgnorePipeQuit()
244 {
245 signal(SIGPIPE, SIG_IGN); // protect from pipe quit
246 }
247
IgnoreStdoutCache()248 void DumpUtils::IgnoreStdoutCache()
249 {
250 setvbuf(stdout, nullptr, _IONBF, 0); // never cache stdout
251 }
252
IgnoreOom()253 void DumpUtils::IgnoreOom()
254 {
255 setpriority(PRIO_PROCESS, 0, TOP_PRIORITY); // protect from OOM
256 }
257
SetAdj(int adj)258 void DumpUtils::SetAdj(int adj)
259 {
260 int fd = FdToWrite(FILE_CUR_OOM_ADJ);
261 if (fd < 0) {
262 return;
263 }
264 dprintf(fd, "%d", adj);
265 close(fd);
266 }
267
BoostPriority()268 void DumpUtils::BoostPriority()
269 {
270 IgnoreOom();
271 IgnorePipeQuit();
272 IgnoreStdoutCache();
273 SetAdj(TOP_OOM_ADJ);
274 }
275
ErrnoToMsg(const int & error)276 std::string DumpUtils::ErrnoToMsg(const int &error)
277 {
278 const int bufSize = 128;
279 char buf[bufSize] = {0};
280 strerror_r(error, buf, bufSize);
281 return buf;
282 }
283
FdToRead(const std::string & file)284 int DumpUtils::FdToRead(const std::string &file)
285 {
286 char path[PATH_MAX] = {0};
287 if (realpath(file.c_str(), path) == nullptr) {
288 DUMPER_HILOGE(MODULE_COMMON, "realpath, no such file. path=[%{public}s], file=[%{public}s]",
289 path, file.c_str());
290 return -1;
291 }
292
293 if (file != std::string(path)) {
294 DUMPER_HILOGI(MODULE_COMMON, "fail to check consistency. path=[%{public}s], file=[%{public}s]",
295 path, file.c_str());
296 }
297
298 int fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC | O_NONBLOCK));
299 if (fd == -1) {
300 DUMPER_HILOGE(MODULE_COMMON, "open [%{public}s] %{public}s", path, ErrnoToMsg(errno).c_str());
301 }
302 return fd;
303 }
304
FdToWrite(const std::string & file)305 int DumpUtils::FdToWrite(const std::string &file)
306 {
307 std::string split = "/";
308 auto pos = file.find_last_of(split);
309 if (pos == std::string::npos) {
310 DUMPER_HILOGE(MODULE_COMMON, "file path:[%{public}s] error", file.c_str());
311 return -1;
312 }
313 std::string tempPath = file.substr(0, pos + 1);
314 std::string name = file.substr(pos + 1);
315
316 char path[PATH_MAX] = {0};
317 if (realpath(tempPath.c_str(), path) != nullptr) {
318 std::string fileName = path + split + name;
319 int fd = -1;
320 if (access(fileName.c_str(), F_OK) == 0) {
321 fd = open(fileName.c_str(), O_WRONLY);
322 if (lseek(fd, 0, SEEK_END) == -1) {
323 DUMPER_HILOGE(MODULE_COMMON, "lseek fail fd:%{public}d, errno:%{public}d", fd, errno);
324 }
325 } else {
326 fd = TEMP_FAILURE_RETRY(open(fileName.c_str(), O_WRONLY | O_CREAT | O_CLOEXEC | O_NOFOLLOW,
327 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
328 }
329 if (fd == -1) {
330 DUMPER_HILOGE(MODULE_COMMON, "open [%{public}s] %{public}s",
331 fileName.c_str(), ErrnoToMsg(errno).c_str());
332 }
333 return fd;
334 }
335 DUMPER_HILOGD(MODULE_COMMON, "realpath, no such file. path=[%{public}s], tempPath=[%{public}s]",
336 path, tempPath.c_str());
337 return -1;
338 }
339
CheckProcessAlive(uint32_t pid)340 bool DumpUtils::CheckProcessAlive(uint32_t pid)
341 {
342 char path[PATH_MAX] = {0};
343 char pathPid[PATH_MAX] = {0};
344 int ret = sprintf_s(pathPid, PATH_MAX, "/proc/%u", pid);
345 if (ret < 0) {
346 return false;
347 }
348 if (realpath(pathPid, path) != nullptr) { // path exist
349 if (access(path, F_OK) == 0) { // can be read
350 return true;
351 }
352 }
353 return false;
354 }
355
RemoveDuplicateString(std::vector<std::string> & strList)356 void DumpUtils::RemoveDuplicateString(std::vector<std::string> &strList)
357 {
358 std::vector<std::string> tmpVtr;
359 std::set<std::string> tmpSet;
360 for (auto &it : strList) {
361 auto ret = tmpSet.insert(it);
362 if (ret.second) {
363 tmpVtr.push_back(it);
364 }
365 }
366 strList = tmpVtr;
367 }
368
StrToId(const std::string & name)369 int DumpUtils::StrToId(const std::string &name)
370 {
371 int id = -1;
372 auto iter = std::find_if(saNameMap_.begin(), saNameMap_.end(), [&](const std::pair<int, std::string> &item) {
373 return name.compare(item.second) == 0;
374 });
375 if (iter == saNameMap_.end()) {
376 if (!StrToInt(name, id)) { // Decimal string
377 return -1; // invalid ability ID
378 }
379 } else {
380 id = iter->first;
381 }
382 return id;
383 }
384
ConvertSaIdToSaName(const std::string & saIdStr)385 std::string DumpUtils::ConvertSaIdToSaName(const std::string &saIdStr)
386 {
387 int saId = StrToId(saIdStr);
388 auto iter = saNameMap_.find(saId);
389 if (iter == saNameMap_.end()) {
390 return saIdStr;
391 }
392 return iter->second;
393 }
394
DirectoryExists(const std::string & path)395 bool DumpUtils::DirectoryExists(const std::string &path)
396 {
397 struct stat fileInfo;
398 if (stat(path.c_str(), &fileInfo) == 0) {
399 return S_ISDIR(fileInfo.st_mode);
400 }
401 return false;
402 }
403
PathIsValid(const std::string & path)404 bool DumpUtils::PathIsValid(const std::string &path)
405 {
406 return access(path.c_str(), F_OK) == 0;
407 }
408
CopyFile(const std::string & src,const std::string & des)409 bool DumpUtils::CopyFile(const std::string &src, const std::string &des)
410 {
411 std::ifstream fin(src);
412 std::ofstream fout(des);
413 if ((!fin.is_open()) || (!fout.is_open())) {
414 return false;
415 }
416 fout << fin.rdbuf();
417 if (fout.fail()) {
418 fout.clear();
419 }
420 fout.flush();
421 return true;
422 }
423
IsCommercialVersion()424 bool DumpUtils::IsCommercialVersion()
425 {
426 bool isCommercialVersion = OHOS::system::GetParameter("const.logsystem.versiontype", "unknown") == "commercial";
427 return isCommercialVersion;
428 }
429
IsUserMode()430 bool DumpUtils::IsUserMode()
431 {
432 std::string debugMode = "0";
433 debugMode = OHOS::system::GetParameter("const.debuggable", debugMode);
434 return debugMode == "0";
435 }
436
CheckAppDebugVersion(int pid)437 bool DumpUtils::CheckAppDebugVersion(int pid)
438 {
439 if (pid <= 0) {
440 DUMPER_HILOGE(MODULE_COMMON, "AppDebugVersion pid %{public}d false", pid);
441 return false;
442 }
443 std::string bundleName;
444 std::string filePath = "/proc/" + std::to_string(pid) + "/cmdline";
445 if (!OHOS::LoadStringFromFile(filePath, bundleName)) {
446 DUMPER_HILOGE(MODULE_COMMON, "Get process name by pid %{public}d failed!", pid);
447 return false;
448 }
449 if (bundleName.empty()) {
450 DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d or process name is illegal!", pid);
451 return false;
452 }
453 auto pos = bundleName.find(":");
454 if (pos != std::string::npos) {
455 bundleName = bundleName.substr(0, pos);
456 }
457 std::string appName = bundleName.substr(0, strlen(bundleName.c_str()));
458 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
459 if (sam == nullptr) {
460 DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d GetSystemAbilityManager", pid);
461 return false;
462 }
463 sptr<IRemoteObject> remoteObject = sam->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
464 if (remoteObject == nullptr) {
465 DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d Get BundleMgr SA failed!", pid);
466 return false;
467 }
468 #ifdef HIDUMPER_BUNDLEMANAGER_FRAMEWORK_ENABLE
469 sptr<AppExecFwk::BundleMgrProxy> proxy = iface_cast<AppExecFwk::BundleMgrProxy>(remoteObject);
470 AppExecFwk::ApplicationInfo appInfo;
471 bool ret = proxy->GetApplicationInfo(appName, AppExecFwk::GET_APPLICATION_INFO_WITH_DISABLE,
472 AppExecFwk::Constants::ANY_USERID, appInfo);
473 if (!ret) {
474 DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d %{public}s Get App info failed!", pid, appName.c_str());
475 return false;
476 }
477 bool isDebugApp = (appInfo.appProvisionType == AppExecFwk::Constants::APP_PROVISION_TYPE_DEBUG);
478 DUMPER_HILOGD(MODULE_COMMON, "debug|pid %{public}d %{public}s DebugVersion %{public}d",
479 pid, appName.c_str(), isDebugApp);
480 return isDebugApp;
481 #else
482 DUMPER_HILOGD(MODULE_COMMON, "debug|pid %{public}d %{public}s DebugVersion false", pid, appName.c_str());
483 return false;
484 #endif
485 }
486
IsHmKernel()487 bool DumpUtils::IsHmKernel()
488 {
489 bool isHM = false;
490 utsname unameBuf;
491 if ((uname(&unameBuf)) == 0) {
492 std::string osRelease = unameBuf.release;
493 isHM = osRelease.find("HongMeng") != std::string::npos;
494 }
495 return isHM;
496 }
497 } // namespace HiviewDFX
498 } // namespace OHOS
499