maps-fault.c

   1 /*
   2  * Routines to dirty/fault-in mapped pages.
   3  */
   4
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <sys/mman.h>
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include "arch.h"
  11 #include "maps.h"
  12 #include "random.h"
  13 #include "utils.h"
  14
  15 struct faultfn {
  16         void (*func)(struct map *map);
  17 };
  18
  19 /*****************************************************************************/
  20 /* dirty page routines */
  21
  22 static void dirty_one_page(struct map *map)
  23 {
  24         char *p = map->ptr;
  25
  26         p[rand() % map->size] = rand();
  27 }
  28
  29 static void dirty_whole_mapping(struct map *map)
  30 {
  31         char *p = map->ptr;
  32         unsigned int i;
  33
  34         for (i = 0; i < map->size; i += page_size)
  35                 p[i] = rand();
  36 }
  37
  38 static void dirty_every_other_page(struct map *map)
  39 {
  40         char *p = map->ptr;
  41         unsigned int i;
  42
  43         for (i = 0; i < map->size; i += (page_size * 2))
  44                 p[i] = rand();
  45 }
  46
  47 static void dirty_mapping_reverse(struct map *map)
  48 {
  49         char *p = map->ptr;
  50         unsigned int i;
  51
  52         for (i = (map->size - page_size); i > 0; i -= page_size)
  53                 p[i] = rand();
  54 }
  55
  56 /* dirty a random set of map->size pages. (some may be faulted >once) */
  57 static void dirty_random_pages(struct map *map)
  58 {
  59         char *p = map->ptr;
  60         unsigned int i;
  61         unsigned int num_pages = map->size / page_size;
  62
  63         for (i = 0; i < num_pages; i++)
  64                 p[(rand() % (num_pages + 1)) * page_size] = rand();
  65 }
  66
  67 /* Dirty the last page in a mapping
  68  * Fill it with ascii, in the hope we do something like
  69  * a strlen and go off the end. */
  70 static void dirty_last_page(struct map *map)
  71 {
  72         char *p = map->ptr;
  73
  74         memset((void *) p + (map->size - page_size), 'A', page_size);
  75 }
  76
  77 static const struct faultfn write_faultfns[] = {
  78         { .func = dirty_one_page },
  79         { .func = dirty_whole_mapping },
  80         { .func = dirty_every_other_page },
  81         { .func = dirty_mapping_reverse },
  82         { .func = dirty_random_pages },
  83         { .func = dirty_last_page },
  84 };
  85
  86 /*****************************************************************************/
  87 /* routines to fault in pages */
  88
  89 static void read_one_page(struct map *map)
  90 {
  91         char *p = map->ptr;
  92         unsigned long offset = (rand() % map->size) & PAGE_MASK;
  93         char buf[page_size];
  94
  95         p += offset;
  96         memcpy(buf, p, page_size);
  97 }
  98
  99
 100 static void read_whole_mapping(struct map *map)
 101 {
 102         char *p = map->ptr;
 103         unsigned int i;
 104         char buf[page_size];
 105
 106         for (i = 0; i < map->size; i += page_size)
 107                 memcpy(buf, p + i, page_size);
 108 }
 109
 110 static void read_every_other_page(struct map *map)
 111 {
 112         char *p = map->ptr;
 113         unsigned int i;
 114         char buf[page_size];
 115
 116         for (i = 0; i < map->size; i += (page_size * 2))
 117                 memcpy(buf, p + i, page_size);
 118 }
 119
 120 static void read_mapping_reverse(struct map *map)
 121 {
 122         char *p = map->ptr;
 123         unsigned int i;
 124         char buf[page_size];
 125
 126         for (i = (map->size - page_size); i > 0; i -= page_size)
 127                 memcpy(buf, p + i, page_size);
 128 }
 129
 130 /* fault in a random set of map->size pages. (some may be faulted >once) */
 131 static void read_random_pages(struct map *map)
 132 {
 133         char *p = map->ptr;
 134         unsigned int i;
 135         unsigned int num_pages = map->size / page_size;
 136         char buf[page_size];
 137
 138         for (i = 0; i < num_pages; i++)
 139                 memcpy(buf, p + ((rand() % (num_pages + 1)) * page_size), page_size);
 140 }
 141
 142 /* Fault in the last page in a mapping */
 143 static void read_last_page(struct map *map)
 144 {
 145         char *p = map->ptr;
 146         char buf[page_size];
 147
 148         memcpy(buf, p + (map->size - page_size), page_size);
 149 }
 150
 151 static const struct faultfn read_faultfns[] = {
 152         { .func = read_one_page },
 153         { .func = read_whole_mapping },
 154         { .func = read_every_other_page },
 155         { .func = read_mapping_reverse },
 156         { .func = read_random_pages },
 157         { .func = read_last_page },
 158 };
 159
 160 /*****************************************************************************/
 161
 162 /*
 163  * Routine to perform various kinds of write operations to a mapping
 164  * that we created.
 165  */
 166 void dirty_mapping(struct map *map)
 167 {
 168         bool rw = rand_bool();
 169
 170         if (rw == TRUE) {
 171                 /* Check mapping is writable, or we'll segv.
 172                  * TODO: Perhaps we should do that, and trap it, mark it writable,
 173                  * then reprotect after we dirtied it ? */
 174                 if (!(map->prot & PROT_WRITE))
 175                         return;
 176
 177                 write_faultfns[rand() % ARRAY_SIZE(write_faultfns)].func(map);
 178                 return;
 179         } else {
 180                 if (!(map->prot & PROT_READ))
 181                         return;
 182
 183                 read_faultfns[rand() % ARRAY_SIZE(read_faultfns)].func(map);
 184         }
 185 }