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