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), file);
 173                         if (ret < 0) {
 174                                 error = errno;
 175                                 continue;
 176                         }
 177                         if (!pageframe)
 178                                 pageframe = alloc_pageframe();
 179                         ret -= sizeof(pf[0]);
 180
 181                         /* ignore unused pages */
 182                         if (!pf[ret / sizeof(pf[0])])
 183                                 continue;
 184
 185                         pageframe_to_struct(pf[ret / sizeof(pf[0])], pageframe);
 186
 187                         if (check_parse_opts(opts, pageframe, map)) {
 188                                 match = tree_to_pageframe(
 189                                         bintree_add(&pf_tree->tree,
 190                                                 &pageframe->tree,
 191                                                 &pageframe_ops));
 192                         } else {
 193                                 match = tree_to_pageframe(
 194                                         bintree_find(&pf_tree->tree,
 195                                                 &pageframe->tree,
 196                                                 &pageframe_ops));
 197                         }
 198
 199                         if (match == NULL)
 200                                 continue;
 201
 202                         if (match == pageframe)
 203                                 pageframe = NULL;
 204
 205                         match->refcount++;
 206                         /*
 207                          * Add a link from the physical page to this
 208                          * process's page map
 209                          */
 210                         if (!match->ml) {
 211                                 match->ml = alloc_maplist();
 212                                 match->ml->map = map;
 213                         } else {
 214                                 tmp = alloc_maplist();
 215                                 tmp->map = map;
 216                                 list_add(&match->ml->list, &tmp->list);
 217                         }
 218
 219                         if (match->page_present) {
 220                                 map->pages_present++;
 221                         } else if (match->page_swapped) {
 222                                 map->pages_swapped++;
 223                         }
 224                 }
 225         }
 226
 227         return 0;
 228 }
 229
 230 void read_pageframe(int pid, struct pageframe *pageframe,
 231                 struct process **process_list, struct parse_opts *opts)
 232 {
 233         struct maps *maps;
 234         struct process *process;
 235         FILE *file;
 236         char path[512];
 237         int ret;
 238
 239         process = malloc(sizeof(*process));
 240         memset(process, 0, sizeof(*process));
 241         INIT_LIST_HEAD(&process->list);
 242
 243         if (*process_list == NULL)
 244                 *process_list = process;
 245
 246         process->pid = pid;
 247
 248         list_add_tail(&process->list, &(*process_list)->list);
 249
 250         snprintf(path, sizeof(path), "/proc/%d/maps", pid);
 251         file = fopen(path, "rb");
 252
 253         if (!file)
 254                 return;
 255
 256         maps = parse_maps(file, pid);
 257         fclose(file);
 258         process->maps = maps;
 259
 260         snprintf(path, sizeof(path), "/proc/%d/pagemap", pid);
 261         file = fopen(path, "rb");
 262
 263         if (!file)
 264                 return;
 265
 266         parse_pageframe(file, pageframe, maps, opts);
 267         fclose(file);
 268
 269         snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
 270         file = fopen(path, "rb");
 271
 272         if (!file)
 273                 return;
 274
 275         ret = fread(process->name, 1, sizeof(process->name), file);
 276         if (ret > 0)
 277                 process->name[ret - 1] = 0;
 278         fclose(file);
 279
 280         if (maps == NULL)
 281                 return;
 282
 283         list_for_each_entry(maps, &process->maps->list, list) {
 284                 process->pages_present += maps->pages_present;
 285                 process->pages_swapped += maps->pages_swapped;
 286         }
 287
 288         return;
 289 }
 290
 291 static int get_next_pid(void)
 292 {
 293         static DIR *dir = NULL;
 294         struct dirent *dirent;
 295         int error;
 296
 297         if (!dir) {
 298                 dir = opendir("/proc");
 299                 if (!dir) {
 300                         error = errno;
 301                         printf("Failed to open /proc directory: %s\n",
 302                                 strerror(error));
 303                         return -1;
 304                 }
 305         }
 306
 307 restart:
 308         dirent = readdir(dir);
 309         if (!dirent) {
 310                 if (errno == 0) {
 311                         closedir(dir);
 312                         dir = NULL;
 313                         return 0;
 314                 }
 315                 error = errno;
 316                 printf("Failed to read /proc directory: %s\n", strerror(error));
 317                 return -1;
 318         }
 319
 320         if (dirent->d_name[0] < '0' || dirent->d_name[0] > '9')
 321                 goto restart;
 322
 323         return atoi(dirent->d_name);
 324 }
 325
 326 void scan_all_pids(struct pageframe *pf, struct process **process_list,
 327                 struct parse_opts *opts)
 328 {
 329         int pid;
 330
 331         while(1) {
 332                 pid = get_next_pid();
 333                 if (pid <= 0)
 334                         break;
 335                 read_pageframe(pid, pf, process_list, opts);
 336         }
 337 }