1 /*
2 * Copyright (C) 2016 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_TAG "memtrack_hidl_hal_test"
18 #include <android-base/logging.h>
19 #include <android-base/unique_fd.h>
20
21 #include <android/hardware/memtrack/1.0/IMemtrack.h>
22
23 #include <VtsHalHidlTargetTestBase.h>
24 #include <VtsHalHidlTargetTestEnvBase.h>
25
26 #include <fcntl.h>
27 #include <algorithm>
28 #include <vector>
29
30 using ::android::hardware::memtrack::V1_0::IMemtrack;
31 using ::android::hardware::memtrack::V1_0::MemtrackRecord;
32 using ::android::hardware::memtrack::V1_0::MemtrackFlag;
33 using ::android::hardware::memtrack::V1_0::MemtrackType;
34 using ::android::hardware::memtrack::V1_0::MemtrackStatus;
35 using ::android::hardware::hidl_vec;
36 using ::android::hardware::Return;
37 using ::android::sp;
38 using ::android::base::unique_fd;
39 using std::vector;
40 using std::count_if;
41
42 // Test environment for Memtrack HIDL HAL.
43 class MemtrackHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
44 public:
45 // get the test environment singleton
Instance()46 static MemtrackHidlEnvironment* Instance() {
47 static MemtrackHidlEnvironment* instance = new MemtrackHidlEnvironment;
48 return instance;
49 }
50
registerTestServices()51 virtual void registerTestServices() override { registerTestService<IMemtrack>(); }
52 };
53
54 class MemtrackHidlTest : public ::testing::VtsHalHidlTargetTestBase {
55 public:
SetUp()56 virtual void SetUp() override {
57 memtrack = ::testing::VtsHalHidlTargetTestBase::getService<IMemtrack>(
58 MemtrackHidlEnvironment::Instance()->getServiceName<IMemtrack>());
59 ASSERT_NE(memtrack, nullptr);
60 }
61
TearDown()62 virtual void TearDown() override {}
63
64 sp<IMemtrack> memtrack;
65 };
66
67 /* Returns true if flags contains at least min, and no more than max,
68 * of the flags in flagSet. Returns false otherwise.
69 */
rightFlagCount(uint32_t flags,vector<MemtrackFlag> flagSet,uint32_t min,uint32_t max)70 bool rightFlagCount(uint32_t flags, vector<MemtrackFlag> flagSet, uint32_t min,
71 uint32_t max) {
72 uint32_t count =
73 count_if(flagSet.begin(), flagSet.end(),
74 [&](MemtrackFlag f) { return flags & (uint32_t)f; });
75 return (min <= count && count <= max);
76 }
77
78 /* Returns true when passed a valid, defined status, false otherwise.
79 */
validStatus(MemtrackStatus s)80 bool validStatus(MemtrackStatus s) {
81 vector<MemtrackStatus> statusVec = {
82 MemtrackStatus::SUCCESS, MemtrackStatus::MEMORY_TRACKING_NOT_SUPPORTED,
83 MemtrackStatus::TYPE_NOT_SUPPORTED};
84 return std::find(statusVec.begin(), statusVec.end(), s) != statusVec.end();
85 }
86
generate_cb(MemtrackStatus * s,hidl_vec<MemtrackRecord> * v)87 auto generate_cb(MemtrackStatus *s, hidl_vec<MemtrackRecord> *v) {
88 return [=](MemtrackStatus status, hidl_vec<MemtrackRecord> vec) {
89 *s = status;
90 *v = vec;
91 };
92 }
93
94 /* Sanity check results when getMemory() is passed a negative PID
95 */
TEST_F(MemtrackHidlTest,BadPidTest)96 TEST_F(MemtrackHidlTest, BadPidTest) {
97 MemtrackStatus s;
98 hidl_vec<MemtrackRecord> v;
99 auto cb = generate_cb(&s, &v);
100 for (uint32_t i = 0; i < static_cast<uint32_t>(MemtrackType::NUM_TYPES);
101 i++) {
102 Return<void> ret =
103 memtrack->getMemory(-1, static_cast<MemtrackType>(i), cb);
104 ASSERT_TRUE(ret.isOk());
105 ASSERT_TRUE(validStatus(s));
106 }
107 }
108
109 /* Sanity check results when getMemory() is passed a bad memory usage type
110 */
TEST_F(MemtrackHidlTest,BadTypeTest)111 TEST_F(MemtrackHidlTest, BadTypeTest) {
112 MemtrackStatus s;
113 hidl_vec<MemtrackRecord> v;
114 auto cb = generate_cb(&s, &v);
115 Return<void> ret = memtrack->getMemory(getpid(), MemtrackType::NUM_TYPES, cb);
116 ASSERT_TRUE(ret.isOk());
117 ASSERT_TRUE(validStatus(s));
118 }
119
120 /* Call memtrack on this process and check that the results are reasonable
121 * for all memory types, including valid flag combinations for every
122 * MemtrackRecord returned.
123 */
TEST_F(MemtrackHidlTest,GetMemoryTest)124 TEST_F(MemtrackHidlTest, GetMemoryTest) {
125 /* Opening this device causes the kernel to provide memtrack with memory
126 * info for this process.
127 */
128 unique_fd fd(open("/dev/kgsl-3d0", O_RDWR));
129
130 MemtrackStatus s;
131 hidl_vec<MemtrackRecord> v;
132 auto cb = generate_cb(&s, &v);
133 uint32_t unsupportedCount = 0;
134 for (uint32_t i = 0; i < static_cast<uint32_t>(MemtrackType::NUM_TYPES);
135 i++) {
136 Return<void> ret =
137 memtrack->getMemory(getpid(), static_cast<MemtrackType>(i), cb);
138 ASSERT_TRUE(ret.isOk());
139
140 switch (s) {
141 case MemtrackStatus::MEMORY_TRACKING_NOT_SUPPORTED:
142 unsupportedCount++;
143 break;
144 case MemtrackStatus::TYPE_NOT_SUPPORTED:
145 break;
146 case MemtrackStatus::SUCCESS: {
147 for (uint32_t j = 0; j < v.size(); j++) {
148 // Enforce flag constraints
149 vector<MemtrackFlag> smapFlags = {MemtrackFlag::SMAPS_ACCOUNTED,
150 MemtrackFlag::SMAPS_UNACCOUNTED};
151 EXPECT_TRUE(rightFlagCount(v[j].flags, smapFlags, 1, 1));
152 vector<MemtrackFlag> shareFlags = {MemtrackFlag::SHARED,
153 MemtrackFlag::SHARED_PSS,
154 MemtrackFlag::PRIVATE};
155 EXPECT_TRUE(rightFlagCount(v[j].flags, shareFlags, 0, 1));
156 vector<MemtrackFlag> systemFlags = {MemtrackFlag::SYSTEM,
157 MemtrackFlag::DEDICATED};
158 EXPECT_TRUE(rightFlagCount(v[j].flags, systemFlags, 0, 1));
159 vector<MemtrackFlag> secureFlags = {MemtrackFlag::SECURE,
160 MemtrackFlag::NONSECURE};
161 EXPECT_TRUE(rightFlagCount(v[j].flags, secureFlags, 0, 1));
162 }
163 break;
164 }
165 default:
166 FAIL();
167 }
168 }
169 // If tracking is not supported this should be returned for all types.
170 ASSERT_TRUE(unsupportedCount == 0 ||
171 unsupportedCount ==
172 static_cast<uint32_t>(MemtrackType::NUM_TYPES));
173 }
174
main(int argc,char ** argv)175 int main(int argc, char **argv) {
176 ::testing::AddGlobalTestEnvironment(MemtrackHidlEnvironment::Instance());
177 ::testing::InitGoogleTest(&argc, argv);
178 MemtrackHidlEnvironment::Instance()->init(&argc, argv);
179 int status = RUN_ALL_TESTS();
180 LOG(INFO) << "Test result = " << status;
181 return status;
182 }
183