1/* 2 * Copyright (C) 2013 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#include <memtrack/memtrack.h> 18 19#define LOG_TAG "memtrack" 20 21#include <log/log.h> 22 23#include <hardware/memtrack.h> 24 25#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) 26 27static const memtrack_module_t *module; 28 29struct memtrack_proc { 30 pid_t pid; 31 struct memtrack_proc_type { 32 enum memtrack_type type; 33 size_t num_records; 34 size_t allocated_records; 35 struct memtrack_record *records; 36 } types[MEMTRACK_NUM_TYPES]; 37}; 38 39int memtrack_init(void) 40{ 41 int err; 42 43 if (module) { 44 return 0; 45 } 46 47 err = hw_get_module(MEMTRACK_HARDWARE_MODULE_ID, 48 (hw_module_t const**)&module); 49 if (err) { 50 ALOGE("Couldn't load %s module (%s)", MEMTRACK_HARDWARE_MODULE_ID, 51 strerror(-err)); 52 return err; 53 } 54 55 return module->init(module); 56} 57 58struct memtrack_proc *memtrack_proc_new(void) 59{ 60 if (!module) { 61 return NULL; 62 } 63 64 return calloc(sizeof(struct memtrack_proc), 1); 65} 66 67void memtrack_proc_destroy(struct memtrack_proc *p) 68{ 69 enum memtrack_type i; 70 71 if (p) { 72 for (i = 0; i < MEMTRACK_NUM_TYPES; i++) { 73 free(p->types[i].records); 74 } 75 } 76 free(p); 77} 78 79static int memtrack_proc_get_type(struct memtrack_proc_type *t, 80 pid_t pid, enum memtrack_type type) 81{ 82 size_t num_records = t->num_records; 83 int ret; 84 85retry: 86 ret = module->getMemory(module, pid, type, t->records, &num_records); 87 if (ret) { 88 t->num_records = 0; 89 return ret; 90 } 91 if (num_records > t->allocated_records) { 92 /* Need more records than allocated */ 93 free(t->records); 94 t->records = calloc(sizeof(*t->records), num_records); 95 if (!t->records) { 96 return -ENOMEM; 97 } 98 t->allocated_records = num_records; 99 goto retry; 100 } 101 t->num_records = num_records; 102 103 return 0; 104} 105 106/* TODO: sanity checks on return values from HALs: 107 * make sure no records have invalid flags set 108 * - unknown flags 109 * - too many flags of a single category 110 * - missing ACCOUNTED/UNACCOUNTED 111 * make sure there are not overlapping SHARED and SHARED_PSS records 112 */ 113static int memtrack_proc_sanity_check(struct memtrack_proc *p) 114{ 115 (void)p; 116 return 0; 117} 118 119int memtrack_proc_get(struct memtrack_proc *p, pid_t pid) 120{ 121 enum memtrack_type i; 122 123 if (!module) { 124 return -EINVAL; 125 } 126 127 if (!p) { 128 return -EINVAL; 129 } 130 131 p->pid = pid; 132 for (i = 0; i < MEMTRACK_NUM_TYPES; i++) { 133 memtrack_proc_get_type(&p->types[i], pid, i); 134 } 135 136 return memtrack_proc_sanity_check(p); 137} 138 139static ssize_t memtrack_proc_sum(struct memtrack_proc *p, 140 enum memtrack_type types[], size_t num_types, 141 unsigned int flags) 142{ 143 ssize_t sum = 0; 144 size_t i; 145 size_t j; 146 147 for (i = 0; i < num_types; i++) { 148 enum memtrack_type type = types[i]; 149 for (j = 0; j < p->types[type].num_records; j++) { 150 if ((p->types[type].records[j].flags & flags) == flags) { 151 sum += p->types[type].records[j].size_in_bytes; 152 } 153 } 154 } 155 156 return sum; 157} 158 159ssize_t memtrack_proc_graphics_total(struct memtrack_proc *p) 160{ 161 enum memtrack_type types[] = { MEMTRACK_TYPE_GRAPHICS }; 162 return memtrack_proc_sum(p, types, ARRAY_SIZE(types), 0); 163} 164 165ssize_t memtrack_proc_graphics_pss(struct memtrack_proc *p) 166{ 167 enum memtrack_type types[] = { MEMTRACK_TYPE_GRAPHICS }; 168 return memtrack_proc_sum(p, types, ARRAY_SIZE(types), 169 MEMTRACK_FLAG_SMAPS_UNACCOUNTED); 170} 171 172ssize_t memtrack_proc_gl_total(struct memtrack_proc *p) 173{ 174 enum memtrack_type types[] = { MEMTRACK_TYPE_GL }; 175 return memtrack_proc_sum(p, types, ARRAY_SIZE(types), 0); 176} 177 178ssize_t memtrack_proc_gl_pss(struct memtrack_proc *p) 179{ 180 enum memtrack_type types[] = { MEMTRACK_TYPE_GL }; 181 return memtrack_proc_sum(p, types, ARRAY_SIZE(types), 182 MEMTRACK_FLAG_SMAPS_UNACCOUNTED); 183} 184 185ssize_t memtrack_proc_other_total(struct memtrack_proc *p) 186{ 187 enum memtrack_type types[] = { MEMTRACK_TYPE_MULTIMEDIA, 188 MEMTRACK_TYPE_CAMERA, 189 MEMTRACK_TYPE_OTHER }; 190 return memtrack_proc_sum(p, types, ARRAY_SIZE(types), 0); 191} 192 193ssize_t memtrack_proc_other_pss(struct memtrack_proc *p) 194{ 195 enum memtrack_type types[] = { MEMTRACK_TYPE_MULTIMEDIA, 196 MEMTRACK_TYPE_CAMERA, 197 MEMTRACK_TYPE_OTHER }; 198 return memtrack_proc_sum(p, types, ARRAY_SIZE(types), 199 MEMTRACK_FLAG_SMAPS_UNACCOUNTED); 200} 201