160 lines
6 KiB
C
160 lines
6 KiB
C
/*
|
|
* Copyright (C) 2013 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.
|
|
*/
|
|
|
|
#ifndef ANDROID_INCLUDE_HARDWARE_MEMTRACK_H
|
|
#define ANDROID_INCLUDE_HARDWARE_MEMTRACK_H
|
|
|
|
#include <stdint.h>
|
|
#include <sys/cdefs.h>
|
|
#include <sys/types.h>
|
|
|
|
#include <hardware/hardware.h>
|
|
|
|
__BEGIN_DECLS
|
|
|
|
#define MEMTRACK_MODULE_API_VERSION_0_1 HARDWARE_MODULE_API_VERSION(0, 1)
|
|
|
|
/**
|
|
* The id of this module
|
|
*/
|
|
#define MEMTRACK_HARDWARE_MODULE_ID "memtrack"
|
|
|
|
/*
|
|
* 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' address space.
|
|
* A secondary goal is to be able to categorize memory used by a process into
|
|
* GL, graphics, etc. All memory sizes should be in real memory usage,
|
|
* accounting for stride, bit depth, rounding up to page size, etc.
|
|
*
|
|
* 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 should fill out an array of memtrack_record structures breaking
|
|
* down the statistics of that memory type as much as possible. For example,
|
|
* getMemory(<pid>, MEMTRACK_TYPE_GL) might return:
|
|
* { { 4096, ACCOUNTED | PRIVATE | SYSTEM },
|
|
* { 40960, UNACCOUNTED | PRIVATE | SYSTEM },
|
|
* { 8192, ACCOUNTED | PRIVATE | DEDICATED },
|
|
* { 8192, UNACCOUNTED | PRIVATE | DEDICATED } }
|
|
* If the HAL could not differentiate between SYSTEM and DEDICATED memory, it
|
|
* could return:
|
|
* { { 12288, ACCOUNTED | PRIVATE },
|
|
* { 49152, UNACCOUNTED | PRIVATE } }
|
|
*
|
|
* Memory should not overlap between types. For example, a graphics buffer
|
|
* that has been mapped into the GPU as a surface should show up when
|
|
* MEMTRACK_TYPE_GRAPHICS is requested, and not when MEMTRACK_TYPE_GL
|
|
* is requested.
|
|
*/
|
|
|
|
enum memtrack_type {
|
|
MEMTRACK_TYPE_OTHER = 0,
|
|
MEMTRACK_TYPE_GL = 1,
|
|
MEMTRACK_TYPE_GRAPHICS = 2,
|
|
MEMTRACK_TYPE_MULTIMEDIA = 3,
|
|
MEMTRACK_TYPE_CAMERA = 4,
|
|
MEMTRACK_NUM_TYPES,
|
|
};
|
|
|
|
struct memtrack_record {
|
|
size_t size_in_bytes;
|
|
unsigned int flags;
|
|
};
|
|
|
|
/**
|
|
* Flags to differentiate memory that can already be accounted for in
|
|
* /proc/<pid>/smaps,
|
|
* (Shared_Clean + Shared_Dirty + Private_Clean + Private_Dirty = Size).
|
|
* In general, memory mapped in to a userspace process is accounted unless
|
|
* it was mapped with remap_pfn_range.
|
|
* Exactly one of these should be set.
|
|
*/
|
|
#define MEMTRACK_FLAG_SMAPS_ACCOUNTED (1 << 1)
|
|
#define MEMTRACK_FLAG_SMAPS_UNACCOUNTED (1 << 2)
|
|
|
|
/**
|
|
* Flags to differentiate memory shared across multiple processes vs. memory
|
|
* used by a single process. Only zero or one of these may be set in a record.
|
|
* If none are set, record is assumed to count shared + private memory.
|
|
*/
|
|
#define MEMTRACK_FLAG_SHARED (1 << 3)
|
|
#define MEMTRACK_FLAG_SHARED_PSS (1 << 4) /* shared / num_procesess */
|
|
#define MEMTRACK_FLAG_PRIVATE (1 << 5)
|
|
|
|
/**
|
|
* Flags to differentiate memory taken from the kernel's allocation pool vs.
|
|
* memory that is dedicated to non-kernel allocations, for example a carveout
|
|
* or separate video memory. Only zero or one of these may be set in a record.
|
|
* If none are set, record is assumed to count system + dedicated memory.
|
|
*/
|
|
#define MEMTRACK_FLAG_SYSTEM (1 << 6)
|
|
#define MEMTRACK_FLAG_DEDICATED (1 << 7)
|
|
|
|
/**
|
|
* Flags to differentiate memory accessible by the CPU in non-secure mode vs.
|
|
* memory that is protected. Only zero or one of these may be set in a record.
|
|
* If none are set, record is assumed to count secure + nonsecure memory.
|
|
*/
|
|
#define MEMTRACK_FLAG_NONSECURE (1 << 8)
|
|
#define MEMTRACK_FLAG_SECURE (1 << 9)
|
|
|
|
/**
|
|
* Every hardware module must have a data structure named HAL_MODULE_INFO_SYM
|
|
* and the fields of this data structure must begin with hw_module_t
|
|
* followed by module specific information.
|
|
*/
|
|
typedef struct memtrack_module {
|
|
struct hw_module_t common;
|
|
|
|
/**
|
|
* (*init)() performs memtrack management setup actions and is called
|
|
* once before any calls to getMemory().
|
|
* Returns 0 on success, -errno on error.
|
|
*/
|
|
int (*init)(const struct memtrack_module *module);
|
|
|
|
/**
|
|
* (*getMemory)() expects an array of record objects and populates up to
|
|
* *num_record structures with the sizes of memory plus associated flags for
|
|
* that memory. It also updates *num_records with the total number of
|
|
* records it could return if *num_records was large enough when passed in.
|
|
* Returning records with size 0 is expected, the number of records should
|
|
* not vary between calls to getMemory for the same memory type, even
|
|
* for different pids.
|
|
*
|
|
* The caller will often call getMemory for a type and pid with
|
|
* *num_records == 0 to determine how many records to allocate room for,
|
|
* this case should be a fast-path in the HAL, returning a constant and
|
|
* not querying any kernel files. If *num_records passed in is 0,
|
|
* then records may be NULL.
|
|
*
|
|
* This function must be thread-safe, it may get called from multiple
|
|
* threads at the same time.
|
|
*
|
|
* Returns 0 on success, -ENODEV if the type is not supported, -errno
|
|
* on other errors.
|
|
*/
|
|
int (*getMemory)(const struct memtrack_module *module,
|
|
pid_t pid,
|
|
int type,
|
|
struct memtrack_record *records,
|
|
size_t *num_records);
|
|
} memtrack_module_t;
|
|
|
|
__END_DECLS
|
|
|
|
#endif // ANDROID_INCLUDE_HARDWARE_MEMTRACK_H
|