maps.c

   1 #include <errno.h>
   2 #include <fcntl.h>
   3 #include <malloc.h>
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <unistd.h>
   8 #include <sys/mman.h>
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include "arch.h"
  12 #include "child.h"
  13 #include "list.h"
  14 #include "log.h"
  15 #include "maps.h"
  16 #include "random.h"
  17 #include "shm.h"
  18 #include "trinity.h"    // page_size
  19 #include "utils.h"
  20
  21 static unsigned int num_global_mappings = 0;
  22 static struct map *global_mappings = NULL;
  23
  24 static void dump_global_mappings(void)
  25 {
  26         struct map *m;
  27         struct list_head *node;
  28
  29         output(2, "There are %d entries in the map table\n", num_global_mappings);
  30
  31         list_for_each(node, &global_mappings->list) {
  32                 m = (struct map *) node;
  33                 output(2, " start: %p  name: %s\n", m->ptr, m->name);
  34         }
  35 }
  36
  37 static void alloc_zero_map(unsigned long size, int prot, const char *name)
  38 {
  39         struct map *newnode;
  40         struct list_head *list;
  41         int fd;
  42
  43         fd = open("/dev/zero", O_RDWR);
  44         if (fd == -1) {
  45                 outputerr("couldn't open /dev/zero\n");
  46                 exit(EXIT_FAILURE);
  47         }
  48
  49         newnode = zmalloc(sizeof(struct map));
  50         newnode->name = strdup(name);
  51         newnode->size = size;
  52         newnode->prot = prot;
  53         newnode->ptr = mmap(NULL, size, prot, MAP_ANONYMOUS | MAP_SHARED, fd, 0);
  54         if (newnode->ptr == MAP_FAILED) {
  55                 outputerr("mmap failure\n");
  56                 exit(EXIT_FAILURE);
  57         }
  58
  59         newnode->name = malloc(80);
  60         if (!newnode->name) {
  61                 outputerr("malloc() failed in %s().", __func__);
  62                 exit(EXIT_FAILURE);
  63         }
  64
  65         sprintf(newnode->name, "anon(%s)", name);
  66
  67         num_global_mappings++;
  68
  69         list = &global_mappings->list;
  70         list_add_tail(&newnode->list, list);
  71
  72         output(2, "mapping[%d]: (zeropage %s) %p (%lu bytes)\n",
  73                         num_global_mappings - 1, name, newnode->ptr, size);
  74
  75         close(fd);
  76 }
  77
  78 void setup_global_mappings(void)
  79 {
  80         unsigned int i;
  81         const unsigned long sizes[] = {
  82                 1 * MB, 2 * MB, 4 * MB, 10 * MB,
  83 //              1 * GB, // disabled for now, due to OOM.
  84         };
  85
  86         global_mappings = zmalloc(sizeof(struct map));
  87         INIT_LIST_HEAD(&global_mappings->list);
  88
  89         /* page_size * 2, so we have a guard page afterwards.
  90          * This is necessary for when we want to test page boundaries.
  91          * see end of _get_address() for details.
  92          */
  93         alloc_zero_map(page_size * 2, PROT_READ | PROT_WRITE, "PROT_READ | PROT_WRITE");
  94         alloc_zero_map(page_size * 2, PROT_READ, "PROT_READ");
  95         alloc_zero_map(page_size * 2, PROT_WRITE, "PROT_WRITE");
  96
  97         /*
  98          * multi megabyte page mappings.
  99          */
 100         for (i = 0; i < ARRAY_SIZE(sizes); i++) {
 101                 alloc_zero_map(sizes[i], PROT_READ | PROT_WRITE, "PROT_READ | PROT_WRITE");
 102                 alloc_zero_map(sizes[i], PROT_READ, "PROT_READ");
 103                 alloc_zero_map(sizes[i], PROT_WRITE, "PROT_WRITE");
 104         }
 105
 106         dump_global_mappings();
 107 }
 108
 109 /* Walk the list, get the j'th element */
 110 static struct map * __get_map(struct list_head *head, unsigned int max)
 111 {
 112         struct map *m;
 113         struct list_head *node;
 114
 115         unsigned int i, j = 0;
 116
 117         i = rand() % max;
 118
 119         list_for_each(node, head) {
 120                 m = (struct map *) node;
 121
 122                 if (i == j)
 123                         return m;
 124                 j++;
 125         }
 126         return 0;
 127 }
 128
 129 struct map * get_map(void)
 130 {
 131         struct map *map;
 132         bool local = FALSE;
 133
 134         /* If we're not running in child context, just do global. */
 135         if (this_child == 0)
 136                 return __get_map(&global_mappings->list, num_global_mappings);
 137
 138         /* Only toss the dice if we actually have local mappings. */
 139         if (shm->num_mappings[this_child] > 0)
 140                 local = rand_bool();
 141
 142         if (local == TRUE)
 143                 map = __get_map(&shm->mappings[this_child]->list, shm->num_mappings[this_child]);
 144         else
 145                 map = __get_map(&global_mappings->list, num_global_mappings);
 146
 147         return map;
 148 }
 149
 150 void destroy_global_mappings(void)
 151 {
 152         struct map *m;
 153
 154         while (!list_empty(&global_mappings->list)) {
 155                 m = global_mappings;
 156
 157                 munmap(m->ptr, m->size);
 158                 free(m->name);
 159
 160                 global_mappings = (struct map *) m->list.next;
 161
 162                 list_del(&m->list);
 163                 free(m);
 164         }
 165
 166         num_global_mappings = 0;
 167 }
 168
 169 void delete_local_mapping(int childno, struct map *map)
 170 {
 171         list_del(&map->list);
 172         shm->num_mappings[childno]--;
 173 }
 174
 175 struct map * common_set_mmap_ptr_len(int childno)
 176 {
 177         struct map *map;
 178
 179         map = (struct map *) shm->a1[childno];
 180         shm->scratch[childno] = (unsigned long) map;    /* Save this for ->post */
 181         if (map == NULL) {
 182                 shm->a1[childno] = 0;
 183                 shm->a2[childno] = 0;
 184                 return NULL;
 185         }
 186
 187         shm->a1[childno] = (unsigned long) map->ptr;
 188         shm->a2[childno] = map->size;           //TODO: Munge this.
 189
 190         return map;
 191 }
 192
 193 void dirty_mapping(struct map *map)
 194 {
 195         char *p = map->ptr;
 196         unsigned int i;
 197
 198         /* Check mapping is writable. */
 199         if (!(map->prot & PROT_WRITE))
 200                 return;
 201
 202         if (rand_bool()) {
 203                 /* Just fault in one page. */
 204                 p[rand() % page_size] = 1;
 205         } else {
 206                 /* fault in the whole mapping */
 207                 for (i = 0; i < map->size; i += page_size)
 208                         p[i] = 1;
 209         }
 210         //TODO: More access patterns.
 211 }