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
30using ::android::hardware::memtrack::V1_0::IMemtrack;
31using ::android::hardware::memtrack::V1_0::MemtrackRecord;
32using ::android::hardware::memtrack::V1_0::MemtrackFlag;
33using ::android::hardware::memtrack::V1_0::MemtrackType;
34using ::android::hardware::memtrack::V1_0::MemtrackStatus;
35using ::android::hardware::hidl_vec;
36using ::android::hardware::Return;
37using ::android::sp;
38using ::android::base::unique_fd;
39using std::vector;
40using std::count_if;
41
42// Test environment for Memtrack HIDL HAL.
43class MemtrackHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
44   public:
45    // get the test environment singleton
46    static MemtrackHidlEnvironment* Instance() {
47        static MemtrackHidlEnvironment* instance = new MemtrackHidlEnvironment;
48        return instance;
49    }
50
51    virtual void registerTestServices() override { registerTestService<IMemtrack>(); }
52};
53
54class MemtrackHidlTest : public ::testing::VtsHalHidlTargetTestBase {
55 public:
56  virtual void SetUp() override {
57      memtrack = ::testing::VtsHalHidlTargetTestBase::getService<IMemtrack>(
58          MemtrackHidlEnvironment::Instance()->getServiceName<IMemtrack>());
59      ASSERT_NE(memtrack, nullptr);
60  }
61
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 */
70bool 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 */
80bool 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
87auto 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 */
96TEST_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 */
111TEST_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 */
124TEST_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
175int 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