linux_usr/v3_guest_mem.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include <fcntl.h>
   5 #include <sys/mman.h>
   6
   7 #include "v3_guest_mem.h"
   8
   9
  10
  11 #define GUEST_FILE "/proc/v3vee/v3-guests-details"
  12 //#define GUEST_FILE "/v-test/numa/palacios-devel/test.proc"
  13 #define MAXLINE 65536
  14
  15 struct v3_guest_mem_map * v3_guest_mem_get_map(char *vmdev)
  16 {
  17   FILE *f;
  18   int rc;
  19   int i;
  20   char buf[MAXLINE];
  21   char dev[MAXLINE];
  22   uint64_t start, end, num;
  23   uint64_t guest_cur;
  24   uint64_t num_regions;
  25
  26
  27   if (!(f=fopen(GUEST_FILE,"r"))) {
  28       fprintf(stderr,"Cannot open %s - is Palacios active?\n",GUEST_FILE);
  29       return 0;
  30   }
  31
  32   while (1) {
  33       if (!fgets(buf,MAXLINE,f)) {
  34           fprintf(stderr,"Could not find info for %s\n",vmdev);
  35           return 0;
  36       }
  37       if (sscanf(buf,"Device: %s",dev)==1) {
  38           if (!strcmp(dev,vmdev)) {
  39               // found our VM
  40               break;
  41           }
  42       }
  43   }
  44
  45   // Now we need the number of regions
  46   while (1) {
  47       if (!fgets(buf,MAXLINE,f)) {
  48           fprintf(stderr,"Could not find number of regions for %s\n",vmdev);
  49           return 0;
  50       }
  51       if (sscanf(buf,"Regions: %llu",&num_regions)==1) {
  52           break;
  53       }
  54   }
  55
  56   struct v3_guest_mem_map *m =
  57       (struct v3_guest_mem_map *) malloc(sizeof(struct v3_guest_mem_map)+num_regions*sizeof(struct v3_guest_mem_block));
  58   if (!m) {
  59       fprintf(stderr, "Cannot allocate space\n");
  60       fclose(f);
  61       return 0;
  62   }
  63
  64   memset(m,0,sizeof(struct v3_guest_mem_map)+num_regions*sizeof(struct v3_guest_mem_block));
  65
  66   m->numblocks=num_regions;
  67
  68   // Now collect the region info
  69   guest_cur=0;
  70   i=0;
  71   while (i<num_regions) {
  72       if (!fgets(buf,MAXLINE,f)) {
  73           fprintf(stderr,"Did not find all regions...\n");
  74           free(m);
  75           return 0;
  76       }
  77       if (sscanf(buf," region %d has HPAs %llx-%llx",&num,&start,&end)==3) {
  78           m->block[i].gpa = (void*)guest_cur;
  79           m->block[i].hpa = (void*)start;
  80           m->block[i].numpages = (end-start) / 4096 + !!((end-start) % 4096);
  81           if ((end-start)%4096) {
  82               fprintf(stderr,"Odd, region %d is a non-integral number of pages",i);
  83           }
  84           guest_cur+=end-start;
  85           m->block[i].cumgpa=(void*)(guest_cur-1);
  86           i++;
  87       }
  88   }
  89
  90   fclose(f);
  91
  92   return m;
  93
  94 }
  95
  96 int v3_map_guest_mem(struct v3_guest_mem_map *map)
  97 {
  98   uint64_t i;
  99
 100   if (map->fd) {
 101     fprintf(stderr, "Memory appears to already be mapped\n");
 102     return -1;
 103   }
 104
 105   map->fd = open("/dev/mem", O_RDWR | O_SYNC);
 106
 107   if (map->fd<0) {
 108     fprintf(stderr, "Cannot open /dev/mem - are you root?\n");
 109     map->fd=0;
 110     return -1;
 111   }
 112
 113   for (i=0; i<map->numblocks; i++) {
 114       //fprintf(stderr,"Mapping %llu bytes of /dev/mem offset 0x%llx\n",
 115       //    map->block[i].numpages*4096, (off_t)(map->block[i].hpa));
 116     map->block[i].uva = mmap(NULL,
 117                              map->block[i].numpages*4096,
 118                              PROT_READ | PROT_WRITE,
 119                              MAP_SHARED,
 120                              map->fd,
 121                              (off_t) (map->block[i].hpa));
 122
 123     if (map->block[i].uva == MAP_FAILED) {
 124       fprintf(stderr, "Failed to map block %llu\n",i);
 125       map->block[i].uva=0;
 126       v3_unmap_guest_mem(map);
 127       return -1;
 128     }
 129   }
 130
 131   return 0;
 132
 133 }
 134
 135 int v3_unmap_guest_mem(struct v3_guest_mem_map *map)
 136 {
 137   uint64_t i;
 138
 139   for (i=0; i<map->numblocks; i++) {
 140     if (map->block[i].uva) {
 141       munmap(map->block[i].uva, map->block[i].numpages*4096);
 142       map->block[i].uva=0;
 143     }
 144   }
 145   if (map->fd) {
 146     close(map->fd);
 147     map->fd=0;
 148   }
 149   return 0;
 150 }
 151
 152
 153 void *v3_gpa_start(struct v3_guest_mem_map *map)
 154 {
 155     return 0; // all guests start at zero for now
 156 }
 157
 158 void *v3_gpa_end(struct v3_guest_mem_map *map)
 159 {
 160     struct v3_guest_mem_block *l = &(map->block[map->numblocks-1]);
 161
 162     // currently, the regions are consecutive, so we just need the last block
 163     return l->gpa+l->numpages*4096-1;
 164 }
 165
 166
 167 int v3_guest_mem_apply(void (*func)(void *data, uint64_t num_bytes, void *priv),
 168                        struct v3_guest_mem_map *map, void *gpa, uint64_t num_bytes, void *priv)
 169 {
 170     void *cur_gpa;
 171     void *cur_uva;
 172     uint64_t left_bytes;
 173     uint64_t block_bytes;
 174
 175     if (!(map->fd)) {
 176         return -1;
 177     }
 178
 179     if (gpa < v3_gpa_start(map) || gpa+num_bytes-1 > v3_gpa_end(map)) {
 180         return -1;
 181     }
 182
 183     cur_gpa = gpa;
 184     left_bytes = num_bytes;
 185
 186     while (left_bytes) {
 187         cur_uva = v3_gpa_to_uva(map, cur_gpa, &block_bytes);
 188         if (!cur_uva) {
 189             return -1;
 190         }
 191         if (block_bytes>left_bytes) {
 192             block_bytes = left_bytes;
 193         }
 194         func(cur_uva,block_bytes,priv);
 195         left_bytes-=block_bytes;
 196         cur_gpa+=block_bytes;
 197     }
 198
 199     return 0;
 200 }
 201
 202
 203
 204 static void copy_out(void *uva, uint64_t num_bytes, void *curoff)
 205 {
 206     memcpy(*((void**)(curoff)), uva, num_bytes);
 207     *(void**)curoff += num_bytes;
 208 }
 209
 210 static void copy_in(void *uva, uint64_t num_bytes, void *curoff)
 211 {
 212     memcpy(uva, *((void**)(curoff)), num_bytes);
 213     *(void**)curoff += num_bytes;
 214 }
 215
 216 static void do_hash(void *uva, uint64_t num_bytes, void *priv)
 217 {
 218     uint64_t i;
 219     uint64_t *curhash = (uint64_t *)priv;
 220
 221     for (i=0;i<num_bytes;i++) {
 222         *curhash += ((uint8_t*)uva)[i];
 223     }
 224 }
 225
 226 int v3_guest_mem_read(struct v3_guest_mem_map *map, void *gpa, uint64_t num_bytes, char *data)
 227 {
 228     void *cpy_ptr=data;
 229
 230     return v3_guest_mem_apply(copy_out,map,gpa,num_bytes,&cpy_ptr);
 231 }
 232
 233 int v3_guest_mem_write(struct v3_guest_mem_map *map, void *gpa, uint64_t num_bytes, char *data)
 234 {
 235     void *cpy_ptr=data;
 236
 237     return v3_guest_mem_apply(copy_in,map,gpa,num_bytes,&cpy_ptr);
 238 }
 239
 240 int v3_guest_mem_hash(struct v3_guest_mem_map *map, void *gpa, uint64_t num_bytes, uint64_t *hash)
 241 {
 242     *hash = 0;
 243
 244     return v3_guest_mem_apply(do_hash,map,gpa,num_bytes,hash);
 245 }
 246
 247
 248
 249 int v3_guest_mem_track_start(char *vmdev,
 250                              v3_mem_track_access_t access,
 251                              v3_mem_track_reset_t reset,
 252                              uint64_t period)
 253 {
 254     struct v3_mem_track_cmd cmd;
 255
 256     cmd.request=V3_MEM_TRACK_START;
 257     cmd.config.access_type=access;
 258     cmd.config.reset_type=reset;
 259     cmd.config.period=period;
 260
 261     return v3_vm_ioctl(vmdev,V3_VM_MEM_TRACK_CMD,&cmd);
 262
 263 }
 264
 265 int v3_guest_mem_track_stop(char *vmdev)
 266 {
 267     struct v3_mem_track_cmd cmd;
 268
 269     cmd.request=V3_MEM_TRACK_STOP;
 270
 271     return v3_vm_ioctl(vmdev,V3_VM_MEM_TRACK_CMD,&cmd);
 272
 273 }
 274
 275
 276 #define CEIL_DIV(x,y) (((x)/(y)) + !!((x)%(y)))
 277
 278 static uint8_t *alloc_bitmap(uint64_t num_pages)
 279 {
 280     uint8_t *b;
 281
 282     if (!(b =  malloc(CEIL_DIV(num_pages,8)))) {
 283         return NULL;
 284     }
 285
 286     memset(b,0,CEIL_DIV(num_pages,8));
 287
 288     return b;
 289 }
 290
 291
 292 static void free_bitmap(uint8_t *b)
 293 {
 294     if (b) {
 295         free(b);
 296     }
 297
 298 }
 299
 300
 301 void v3_guest_mem_track_free_snapshot(v3_mem_track_snapshot *s)
 302 {
 303     int i;
 304
 305     if (s) {
 306         for (i=0;i<s->num_cores;i++) {
 307             free_bitmap(s->core[i].access_bitmap);
 308         }
 309         free(s);
 310     }
 311 }
 312
 313
 314 static v3_mem_track_snapshot *alloc_snapshot(uint64_t num_cores, uint64_t num_pages)
 315 {
 316     int i;
 317     v3_mem_track_snapshot *s;
 318
 319     s = malloc(sizeof(v3_mem_track_snapshot) + sizeof(struct v3_core_mem_track) * num_cores);
 320
 321     if (!s) {
 322         return NULL;
 323     }
 324
 325     memset(s,0,sizeof(v3_mem_track_snapshot) + sizeof(struct v3_core_mem_track) * num_cores);
 326
 327     s->num_cores=num_cores;
 328
 329     for (i=0;i<num_cores;i++) {
 330         if (!(s->core[i].access_bitmap = alloc_bitmap(num_pages))) {
 331             v3_guest_mem_track_free_snapshot(s);
 332             return NULL;
 333         }
 334         s->core[i].num_pages=num_pages;
 335     }
 336
 337     return s;
 338 }
 339
 340
 341 v3_mem_track_snapshot *v3_guest_mem_track_snapshot(char *vmdev)
 342 {
 343     struct v3_mem_track_sizes size;
 344     v3_mem_track_snapshot *s;
 345     int rc;
 346
 347     rc = v3_vm_ioctl(vmdev,V3_VM_MEM_TRACK_SIZE,&size);
 348
 349     if (rc) {
 350         return 0;
 351     }
 352
 353     //printf("returned size num_cores=%u, num_pages=%llu",size.num_cores,size.num_pages);
 354
 355     // allocate a snapshot;
 356     if (!(s=alloc_snapshot(size.num_cores,size.num_pages))) {
 357         return 0;
 358     }
 359
 360
 361
 362     if (v3_vm_ioctl(vmdev,V3_VM_MEM_TRACK_SNAP,s)) {
 363         v3_guest_mem_track_free_snapshot(s);
 364         return 0;
 365     }
 366
 367     return s;
 368 }
 369
 370
 371