maps.c

   1 #include <stdlib.h>
   2 #include <string.h>
   3 #include <sys/mman.h>
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6 #include "arch.h"
   7 #include "list.h"
   8 #include "child.h"
   9 #include "maps.h"
  10 #include "random.h"
  11 #include "shm.h"
  12 #include "trinity.h"    // page_size
  13
  14 /* Walk the list, get the j'th element */
  15 static struct map * __get_map(struct list_head *head, unsigned int max)
  16 {
  17         struct list_head *node;
  18
  19         unsigned int i, j = 0;
  20
  21         i = rand() % max;
  22
  23         list_for_each(node, head) {
  24                 struct map *m;
  25
  26                 m = (struct map *) node;
  27
  28                 if (i == j)
  29                         return m;
  30                 j++;
  31         }
  32         return NULL;
  33 }
  34
  35 struct map * get_map(void)
  36 {
  37         struct map *map;
  38         bool local = FALSE;
  39
  40         /* If we're not running in child context, just do shared mappings. */
  41         if (this_child == 0)
  42                 return __get_map(&shared_mappings->list, num_shared_mappings);
  43
  44         /* Only toss the dice if we actually have local mappings. */
  45         if (shm->num_mappings[this_child] > 0)
  46                 local = rand_bool();
  47
  48         if (local == TRUE)
  49                 map = __get_map(&shm->mappings[this_child]->list, shm->num_mappings[this_child]);
  50         else
  51                 map = __get_map(&shared_mappings->list, num_shared_mappings);
  52
  53         return map;
  54 }
  55
  56 static void delete_local_mapping(int childno, struct map *map)
  57 {
  58         list_del(&map->list);
  59         shm->num_mappings[childno]--;
  60 }
  61
  62 void delete_mapping(int childno, struct map *map)
  63 {
  64         if (map->type == MAP_LOCAL)
  65                 delete_local_mapping(childno, map);
  66
  67         /* Right now, we don't want to delete MAP_GLOBAL mappings */
  68 }
  69
  70 struct map * common_set_mmap_ptr_len(int childno)
  71 {
  72         struct map *map;
  73
  74         map = (struct map *) shm->a1[childno];
  75         shm->scratch[childno] = (unsigned long) map;    /* Save this for ->post */
  76         if (map == NULL) {
  77                 shm->a1[childno] = 0;
  78                 shm->a2[childno] = 0;
  79                 return NULL;
  80         }
  81
  82         shm->a1[childno] = (unsigned long) map->ptr;
  83         shm->a2[childno] = map->size;           //TODO: Munge this.
  84
  85         return map;
  86 }
  87
  88 void dirty_mapping(struct map *map)
  89 {
  90         char *p = map->ptr;
  91         unsigned int i;
  92         unsigned int num_pages = map->size / page_size;
  93
  94         /* Check mapping is writable. */
  95         if (!(map->prot & PROT_WRITE))
  96                 return;
  97
  98         switch (rand() % 6) {
  99         case 0:
 100                 /* Just fault in one page. */
 101                 p[rand() % map->size] = rand();
 102                 break;
 103
 104         case 1:
 105                 /* fault in the whole mapping. */
 106                 for (i = 0; i < map->size; i += page_size)
 107                         p[i] = rand();
 108                 break;
 109
 110         case 2:
 111                 /* every other page. */
 112                 for (i = 0; i < map->size; i += (page_size * 2))
 113                         p[i] = rand();
 114                 break;
 115
 116         case 3:
 117                 /* whole mapping in reverse */
 118                 for (i = (map->size - page_size); i > 0; i -= page_size)
 119                         p[i] = rand();
 120                 break;
 121
 122         case 4:
 123                 /* fault in map->size pages. (some may be faulted >once) */
 124                 for (i = 0; i < num_pages; i++);
 125                         p[rand() % (num_pages + 1)] = rand();
 126                 break;
 127
 128         case 5:
 129                 /* fault in the last page in a mapping
 130                  * Fill it with ascii, in the hope we do something like
 131                  * a strlen and go off the end. */
 132                 memset((void *) p + (map->size - page_size), 'A', page_size);
 133                 break;
 134         }
 135 }