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     pm_memusage_pswap_init_handle(&usage, usage_out->p_swap);
  46
  47     for (i = 0; i < len; i++) {
  48         usage.vss += map->proc->ker->pagesize;
  49
  50         if (!PM_PAGEMAP_PRESENT(pagemap[i]) &&
  51                 !PM_PAGEMAP_SWAPPED(pagemap[i]))
  52             continue;
  53
  54         if (!PM_PAGEMAP_SWAPPED(pagemap[i])) {
  55             if (flags_mask) {
  56                 uint64_t flags;
  57                 error = pm_kernel_flags(map->proc->ker, PM_PAGEMAP_PFN(pagemap[i]),
  58                                         &flags);
  59                 if (error) goto out;
  60
  61                 if ((flags & flags_mask) != required_flags)
  62                     continue;
  63             }
  64
  65             error = pm_kernel_count(map->proc->ker, PM_PAGEMAP_PFN(pagemap[i]),
  66                                     &count);
  67             if (error) goto out;
  68
  69             usage.rss += (count >= 1) ? map->proc->ker->pagesize : (0);
  70             usage.pss += (count >= 1) ? (map->proc->ker->pagesize / count) : (0);
  71             usage.uss += (count == 1) ? (map->proc->ker->pagesize) : (0);
  72         } else {
  73             usage.swap += map->proc->ker->pagesize;
  74             pm_memusage_pswap_add_offset(&usage, PM_PAGEMAP_SWAP_OFFSET(pagemap[i]));
  75         }
  76     }
  77
  78     memcpy(usage_out, &usage, sizeof(usage));
  79
  80     error = 0;
  81
  82 out:
  83     free(pagemap);
  84
  85     return error;
  86 }
  87
  88 int pm_map_usage(pm_map_t *map, pm_memusage_t *usage_out) {
  89     return pm_map_usage_flags(map, usage_out, 0, 0);
  90 }
  91
  92 int pm_map_workingset(pm_map_t *map, pm_memusage_t *ws_out) {
  93     uint64_t *pagemap;
  94     size_t len, i;
  95     uint64_t count, flags;
  96     pm_memusage_t ws;
  97     int error;
  98
  99     if (!map || !ws_out)
 100         return -1;
 101
 102     error = pm_map_pagemap(map, &pagemap, &len);
 103     if (error) return error;
 104
 105     pm_memusage_zero(&ws);
 106
 107     for (i = 0; i < len; i++) {
 108         error = pm_kernel_flags(map->proc->ker, PM_PAGEMAP_PFN(pagemap[i]),
 109                                 &flags);
 110         if (error) goto out;
 111
 112         if (!(flags & PM_PAGE_REFERENCED))
 113             continue;
 114
 115         error = pm_kernel_count(map->proc->ker, PM_PAGEMAP_PFN(pagemap[i]),
 116                                 &count);
 117         if (error) goto out;
 118
 119         ws.vss += map->proc->ker->pagesize;
 120         if( PM_PAGEMAP_SWAPPED(pagemap[i]) ) continue;
 121         ws.rss += (count >= 1) ? (map->proc->ker->pagesize) : (0);
 122         ws.pss += (count >= 1) ? (map->proc->ker->pagesize / count) : (0);
 123         ws.uss += (count == 1) ? (map->proc->ker->pagesize) : (0);
 124     }
 125
 126     memcpy(ws_out, &ws, sizeof(ws));
 127
 128     error = 0;
 129
 130 out:
 131     free(pagemap);
 132
 133     return 0;
 134 }
 135
 136 int pm_map_destroy(pm_map_t *map) {
 137     if (!map)
 138         return -1;
 139
 140     free(map->name);
 141     free(map);
 142
 143     return 0;
 144 }