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