libpagemap/pm_map.c

   1 /*
   2  * Copyright (C) 2008 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 <stdlib.h>
  18 #include <string.h>
  19
  20 #include <pagemap/pagemap.h>
  21
  22 int pm_map_pagemap(pm_map_t *map, uint64_t **pagemap_out, size_t *len) {
  23     if (!map)
  24         return -1;
  25
  26     return pm_process_pagemap_range(map->proc, map->start, map->end,
  27                                     pagemap_out, len);
  28 }
  29
  30 int pm_map_usage_flags(pm_map_t *map, pm_memusage_t *usage_out,
  31                         uint64_t flags_mask, uint64_t required_flags) {
  32     uint64_t *pagemap;
  33     size_t len, i;
  34     uint64_t count;
  35     pm_memusage_t usage;
  36     int error;
  37
  38     if (!map || !usage_out)
  39         return -1;
  40
  41     error = pm_map_pagemap(map, &pagemap, &len);
  42     if (error) return error;
  43
  44     pm_memusage_zero(&usage);
  45
  46     for (i = 0; i < len; i++) {
  47         usage.vss += map->proc->ker->pagesize;
  48
  49         if (!PM_PAGEMAP_PRESENT(pagemap[i]) &&
  50             !PM_PAGEMAP_SWAPPED(pagemap[i]))
  51             continue;
  52
  53         if (!PM_PAGEMAP_SWAPPED(pagemap[i])) {
  54             if (flags_mask) {
  55                 uint64_t flags;
  56                 error = pm_kernel_flags(map->proc->ker, PM_PAGEMAP_PFN(pagemap[i]),
  57                                         &flags);
  58                 if (error) goto out;
  59
  60                 if ((flags & flags_mask) != required_flags)
  61                     continue;
  62             }
  63
  64             error = pm_kernel_count(map->proc->ker, PM_PAGEMAP_PFN(pagemap[i]),
  65                                     &count);
  66             if (error) goto out;
  67
  68             usage.rss += (count >= 1) ? map->proc->ker->pagesize : (0);
  69             usage.pss += (count >= 1) ? (map->proc->ker->pagesize / count) : (0);
  70             usage.uss += (count == 1) ? (map->proc->ker->pagesize) : (0);
  71         } else {
  72             usage.swap += map->proc->ker->pagesize;
  73         }
  74     }
  75
  76     memcpy(usage_out, &usage, sizeof(usage));
  77
  78     error = 0;
  79
  80 out:
  81     free(pagemap);
  82
  83     return error;
  84 }
  85
  86 int pm_map_usage(pm_map_t *map, pm_memusage_t *usage_out) {
  87     return pm_map_usage_flags(map, usage_out, 0, 0);
  88 }
  89
  90 int pm_map_workingset(pm_map_t *map, pm_memusage_t *ws_out) {
  91     uint64_t *pagemap;
  92     size_t len, i;
  93     uint64_t count, flags;
  94     pm_memusage_t ws;
  95     int error;
  96
  97     if (!map || !ws_out)
  98         return -1;
  99
 100     error = pm_map_pagemap(map, &pagemap, &len);
 101     if (error) return error;
 102
 103     pm_memusage_zero(&ws);
 104
 105     for (i = 0; i < len; i++) {
 106         error = pm_kernel_flags(map->proc->ker, PM_PAGEMAP_PFN(pagemap[i]),
 107                                 &flags);
 108         if (error) goto out;
 109
 110         if (!(flags & PM_PAGE_REFERENCED))
 111             continue;
 112
 113         error = pm_kernel_count(map->proc->ker, PM_PAGEMAP_PFN(pagemap[i]),
 114                                 &count);
 115         if (error) goto out;
 116
 117         ws.vss += map->proc->ker->pagesize;
 118         if( PM_PAGEMAP_SWAPPED(pagemap[i]) ) continue;
 119         ws.rss += (count >= 1) ? (map->proc->ker->pagesize) : (0);
 120         ws.pss += (count >= 1) ? (map->proc->ker->pagesize / count) : (0);
 121         ws.uss += (count == 1) ? (map->proc->ker->pagesize) : (0);
 122     }
 123
 124     memcpy(ws_out, &ws, sizeof(ws));
 125
 126     error = 0;
 127
 128 out:
 129     free(pagemap);
 130
 131     return 0;
 132 }
 133
 134 int pm_map_destroy(pm_map_t *map) {
 135     if (!map)
 136         return -1;
 137
 138     free(map->name);
 139     free(map);
 140
 141     return 0;
 142 }