summaryrefslogtreecommitdiff
path: root/memtrack-pixel/core/Memtrack.cpp
blob: 48d4fa7b651d1c49f1cbb1ddaeeecf3489f2754d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <Memtrack.h>
#include <stdlib.h>

#include <sstream>
#include <string>
#include <vector>

#include "GpuSysfsReader.h"
#include "filesystem.h"

#undef LOG_TAG
#define LOG_TAG "memtrack-core"

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::GL && type != MemtrackType::GRAPHICS &&
        type != MemtrackType::MULTIMEDIA && type != MemtrackType::CAMERA)
        return ndk::ScopedAStatus(AStatus_fromExceptionCode(EX_UNSUPPORTED_OPERATION));

    _aidl_return->clear();

    // Other types are retained only for backward compatibility
    if (type != MemtrackType::GL && type != MemtrackType::GRAPHICS)
        return ndk::ScopedAStatus::ok();

    // pid 0 is only supported for GL type to report total private memory
    if (pid == 0 && type != MemtrackType::GL)
        return ndk::ScopedAStatus::ok();

    uint64_t size = 0;
    switch (type) {
        case MemtrackType::GL:
            size = GpuSysfsReader::getPrivateGpuMem(pid);
            break;
        case MemtrackType::GRAPHICS:
            // TODO(b/194483693): This is not PSS as required by memtrack HAL
            // but complete dmabuf allocations. Reporting PSS requires reading
            // procfs. This HAL does not have that permission yet.
            size = GpuSysfsReader::getDmaBufGpuMem(pid);
            break;
        default:
            break;
    }

    MemtrackRecord record = {
            .flags = MemtrackRecord::FLAG_SMAPS_UNACCOUNTED,
            .sizeInBytes = static_cast<long>(size),
    };
    _aidl_return->emplace_back(record);

    return ndk::ScopedAStatus::ok();
}

ndk::ScopedAStatus Memtrack::getGpuDeviceInfo(std::vector<DeviceInfo>* _aidl_return) {
    auto devPath = filesystem::path(GpuSysfsReader::kSysfsDevicePath);
    std::string devName = "default-gpu";
    if (filesystem::exists(devPath) && filesystem::is_symlink(devPath)) {
        devName = filesystem::read_symlink(devPath).filename().string();
    }

    DeviceInfo dev_info = {.id = 0, .name = devName};

    _aidl_return->clear();
    _aidl_return->emplace_back(dev_info);
    return ndk::ScopedAStatus::ok();
}

} // namespace memtrack
} // namespace hardware
} // namespace android
} // namespace aidl