git.itanic.dy.fi Git - scan-pagemap/blob - parse.c

   1 #include <sys/types.h>
   2 #include <dirent.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <errno.h>
   7
   8 #include "parse.h"
   9 #include "pagemap.h"
  10
  11 static struct maps_list *alloc_maplist(void)
  12 {
  13         struct maps_list *map;
  14
  15         map = malloc(sizeof *map);
  16         if (map == NULL)
  17                 goto err;
  18
  19         memset(map, 0, sizeof(*map));
  20         INIT_LIST_HEAD(&map->list);
  21 err:
  22         return map;
  23 }
  24
  25 static struct maps *alloc_map(void)
  26 {
  27         struct maps *map;
  28
  29         map = malloc(sizeof *map);
  30         if (map == NULL)
  31                 goto err;
  32
  33         memset(map, 0, sizeof(*map));
  34         INIT_LIST_HEAD(&map->list);
  35 err:
  36         return map;
  37 }
  38
  39 static struct maps *parse_maps(FILE *file, int pid)
  40 {
  41         struct maps *the_map = NULL;
  42         char line[1024];
  43         int ret;
  44
  45         while(fgets(line, sizeof(line), file)) {
  46                 struct maps *map = alloc_map();
  47                 unsigned long start, end;
  48                 char name[1024];
  49
  50                 if (map == NULL)
  51                         return 0;
  52
  53                 if (the_map == NULL)
  54                         the_map = map;
  55
  56                 ret = sscanf(line, "%lx-%lx %*s %*s %*s %*s %s",
  57                              &start, &end, name);
  58
  59                 if (ret < 2) {
  60                         printf("Error reading input: %s\n", line);
  61                         break;
  62                 }
  63
  64                 map->start = start;
  65                 map->end = end;
  66                 map->size = end - start;
  67                 map->pid = pid;
  68
  69                 if (ret >= 3)
  70                         strncpy(map->name, name, sizeof(map->name));
  71
  72                 list_add_tail(&map->list, &the_map->list);
  73         }
  74
  75         return the_map;
  76 }
  77
  78 static void clear_pageframe(struct pageframe *pf)
  79 {
  80         memset(pf, 0, sizeof(*pf));
  81 }
  82
  83 static struct pageframe *alloc_pageframe(void)
  84 {
  85         struct pageframe *pageframe;
  86
  87         pageframe = malloc(sizeof *pageframe);
  88         if (pageframe == NULL)
  89                 goto err;
  90
  91         clear_pageframe(pageframe);
  92 err:
  93         return pageframe;
  94 }
  95
  96 #define BITRANGE(first, last) (((2ll << (last - first)) - 1) << first)
  97
  98 static void pageframe_to_struct(unsigned long long p, struct pageframe *pf)
  99 {
 100         /* Refer Documentation/vm/pagemap.txt for the format */
 101         pf->page_present = !!(BITRANGE(63, 63) & p);
 102         pf->page_swapped = !!(BITRANGE(62, 62) & p);
 103         pf->page_shift   =   (BITRANGE(55, 60) & p) >> 55;
 104         pf->pfn          =   (BITRANGE(0, 54) & p);
 105         pf->swap_type    =   (BITRANGE(0, 4) & p);
 106         pf->swap_offset  =   (BITRANGE(5, 54) & p) >> 5;
 107 #if 0
 108         printf("pfn: %lx shift: %d present: %d swapped %d\n",
 109                 pf->pfn, pf->page_shift, pf->page_present, pf->page_swapped);
 110 #endif
 111 }
 112
 113 static int compare_pageframe(struct bintree *at, struct bintree *bt)
 114 {
 115         struct pageframe *a, *b;
 116         a = tree_to_pageframe(at);
 117         b = tree_to_pageframe(bt);
 118
 119         return a->pfn - b->pfn;
 120 }
 121
 122 struct bintree_ops pageframe_ops = {
 123         .compare = compare_pageframe,
 124 };
 125
 126 static int check_parse_opts(struct parse_opts *opts, struct pageframe *pf,
 127                 struct maps *map)
 128 {
 129         if (opts->parse_mask & PARSE_PID) {
 130                 if (opts->pid == map->pid)
 131                         return 1;
 132         }
 133
 134         if (opts->parse_mask & PARSE_MAP_NAME) {
 135                 if (!strcmp(opts->map_name, map->name))
 136                         return 1;
 137         }
 138
 139         return 0;
 140 }
 141
 142 /* Read data from the /proc/pid/pagemap file */
 143 static int parse_pageframe(FILE *file, struct pageframe *pf_tree,
 144                         struct maps *maps, struct parse_opts *opts)
 145 {
 146         struct maps *map;
 147         struct maps_list *tmp;
 148         struct pageframe *match, *pageframe = NULL;
 149         long start, len, i;
 150         unsigned long long pf[10240];
 151         int ret, error;
 152
 153         if (maps == NULL)
 154                 return 0;
 155
 156         /* Go through the list of allocated memory areas */
 157         list_for_each_entry(map, &maps->list, list) {
 158                 start = map->start >> (PAGE_SHIFT - 3);
 159                 len = map->size >> (PAGE_SHIFT - 3);
 160
 161                 ret = fseek(file, start, SEEK_SET);
 162                 if (ret) {
 163                         error = errno;
 164                         fprintf(stderr, "Error seeking to %lx: %s\n", start,
 165                                 strerror(error));
 166                         continue;
 167                 }
 168
 169                 for (i = 0; i < len; i++) {
 170                         if (!ret) {
 171                                 ret = fread(&pf, 1,
 172                                         MIN(sizeof(pf), (len - i) * 8), file);
 173                         }
 174                         if (ret < 0) {
 175                                 error = errno;
 176                                 continue;
 177                         }
 178                         if (!pageframe)
 179                                 pageframe = alloc_pageframe();
 180                         ret -= sizeof(pf[0]);
 181
 182                         /* ignore unused pages */
 183                         if (!pf[ret / sizeof(pf[0])])
 184                                 continue;
 185
 186                         pageframe_to_struct(pf[ret / sizeof(pf[0])], pageframe);
 187
 188                         if (check_parse_opts(opts, pageframe, map)) {
 189                                 match = tree_to_pageframe(
 190                                         bintree_add(&pf_tree->tree,
 191                                                 &pageframe->tree,
 192                                                 &pageframe_ops));
 193                         } else {
 194                                 match = tree_to_pageframe(
 195                                         bintree_find(&pf_tree->tree,
 196                                                 &pageframe->tree,
 197                                                 &pageframe_ops));
 198                         }
 199
 200                         if (match == NULL)
 201                                 continue;
 202
 203                         if (match == pageframe)
 204                                 pageframe = NULL;
 205
 206                         match->refcount++;
 207                         /*
 208                          * Add a link from the physical page to this
 209                          * process's page map
 210                          */
 211                         if (!match->ml) {
 212                                 match->ml = alloc_maplist();
 213                                 match->ml->map = map;
 214                         } else {
 215                                 tmp = alloc_maplist();
 216                                 tmp->map = map;
 217                                 list_add(&match->ml->list, &tmp->list);
 218                         }
 219
 220                         if (match->page_present) {
 221                                 map->pages_present++;
 222                         } else if (match->page_swapped) {
 223                                 map->pages_swapped++;
 224                         }
 225                 }
 226         }
 227
 228         return 0;
 229 }
 230
 231 void read_pageframe(int pid, struct pageframe *pageframe,
 232                 struct process **process_list, struct parse_opts *opts)
 233 {
 234         struct maps *maps;
 235         struct process *process;
 236         FILE *file;
 237         char path[512];
 238         int ret;
 239
 240         process = malloc(sizeof(*process));
 241         memset(process, 0, sizeof(*process));
 242         INIT_LIST_HEAD(&process->list);
 243
 244         if (*process_list == NULL)
 245                 *process_list = process;
 246
 247         process->pid = pid;
 248
 249         list_add_tail(&process->list, &(*process_list)->list);
 250
 251         snprintf(path, sizeof(path), "/proc/%d/maps", pid);
 252         file = fopen(path, "rb");
 253
 254         if (!file)
 255                 return;
 256
 257         maps = parse_maps(file, pid);
 258         fclose(file);
 259         process->maps = maps;
 260
 261         snprintf(path, sizeof(path), "/proc/%d/pagemap", pid);
 262         file = fopen(path, "rb");
 263
 264         if (!file)
 265                 return;
 266
 267         parse_pageframe(file, pageframe, maps, opts);
 268         fclose(file);
 269
 270         snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
 271         file = fopen(path, "rb");
 272
 273         if (!file)
 274                 return;
 275
 276         ret = fread(process->name, 1, sizeof(process->name), file);
 277         if (ret > 0)
 278                 process->name[ret - 1] = 0;
 279         fclose(file);
 280
 281         if (maps == NULL)
 282                 return;
 283
 284         list_for_each_entry(maps, &process->maps->list, list) {
 285                 process->pages_present += maps->pages_present;
 286                 process->pages_swapped += maps->pages_swapped;
 287         }
 288
 289         return;
 290 }
 291
 292 static int get_next_pid(void)
 293 {
 294         static DIR *dir = NULL;
 295         struct dirent *dirent;
 296         int error;
 297
 298         if (!dir) {
 299                 dir = opendir("/proc");
 300                 if (!dir) {
 301                         error = errno;
 302                         printf("Failed to open /proc directory: %s\n",
 303                                 strerror(error));
 304                         return -1;
 305                 }
 306         }
 307
 308 restart:
 309         dirent = readdir(dir);
 310         if (!dirent) {
 311                 if (errno == 0) {
 312                         closedir(dir);
 313                         dir = NULL;
 314                         return 0;
 315                 }
 316                 error = errno;
 317                 printf("Failed to read /proc directory: %s\n", strerror(error));
 318                 return -1;
 319         }
 320
 321         if (dirent->d_name[0] < '0' || dirent->d_name[0] > '9')
 322                 goto restart;
 323
 324         return atoi(dirent->d_name);
 325 }
 326
 327 void scan_all_pids(struct pageframe *pf, struct process **process_list,
 328                 struct parse_opts *opts)
 329 {
 330         int pid;
 331
 332         if (opts->parse_mask & PARSE_PID)
 333                 read_pageframe(opts->pid, pf, process_list, opts);
 334
 335         while(1) {
 336                 pid = get_next_pid();
 337                 if (pid <= 0)
 338                         break;
 339                 read_pageframe(pid, pf, process_list, opts);
 340         }
 341 }