Home | History | Annotate | Download | only in libmemtrack 
      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 <errno.h>
     18 #include <stdbool.h>
     19 #include <stdio.h>
     20 #include <string.h>
     21 #include <sys/mman.h>
     22 
     23 #include <hardware/memtrack.h>
     24 
     25 #include "memtrack_msm.h"
     26 
     27 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
     28 #define min(x, y) ((x) < (y) ? (x) : (y))
     29 
     30 struct memtrack_record record_templates[] = {
     31     {
     32         .flags = MEMTRACK_FLAG_SMAPS_ACCOUNTED |
     33                  MEMTRACK_FLAG_PRIVATE |
     34                  MEMTRACK_FLAG_NONSECURE,
     35     },
     36     {
     37         .flags = MEMTRACK_FLAG_SMAPS_UNACCOUNTED |
     38                  MEMTRACK_FLAG_PRIVATE |
     39                  MEMTRACK_FLAG_NONSECURE,
     40     },
     41 };
     42 
     43 int kgsl_memtrack_get_memory(pid_t pid, enum memtrack_type type,
     44                              struct memtrack_record *records,
     45                              size_t *num_records)
     46 {
     47     size_t allocated_records = min(*num_records, ARRAY_SIZE(record_templates));
     48     FILE *fp;
     49     char line[1024];
     50     char tmp[128];
     51     size_t accounted_size = 0;
     52     size_t unaccounted_size = 0;
     53 
     54     *num_records = ARRAY_SIZE(record_templates);
     55 
     56     /* fastpath to return the necessary number of records */
     57     if (allocated_records == 0) {
     58         return 0;
     59     }
     60 
     61     memcpy(records, record_templates,
     62            sizeof(struct memtrack_record) * allocated_records);
     63 
     64     snprintf(tmp, sizeof(tmp), "/d/kgsl/proc/%d/mem", pid);
     65     fp = fopen(tmp, "r");
     66     if (fp == NULL) {
     67         return -errno;
     68     }
     69 
     70     /* Go through each line of <pid>/mem file and for every entry of type "gpumem"
     71      * check if the gpubuffer entry is usermapped or not. If the entry is usermapped
     72      * count the entry as accounted else count the entry as unaccounted.
     73      */
     74     while (1) {
     75         unsigned long size, mapsize;
     76         char line_type[7];
     77         char flags[10];
     78         char line_usage[19];
     79         int ret, egl_surface_count = 0, egl_image_count = 0;
     80 
     81         if (fgets(line, sizeof(line), fp) == NULL) {
     82             break;
     83         }
     84 
     85         /* Format:
     86          *  gpuaddr useraddr     size    id flags       type            usage sglen mapsize eglsrf eglimg
     87          * 545ba000 545ba000     4096     1 -----pY     gpumem      arraybuffer     1  4096      0      0
     88          */
     89         ret = sscanf(line, "%*x %*x %lu %*d %9s %6s %18s %*d %lu %6d %6d\n",
     90                        &size, flags, line_type, line_usage, &mapsize,
     91                        &egl_surface_count, &egl_image_count);
     92         if (ret != 7) {
     93             continue;
     94         }
     95 
     96         if (size == 0) {
     97             fclose(fp);
     98             return -EINVAL;
     99         }
    100 
    101         if (unaccounted_size + size < size) {
    102             fclose(fp);
    103             return -ERANGE;
    104         }
    105 
    106         if (type == MEMTRACK_TYPE_GL && strcmp(line_type, "gpumem") == 0) {
    107 
    108             if (flags[6] == 'Y') {
    109                 if (accounted_size + mapsize < accounted_size) {
    110                     fclose(fp);
    111                     return -ERANGE;
    112                 }
    113 
    114                 accounted_size += mapsize;
    115 
    116                 if (mapsize > size) {
    117                     fclose(fp);
    118                     return -EINVAL;
    119                 }
    120                 unaccounted_size += size - mapsize;
    121             } else {
    122                 unaccounted_size += size;
    123             }
    124         } else if (type == MEMTRACK_TYPE_GRAPHICS && strcmp(line_type, "ion") == 0) {
    125             if (strcmp(line_usage, "egl_surface") == 0) {
    126                 unaccounted_size += size;
    127             }
    128             else if (egl_surface_count == 0) {
    129                 unaccounted_size += size / (egl_image_count ? egl_image_count : 1);
    130             }
    131         }
    132     }
    133 
    134     if (allocated_records > 0) {
    135         records[0].size_in_bytes = accounted_size;
    136     }
    137     if (allocated_records > 1) {
    138         records[1].size_in_bytes = unaccounted_size;
    139     }
    140 
    141     fclose(fp);
    142 
    143     return 0;
    144 }
    145