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 { SELECTION_FWK_SA_ID, "SelectionService" },
241 { MECH_BODY_SA_ID, "MechBodyController" },
242 };
243
244 namespace HiviewDFX {
IgnorePipeQuit()245 void DumpUtils::IgnorePipeQuit()
246 {
247 signal(SIGPIPE, SIG_IGN); // protect from pipe quit
248 }
249
IgnoreStdoutCache()250 void DumpUtils::IgnoreStdoutCache()
251 {
252 setvbuf(stdout, nullptr, _IONBF, 0); // never cache stdout
253 }
254
IgnoreOom()255 void DumpUtils::IgnoreOom()
256 {
257 setpriority(PRIO_PROCESS, 0, TOP_PRIORITY); // protect from OOM
258 }
259
SetAdj(int adj)260 void DumpUtils::SetAdj(int adj)
261 {
262 int fd = FdToWrite(FILE_CUR_OOM_ADJ);
263 if (fd < 0) {
264 return;
265 }
266 dprintf(fd, "%d", adj);
267 close(fd);
268 }
269
BoostPriority()270 void DumpUtils::BoostPriority()
271 {
272 IgnoreOom();
273 IgnorePipeQuit();
274 IgnoreStdoutCache();
275 SetAdj(TOP_OOM_ADJ);
276 }
277
ErrnoToMsg(const int & error)278 std::string DumpUtils::ErrnoToMsg(const int &error)
279 {
280 const int bufSize = 128;
281 char buf[bufSize] = {0};
282 strerror_r(error, buf, bufSize);
283 return buf;
284 }
285
FdToRead(const std::string & file)286 int DumpUtils::FdToRead(const std::string &file)
287 {
288 char path[PATH_MAX] = {0};
289 if (realpath(file.c_str(), path) == nullptr) {
290 DUMPER_HILOGE(MODULE_COMMON, "realpath, no such file. path=[%{public}s], file=[%{public}s]",
291 path, file.c_str());
292 return -1;
293 }
294
295 if (file != std::string(path)) {
296 DUMPER_HILOGI(MODULE_COMMON, "fail to check consistency. path=[%{public}s], file=[%{public}s]",
297 path, file.c_str());
298 }
299
300 int fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC | O_NONBLOCK));
301 if (fd == -1) {
302 DUMPER_HILOGE(MODULE_COMMON, "open [%{public}s] %{public}s", path, ErrnoToMsg(errno).c_str());
303 }
304 return fd;
305 }
306
FdToWrite(const std::string & file)307 int DumpUtils::FdToWrite(const std::string &file)
308 {
309 std::string split = "/";
310 auto pos = file.find_last_of(split);
311 if (pos == std::string::npos) {
312 DUMPER_HILOGE(MODULE_COMMON, "file path:[%{public}s] error", file.c_str());
313 return -1;
314 }
315 std::string tempPath = file.substr(0, pos + 1);
316 std::string name = file.substr(pos + 1);
317
318 char path[PATH_MAX] = {0};
319 if (realpath(tempPath.c_str(), path) != nullptr) {
320 std::string fileName = path + split + name;
321 int fd = -1;
322 if (access(fileName.c_str(), F_OK) == 0) {
323 fd = open(fileName.c_str(), O_WRONLY);
324 if (lseek(fd, 0, SEEK_END) == -1) {
325 DUMPER_HILOGE(MODULE_COMMON, "lseek fail fd:%{public}d, errno:%{public}d", fd, errno);
326 }
327 } else {
328 fd = TEMP_FAILURE_RETRY(open(fileName.c_str(), O_WRONLY | O_CREAT | O_CLOEXEC | O_NOFOLLOW,
329 S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
330 }
331 if (fd == -1) {
332 DUMPER_HILOGE(MODULE_COMMON, "open [%{public}s] %{public}s",
333 fileName.c_str(), ErrnoToMsg(errno).c_str());
334 }
335 return fd;
336 }
337 DUMPER_HILOGD(MODULE_COMMON, "realpath, no such file. path=[%{public}s], tempPath=[%{public}s]",
338 path, tempPath.c_str());
339 return -1;
340 }
341
CheckProcessAlive(uint32_t pid)342 bool DumpUtils::CheckProcessAlive(uint32_t pid)
343 {
344 char path[PATH_MAX] = {0};
345 char pathPid[PATH_MAX] = {0};
346 int ret = sprintf_s(pathPid, PATH_MAX, "/proc/%u", pid);
347 if (ret < 0) {
348 return false;
349 }
350 if (realpath(pathPid, path) != nullptr) { // path exist
351 if (access(path, F_OK) == 0) { // can be read
352 return true;
353 }
354 }
355 return false;
356 }
357
RemoveDuplicateString(std::vector<std::string> & strList)358 void DumpUtils::RemoveDuplicateString(std::vector<std::string> &strList)
359 {
360 std::vector<std::string> tmpVtr;
361 std::set<std::string> tmpSet;
362 for (auto &it : strList) {
363 auto ret = tmpSet.insert(it);
364 if (ret.second) {
365 tmpVtr.push_back(it);
366 }
367 }
368 strList = tmpVtr;
369 }
370
StrToId(const std::string & name)371 int DumpUtils::StrToId(const std::string &name)
372 {
373 int id = -1;
374 auto iter = std::find_if(saNameMap_.begin(), saNameMap_.end(), [&](const std::pair<int, std::string> &item) {
375 return name.compare(item.second) == 0;
376 });
377 if (iter == saNameMap_.end()) {
378 if (!StrToInt(name, id)) { // Decimal string
379 return -1; // invalid ability ID
380 }
381 } else {
382 id = iter->first;
383 }
384 return id;
385 }
386
ConvertSaIdToSaName(const std::string & saIdStr)387 std::string DumpUtils::ConvertSaIdToSaName(const std::string &saIdStr)
388 {
389 int saId = StrToId(saIdStr);
390 auto iter = saNameMap_.find(saId);
391 if (iter == saNameMap_.end()) {
392 return saIdStr;
393 }
394 return iter->second;
395 }
396
DirectoryExists(const std::string & path)397 bool DumpUtils::DirectoryExists(const std::string &path)
398 {
399 struct stat fileInfo;
400 if (stat(path.c_str(), &fileInfo) == 0) {
401 return S_ISDIR(fileInfo.st_mode);
402 }
403 return false;
404 }
405
PathIsValid(const std::string & path)406 bool DumpUtils::PathIsValid(const std::string &path)
407 {
408 return access(path.c_str(), F_OK) == 0;
409 }
410
CopyFile(const std::string & src,const std::string & des)411 bool DumpUtils::CopyFile(const std::string &src, const std::string &des)
412 {
413 std::ifstream fin(src);
414 std::ofstream fout(des);
415 if ((!fin.is_open()) || (!fout.is_open())) {
416 return false;
417 }
418 fout << fin.rdbuf();
419 if (fout.fail()) {
420 fout.clear();
421 }
422 fout.flush();
423 return true;
424 }
425
IsCommercialVersion()426 bool DumpUtils::IsCommercialVersion()
427 {
428 bool isCommercialVersion = OHOS::system::GetParameter("const.logsystem.versiontype", "unknown") == "commercial";
429 return isCommercialVersion;
430 }
431
IsUserMode()432 bool DumpUtils::IsUserMode()
433 {
434 std::string debugMode = "0";
435 debugMode = OHOS::system::GetParameter("const.debuggable", debugMode);
436 return debugMode == "0";
437 }
438
CheckAppDebugVersion(int pid)439 bool DumpUtils::CheckAppDebugVersion(int pid)
440 {
441 if (pid <= 0) {
442 DUMPER_HILOGE(MODULE_COMMON, "AppDebugVersion pid %{public}d false", pid);
443 return false;
444 }
445 std::string bundleName;
446 std::string filePath = "/proc/" + std::to_string(pid) + "/cmdline";
447 if (!OHOS::LoadStringFromFile(filePath, bundleName)) {
448 DUMPER_HILOGE(MODULE_COMMON, "Get process name by pid %{public}d failed!", pid);
449 return false;
450 }
451 if (bundleName.empty()) {
452 DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d or process name is illegal!", pid);
453 return false;
454 }
455 auto pos = bundleName.find(":");
456 if (pos != std::string::npos) {
457 bundleName = bundleName.substr(0, pos);
458 }
459 std::string appName = bundleName.substr(0, strlen(bundleName.c_str()));
460 sptr<ISystemAbilityManager> sam = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
461 if (sam == nullptr) {
462 DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d GetSystemAbilityManager", pid);
463 return false;
464 }
465 sptr<IRemoteObject> remoteObject = sam->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
466 if (remoteObject == nullptr) {
467 DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d Get BundleMgr SA failed!", pid);
468 return false;
469 }
470 #ifdef HIDUMPER_BUNDLEMANAGER_FRAMEWORK_ENABLE
471 sptr<AppExecFwk::BundleMgrProxy> proxy = iface_cast<AppExecFwk::BundleMgrProxy>(remoteObject);
472 AppExecFwk::ApplicationInfo appInfo;
473 bool ret = proxy->GetApplicationInfo(appName, AppExecFwk::GET_APPLICATION_INFO_WITH_DISABLE,
474 AppExecFwk::Constants::ANY_USERID, appInfo);
475 if (!ret) {
476 DUMPER_HILOGE(MODULE_COMMON, "Pid %{public}d %{public}s Get App info failed!", pid, appName.c_str());
477 return false;
478 }
479 bool isDebugApp = (appInfo.appProvisionType == AppExecFwk::Constants::APP_PROVISION_TYPE_DEBUG);
480 DUMPER_HILOGD(MODULE_COMMON, "debug|pid %{public}d %{public}s DebugVersion %{public}d",
481 pid, appName.c_str(), isDebugApp);
482 return isDebugApp;
483 #else
484 DUMPER_HILOGD(MODULE_COMMON, "debug|pid %{public}d %{public}s DebugVersion false", pid, appName.c_str());
485 return false;
486 #endif
487 }
488
IsHmKernel()489 bool DumpUtils::IsHmKernel()
490 {
491 bool isHM = false;
492 utsname unameBuf;
493 if ((uname(&unameBuf)) == 0) {
494 std::string osRelease = unameBuf.release;
495 isHM = osRelease.find("HongMeng") != std::string::npos;
496 }
497 return isHM;
498 }
499 } // namespace HiviewDFX
500 } // namespace OHOS
501