1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 //#define LOG_NDEBUG 0
18 #define LOG_TAG "ProcessInfo"
19 #include <utils/Log.h>
20
21 #include <mediautils/ProcessInfo.h>
22
23 #include <binder/IPCThreadState.h>
24 #include <binder/IServiceManager.h>
25 #include <private/android_filesystem_config.h>
26 #include <processinfo/IProcessInfoService.h>
27
28 namespace android {
29
30 static constexpr int32_t INVALID_ADJ = -10000;
31 static constexpr int32_t NATIVE_ADJ = -1000;
32
33 /* Make sure this matches with ActivityManager::PROCESS_STATE_NONEXISTENT
34 * #include <binder/ActivityManager.h>
35 * using ActivityManager::PROCESS_STATE_NONEXISTENT;
36 */
37 static constexpr int32_t PROCESS_STATE_NONEXISTENT = 20;
38
ProcessInfo()39 ProcessInfo::ProcessInfo() {}
40
41 /*
42 * Checks whether the list of processes with given pids exist or not.
43 *
44 * Arguments:
45 * - pids (input): List of pids for which to check whether they are Existent or not.
46 * - existent (output): boolean vector corresponds to Existent state of each pids.
47 *
48 * On successful return:
49 * - existent[i] true corresponds to pids[i] still active and
50 * - existent[i] false corresponds to pids[i] already terminated (Nonexistent)
51 * On unsuccessful return, the output argument existent is invalid.
52 */
checkProcessExistent(const std::vector<int32_t> & pids,std::vector<bool> * existent)53 bool ProcessInfo::checkProcessExistent(const std::vector<int32_t>& pids,
54 std::vector<bool>* existent) {
55 sp<IBinder> binder = defaultServiceManager()->waitForService(String16("processinfo"));
56 sp<IProcessInfoService> service = interface_cast<IProcessInfoService>(binder);
57
58 // Get the process state of the applications managed/tracked by the ActivityManagerService.
59 // Don't have to look into the native processes.
60 // If we really need the state of native process, then we can use ==> mOverrideMap
61 size_t count = pids.size();
62 std::vector<int32_t> states(count, PROCESS_STATE_NONEXISTENT);
63 status_t err = service->getProcessStatesFromPids(count,
64 const_cast<int32_t*>(pids.data()),
65 states.data());
66 if (err != OK) {
67 ALOGE("%s: IProcessInfoService::getProcessStatesFromPids failed with %d",
68 __func__, err);
69 return false;
70 }
71
72 existent->clear();
73 for (size_t index = 0; index < states.size(); index++) {
74 // If this process is not tracked by ActivityManagerService, look for overrides.
75 if (states[index] == PROCESS_STATE_NONEXISTENT) {
76 std::scoped_lock lock{mOverrideLock};
77 std::map<int, ProcessInfoOverride>::iterator it =
78 mOverrideMap.find(pids[index]);
79 if (it != mOverrideMap.end()) {
80 states[index] = it->second.procState;
81 }
82 }
83 existent->push_back(states[index] != PROCESS_STATE_NONEXISTENT);
84 }
85
86 return true;
87 }
88
getPriority(int pid,int * priority)89 bool ProcessInfo::getPriority(int pid, int* priority) {
90 sp<IBinder> binder = defaultServiceManager()->waitForService(String16("processinfo"));
91 sp<IProcessInfoService> service = interface_cast<IProcessInfoService>(binder);
92
93 size_t length = 1;
94 int32_t state;
95 int32_t score = INVALID_ADJ;
96 status_t err = service->getProcessStatesAndOomScoresFromPids(length, &pid, &state, &score);
97 ALOGV("%s: pid:%d state:%d score:%d err:%d", __FUNCTION__, pid, state, score, err);
98 if (err != OK) {
99 ALOGE("getProcessStatesAndOomScoresFromPids failed");
100 return false;
101 }
102 if (score <= NATIVE_ADJ) {
103 std::scoped_lock lock{mOverrideLock};
104
105 // If this process if not tracked by ActivityManagerService, look for overrides.
106 auto it = mOverrideMap.find(pid);
107 if (it != mOverrideMap.end()) {
108 ALOGI("pid %d invalid OOM score %d, override to %d", pid, score, it->second.oomScore);
109 score = it->second.oomScore;
110 } else {
111 ALOGE("pid %d invalid OOM score %d", pid, score);
112 return false;
113 }
114 }
115
116 // Use OOM adjustments value as the priority. Lower the value, higher the priority.
117 *priority = score;
118 return true;
119 }
120
isPidTrusted(int pid)121 bool ProcessInfo::isPidTrusted(int pid) {
122 return isPidUidTrusted(pid, -1);
123 }
124
isPidUidTrusted(int pid,int uid)125 bool ProcessInfo::isPidUidTrusted(int pid, int uid) {
126 int callingPid = IPCThreadState::self()->getCallingPid();
127 int callingUid = IPCThreadState::self()->getCallingUid();
128 // Always trust when the caller is acting on their own behalf.
129 if (pid == callingPid && (uid == callingUid || uid == -1)) { // UID can be optional
130 return true;
131 }
132 // Implicitly trust when the caller is our own process.
133 if (callingPid == getpid()) {
134 return true;
135 }
136 // Implicitly trust when a media process is calling.
137 if (callingUid == AID_MEDIA) {
138 return true;
139 }
140 // Otherwise, allow the caller to act as another process when the caller has permissions.
141 return checkCallingPermission(String16("android.permission.MEDIA_RESOURCE_OVERRIDE_PID"));
142 }
143
overrideProcessInfo(int pid,int procState,int oomScore)144 bool ProcessInfo::overrideProcessInfo(int pid, int procState, int oomScore) {
145 std::scoped_lock lock{mOverrideLock};
146
147 mOverrideMap.erase(pid);
148
149 // Disable the override if oomScore is set to NATIVE_ADJ or below.
150 if (oomScore <= NATIVE_ADJ) {
151 return false;
152 }
153
154 mOverrideMap.emplace(pid, ProcessInfoOverride{procState, oomScore});
155 return true;
156 }
157
removeProcessInfoOverride(int pid)158 void ProcessInfo::removeProcessInfoOverride(int pid) {
159 std::scoped_lock lock{mOverrideLock};
160
161 mOverrideMap.erase(pid);
162 }
163
~ProcessInfo()164 ProcessInfo::~ProcessInfo() {}
165
166 } // namespace android
167