Evolution-x/hardware_interfaces
1
0
Fork 0
mirror of https://github.com/Evolution-X/hardware_interfaces synced 2026-02-01 10:44:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Memtrack HAL: Add stable AIDL implementation"

Browse Source 
Revert "libmemtrack: Add support for AIDL memtrack HAL"

Revert "Add stable aidl memtrack HAL to product packages"

Revert "Add stable aidl memtrack hal to vndk list"

Revert "Memtrack HAL stable aidl sepolicy"

Revert "Add android.hardware.memtrack-unstable-ndk_platform"

Revert submission 1518702-memtrack-aidl

Reason for revert: Broken tests and boot time regressions
Reverted Changes:
Ic4dd70e2c:Add android.hardware.memtrack-unstable-ndk_platfor...
Iaf99d0ca4:Add stable aidl memtrack HAL to product packages
Iac54ae2ba:Add stable aidl memtrack hal to vndk list
If310210a3:libmemtrack: Add support for AIDL memtrack HAL
Ib6c634def:Memtrack HAL: Add stable AIDL implementation
I5e1d0e006:Memtrack HAL stable aidl sepolicy

Change-Id: I4a9e3522afe9e9189b7eddc9520d5ef2e2b74520
This commit is contained in:
Kalesh Singh
2020-12-16 00:19:38 +00:00
parent f4ab018143
commit 28641ffb08
18 changed files with 0 additions and 597 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
compatibility_matrices/compatibility_matrix.current.xml
View File

@@ -334,13 +334,6 @@
<instance>default</instance>
</interface>
</hal>
<hal format="aidl" optional="true">
<name>android.hardware.memtrack</name>
<interface>
<name>IMemtrack</name>
<instance>default</instance>
</interface>
</hal>
<hal format="hidl" optional="true">
<name>android.hardware.memtrack</name>
<version>1.0</version>

33
memtrack/aidl/Android.bp
View File

@@ -1,33 +0,0 @@
// Copyright (C) 2020 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
aidl_interface {
name: "android.hardware.memtrack",
vendor_available: true,
srcs: ["android/hardware/memtrack/*.aidl"],
stability: "vintf",
backend: {
cpp: {
enabled: false,
},
java: {
enabled: false,
},
ndk: {
vndk: {
enabled: true,
},
},
},
}

23
memtrack/aidl/aidl_api/android.hardware.memtrack/current/android/hardware/memtrack/DeviceInfo.aidl
View File

@@ -1,23 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL interface (or parcelable). Do not try to
// edit this file. It looks like you are doing that because you have modified
// an AIDL interface in a backward-incompatible way, e.g., deleting a function
// from an interface or a field from a parcelable and it broke the build. That
// breakage is intended.
//
// You must not make a backward incompatible changes to the AIDL files built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.memtrack;
@VintfStability
parcelable DeviceInfo {
int id;
@utf8InCpp String name;
}

23
memtrack/aidl/aidl_api/android.hardware.memtrack/current/android/hardware/memtrack/IMemtrack.aidl
View File

@@ -1,23 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL interface (or parcelable). Do not try to
// edit this file. It looks like you are doing that because you have modified
// an AIDL interface in a backward-incompatible way, e.g., deleting a function
// from an interface or a field from a parcelable and it broke the build. That
// breakage is intended.
//
// You must not make a backward incompatible changes to the AIDL files built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.memtrack;
@VintfStability
interface IMemtrack {
android.hardware.memtrack.MemtrackRecord[] getMemory(in int pid, in android.hardware.memtrack.MemtrackType type);
android.hardware.memtrack.DeviceInfo[] getGpuDeviceInfo();
}

32
memtrack/aidl/aidl_api/android.hardware.memtrack/current/android/hardware/memtrack/MemtrackRecord.aidl
View File

@@ -1,32 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL interface (or parcelable). Do not try to
// edit this file. It looks like you are doing that because you have modified
// an AIDL interface in a backward-incompatible way, e.g., deleting a function
// from an interface or a field from a parcelable and it broke the build. That
// breakage is intended.
//
// You must not make a backward incompatible changes to the AIDL files built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.memtrack;
@VintfStability
parcelable MemtrackRecord {
int flags;
long sizeInBytes;
const int FLAG_SMAPS_ACCOUNTED = 2;
const int FLAG_SMAPS_UNACCOUNTED = 4;
const int FLAG_SHARED = 8;
const int FLAG_SHARED_PSS = 16;
const int FLAG_PRIVATE = 32;
const int FLAG_SYSTEM = 64;
const int FLAG_DEDICATED = 128;
const int FLAG_NONSECURE = 256;
const int FLAG_SECURE = 512;
}

27
memtrack/aidl/aidl_api/android.hardware.memtrack/current/android/hardware/memtrack/MemtrackType.aidl
View File

@@ -1,27 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// THIS FILE IS IMMUTABLE. DO NOT EDIT IN ANY CASE. //
///////////////////////////////////////////////////////////////////////////////
// This file is a snapshot of an AIDL interface (or parcelable). Do not try to
// edit this file. It looks like you are doing that because you have modified
// an AIDL interface in a backward-incompatible way, e.g., deleting a function
// from an interface or a field from a parcelable and it broke the build. That
// breakage is intended.
//
// You must not make a backward incompatible changes to the AIDL files built
// with the aidl_interface module type with versions property set. The module
// type is used to build AIDL files in a way that they can be used across
// independently updatable components of the system. If a device is shipped
// with such a backward incompatible change, it has a high risk of breaking
// later when a module using the interface is updated, e.g., Mainline modules.
package android.hardware.memtrack;
@Backing(type="int") @VintfStability
enum MemtrackType {
OTHER = 0,
GL = 1,
GRAPHICS = 2,
MULTIMEDIA = 3,
CAMERA = 4,
NUM_TYPES = 5,
}

29
memtrack/aidl/android/hardware/memtrack/DeviceInfo.aidl
View File

@@ -1,29 +0,0 @@
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware.memtrack;
/*
* A vector of DeviceInfo is returned by the function getGpuDeviceInfo().
* Each entry consists of the device name and the device id.
* See getGpuDeviceInfo() for further details.
*/
@VintfStability
parcelable DeviceInfo {
int id;
@utf8InCpp String name;
}

82
memtrack/aidl/android/hardware/memtrack/IMemtrack.aidl
View File

@@ -1,82 +0,0 @@
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware.memtrack;
import android.hardware.memtrack.DeviceInfo;
import android.hardware.memtrack.MemtrackRecord;
import android.hardware.memtrack.MemtrackType;
/**
* The Memory Tracker HAL is designed to return information about
* device-specific memory usage.
* The primary goal is to be able to track memory that is not
* trackable in any other way, for example texture memory that is allocated by
* a process, but not mapped in to that process's address space.
* A secondary goal is to be able to categorize memory used by a process into
* GL, graphics, etc. All memory sizes must be in real memory usage,
* accounting for stride, bit depth, rounding up to page size, etc.
*
* Constructor for the interface should be used to perform memtrack management
* setup actions and is called once before any calls to getMemory().
*/
@VintfStability
interface IMemtrack {
/**
* getMemory() populates MemtrackRecord vector with the sizes of memory
* plus associated flags for that memory.
*
* A process collecting memory statistics will call getMemory for each
* combination of pid and memory type. For each memory type that it
* recognizes, the HAL must fill out an array of memtrack_record
* structures breaking down the statistics of that memory type as much as
* possible. For example,
* getMemory(<pid>, GL) might return:
* { { 4096, ACCOUNTED | PRIVATE | SYSTEM },
* { 40960, UNACCOUNTED | PRIVATE | SYSTEM },
* { 8192, ACCOUNTED | PRIVATE | DEDICATED },
* { 8192, UNACCOUNTED | PRIVATE | DEDICATED } }
* If the HAL cannot differentiate between SYSTEM and DEDICATED memory, it
* could return:
* { { 12288, ACCOUNTED | PRIVATE },
* { 49152, UNACCOUNTED | PRIVATE } }
*
* Memory must not overlap between types. For example, a graphics buffer
* that has been mapped into the GPU as a surface must show up when
* GRAPHICS is requested and not when GL
* is requested.
*
* @param pid process for which memory information is requested
* @param type memory type that information is being requested about
* @return vector of MemtrackRecord containing memory information
*/
MemtrackRecord[] getMemory(in int pid, in MemtrackType type);
/**
* getGpuDeviceInfo() populates DeviceInfo with the ID and name
* of each GPU device.
*
* For example, getGpuDeviceInfor, might return:
* { { 0, <gpu-device-name> },
* { 1, <gpu-device-name> } }
*
* This information is used to identify GPU devices for GPU specific
* memory accounting (e.g. DMA buffer usage).
*
* @return vector of DeviceInfo populated for all GPU devices.
*/
DeviceInfo[] getGpuDeviceInfo();
}

43
memtrack/aidl/android/hardware/memtrack/MemtrackRecord.aidl
View File

@@ -1,43 +0,0 @@
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware.memtrack;
/*
* A vector of MemtrackRecord is returned by the function getMemory().
* Each record consists of the size of the memory used by the process and
* flags indicate all the MemtrackFlags that are valid for this record.
* see getMemory() comments for further details.
*/
@VintfStability
parcelable MemtrackRecord {
/* Memtrack Flags */
const int FLAG_SMAPS_ACCOUNTED = 1 << 1;
const int FLAG_SMAPS_UNACCOUNTED = 1 << 2;
const int FLAG_SHARED = 1 << 3;
const int FLAG_SHARED_PSS = 1 << 4;
const int FLAG_PRIVATE = 1 << 5;
const int FLAG_SYSTEM = 1 << 6;
const int FLAG_DEDICATED = 1 << 7;
const int FLAG_NONSECURE = 1 << 8;
const int FLAG_SECURE = 1 << 9;
/* Bitfield indicating all flags that are valid for this record */
int flags;
long sizeInBytes;
}

31
memtrack/aidl/android/hardware/memtrack/MemtrackType.aidl
View File

@@ -1,31 +0,0 @@
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.hardware.memtrack;
/**
* Tags which define the usage of the memory buffers.
*/
@VintfStability
@Backing(type="int")
enum MemtrackType {
OTHER = 0,
GL = 1,
GRAPHICS = 2,
MULTIMEDIA = 3,
CAMERA = 4,
NUM_TYPES,
}

30
memtrack/aidl/default/Android.bp
View File

@@ -1,30 +0,0 @@
// Copyright (C) 2020 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
cc_binary {
name: "android.hardware.memtrack-service.example",
relative_install_path: "hw",
init_rc: ["memtrack-default.rc"],
vintf_fragments: ["memtrack-default.xml"],
vendor: true,
shared_libs: [
"libbase",
"libbinder_ndk",
"android.hardware.memtrack-ndk_platform",
],
srcs: [
"main.cpp",
"Memtrack.cpp",
],
}

44
memtrack/aidl/default/Memtrack.cpp
View File

@@ -1,44 +0,0 @@
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "Memtrack.h"
namespace aidl {
namespace android {
namespace hardware {
namespace memtrack {
ndk::ScopedAStatus Memtrack::getMemory(int pid, MemtrackType type,
std::vector<MemtrackRecord>* _aidl_return) {
if (pid < 0) {
return ndk::ScopedAStatus(AStatus_fromExceptionCode(EX_ILLEGAL_ARGUMENT));
}
if (type < MemtrackType::OTHER || type >= MemtrackType::NUM_TYPES) {
return ndk::ScopedAStatus(AStatus_fromExceptionCode(EX_UNSUPPORTED_OPERATION));
}
_aidl_return->clear();
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Memtrack::getGpuDeviceInfo(std::vector<DeviceInfo>* _aidl_return) {
_aidl_return->clear();
return ndk::ScopedAStatus::ok();
}
} // namespace memtrack
} // namespace hardware
} // namespace android
} // namespace aidl

39
memtrack/aidl/default/Memtrack.h
View File

@@ -1,39 +0,0 @@
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <aidl/android/hardware/memtrack/BnMemtrack.h>
#include <aidl/android/hardware/memtrack/DeviceInfo.h>
#include <aidl/android/hardware/memtrack/MemtrackRecord.h>
#include <aidl/android/hardware/memtrack/MemtrackType.h>
namespace aidl {
namespace android {
namespace hardware {
namespace memtrack {
class Memtrack : public BnMemtrack {
ndk::ScopedAStatus getMemory(int pid, MemtrackType type,
std::vector<MemtrackRecord>* _aidl_return) override;
ndk::ScopedAStatus getGpuDeviceInfo(std::vector<DeviceInfo>* _aidl_return) override;
};
} // namespace memtrack
} // namespace hardware
} // namespace android
} // namespace aidl

36
memtrack/aidl/default/main.cpp
View File

@@ -1,36 +0,0 @@
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "Memtrack.h"
#include <android-base/logging.h>
#include <android/binder_manager.h>
#include <android/binder_process.h>
using aidl::android::hardware::memtrack::Memtrack;
int main() {
ABinderProcess_setThreadPoolMaxThreadCount(0);
std::shared_ptr<Memtrack> memtrack = ndk::SharedRefBase::make<Memtrack>();
const std::string instance = std::string() + Memtrack::descriptor + "/default";
binder_status_t status =
AServiceManager_addService(memtrack->asBinder().get(), instance.c_str());
CHECK(status == STATUS_OK);
ABinderProcess_joinThreadPool();
return EXIT_FAILURE; // Unreachable
}

4
memtrack/aidl/default/memtrack-default.rc
View File

@@ -1,4 +0,0 @@
service vendor.memtrack-default /vendor/bin/hw/android.hardware.memtrack-service.example
class hal
user nobody
group system

7
memtrack/aidl/default/memtrack-default.xml
View File

@@ -1,7 +0,0 @@
<manifest version="1.0" type="device">
<hal format="aidl">
<name>android.hardware.memtrack</name>
<fqname>IMemtrack/default</fqname>
</hal>
</manifest>

17
memtrack/aidl/vts/Android.bp
View File

@@ -1,17 +0,0 @@
cc_test {
name: "VtsHalMemtrackTargetTest",
defaults: [
"VtsHalTargetTestDefaults",
"use_libaidlvintf_gtest_helper_static",
],
srcs: ["VtsHalMemtrackTargetTest.cpp"],
shared_libs: [
"libbinder_ndk",
],
static_libs: [
"android.hardware.memtrack-unstable-ndk_platform",
],
test_suites: [
"vts-core",
],
}

90
memtrack/aidl/vts/VtsHalMemtrackTargetTest.cpp
View File

@@ -1,90 +0,0 @@
/*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <aidl/Gtest.h>
#include <aidl/Vintf.h>
#include <aidl/android/hardware/memtrack/DeviceInfo.h>
#include <aidl/android/hardware/memtrack/IMemtrack.h>
#include <aidl/android/hardware/memtrack/MemtrackType.h>
#include <android/binder_manager.h>
#include <android/binder_process.h>
using aidl::android::hardware::memtrack::DeviceInfo;
using aidl::android::hardware::memtrack::IMemtrack;
using aidl::android::hardware::memtrack::MemtrackRecord;
using aidl::android::hardware::memtrack::MemtrackType;
class MemtrackAidlTest : public testing::TestWithParam<std::string> {
public:
virtual void SetUp() override {
const auto instance = std::string() + IMemtrack::descriptor + "/default";
auto memtrackBinder = ndk::SpAIBinder(AServiceManager_getService(instance.c_str()));
memtrack_ = IMemtrack::fromBinder(memtrackBinder);
ASSERT_NE(memtrack_, nullptr);
}
std::shared_ptr<IMemtrack> memtrack_;
};
TEST_P(MemtrackAidlTest, GetMemoryInvalidPid) {
int pid = -1;
MemtrackType type = MemtrackType::OTHER;
std::vector<MemtrackRecord> records;
auto status = memtrack_->getMemory(pid, type, &records);
EXPECT_EQ(status.getExceptionCode(), EX_ILLEGAL_ARGUMENT);
}
TEST_P(MemtrackAidlTest, GetMemoryInvalidType) {
int pid = 1;
MemtrackType type = MemtrackType::NUM_TYPES;
std::vector<MemtrackRecord> records;
auto status = memtrack_->getMemory(pid, type, &records);
EXPECT_EQ(status.getExceptionCode(), EX_UNSUPPORTED_OPERATION);
}
TEST_P(MemtrackAidlTest, GetMemory) {
int pid = 1;
MemtrackType type = MemtrackType::OTHER;
std::vector<MemtrackRecord> records;
auto status = memtrack_->getMemory(pid, type, &records);
EXPECT_TRUE(status.isOk());
}
TEST_P(MemtrackAidlTest, GetGpuDeviceInfo) {
std::vector<DeviceInfo> device_info;
auto status = memtrack_->getGpuDeviceInfo(&device_info);
EXPECT_TRUE(status.isOk());
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(MemtrackAidlTest);
INSTANTIATE_TEST_SUITE_P(PerInstance, MemtrackAidlTest,
testing::ValuesIn(android::getAidlHalInstanceNames(IMemtrack::descriptor)),
android::PrintInstanceNameToString);
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
ABinderProcess_setThreadPoolMaxThreadCount(1);
ABinderProcess_startThreadPool();
return RUN_ALL_TESTS();
}