X-Git-Url: http://v3vee.org/palacios/gitweb/gitweb.cgi?a=blobdiff_plain;f=linux_usr%2Fv3_mem.c;h=183b9665117ec98c16284504cc29d756494ae51a;hb=02d617c8f625ad5da6c4c9b78b224e84baac5d08;hp=e51ef18fb69d2950c7089ad8e51a7bf98e703316;hpb=aae261833ac5205fb6a6d94e010413b08ab85e41;p=palacios.git diff --git a/linux_usr/v3_mem.c b/linux_usr/v3_mem.c index e51ef18..183b966 100644 --- a/linux_usr/v3_mem.c +++ b/linux_usr/v3_mem.c @@ -30,9 +30,7 @@ int dir_filter(const struct dirent * dir) { -int dir_cmp(const void * d1, const void * d2) { - const struct dirent ** dir1 = (const struct dirent **)d1; - const struct dirent ** dir2 = (const struct dirent **)d2; +int dir_cmp(const struct dirent **dir1, const struct dirent ** dir2) { int num1 = atoi((*dir1)->d_name + 6); int num2 = atoi((*dir2)->d_name + 6); @@ -43,22 +41,30 @@ int dir_cmp(const void * d1, const void * d2) { int main(int argc, char * argv[]) { unsigned long long mem_size_bytes = 0; + unsigned long long mem_min_start = 0; unsigned int block_size_bytes = 0; int bitmap_entries = 0; unsigned char * bitmap = NULL; int num_blocks = 0; int reg_start = 0; - - - if (argc != 2) { - printf("Usage: v3_mem \n"); - return -1; + int mem_ready = 0; + + if (argc != 2 && argc != 3) { + printf("usage: v3_mem [min_start (MB)]\n\n" + "Offline memory for use in Palacios.\n" + "min_start is the minimum allowable starting address.\n" + "this is zero by default\n\n"); + return -1; } mem_size_bytes = atoll(argv[1]) * (1024 * 1024); - printf("Trying to find %dMB (%d bytes) of memory\n", atoll(argv[1]), mem_size_bytes); + if (argc==3) { + mem_min_start = atoll(argv[1]) * (1024 * 1024); + } + + printf("Trying to find %dMB (%d bytes) of memory above %llu\n", atoll(argv[1]), mem_size_bytes, mem_min_start); /* Figure out the block size */ { @@ -71,24 +77,28 @@ int main(int argc, char * argv[]) { perror("Could not open block size file: " SYS_PATH "block_size_bytes"); return -1; } - + if (read(tmp_fd, tmp_buf, BUF_SIZE) <= 0) { perror("Could not read block size file: " SYS_PATH "block_size_bytes"); return -1; } - + close(tmp_fd); block_size_bytes = strtoll(tmp_buf, NULL, 16); printf("Memory block size is %dMB (%d bytes)\n", block_size_bytes / (1024 * 1024), block_size_bytes); + } num_blocks = mem_size_bytes / block_size_bytes; - if (block_size_bytes % mem_size_bytes) num_blocks++; + if (mem_size_bytes % block_size_bytes) num_blocks++; - printf("Looking for %d blocks of memory\n", num_blocks); + mem_min_start = block_size_bytes * + ((mem_min_start / block_size_bytes) + (!!(mem_min_start % block_size_bytes))); + + printf("Looking for %d blocks of memory starting at %p (block %llu)\n", num_blocks, (void*)mem_min_start, mem_min_start/block_size_bytes); // We now need to find consecutive offlinable memory blocks @@ -98,19 +108,26 @@ int main(int argc, char * argv[]) { struct dirent ** namelist = NULL; int size = 0; int i = 0; + int j = 0; + int last_block = 0; + int first_block = mem_min_start/block_size_bytes; - bitmap_entries = scandir(SYS_PATH, &namelist, dir_filter, dir_cmp); + last_block = scandir(SYS_PATH, &namelist, dir_filter, dir_cmp); + bitmap_entries = atoi(namelist[last_block - 1]->d_name + 6) + 1; size = bitmap_entries / 8; if (bitmap_entries % 8) size++; bitmap = malloc(size); + if (!bitmap) { + printf("ERROR: could not allocate space for bitmap\n"); + return -1; + } + memset(bitmap, 0, size); - for (i = 0; i < bitmap_entries; i++) { + for (i = 0 ; j < bitmap_entries - 1; i++) { struct dirent * tmp_dir = namelist[i]; - int major = i / 8; - int minor = i % 8; int block_fd = 0; char status_str[BUF_SIZE]; char fname[BUF_SIZE]; @@ -120,10 +137,20 @@ int main(int argc, char * argv[]) { snprintf(fname, BUF_SIZE, "%s%s/removable", SYS_PATH, tmp_dir->d_name); + j = atoi(tmp_dir->d_name + 6); + int major = j / 8; + int minor = j % 8; + + + if (i= num_blocks) { + break; + } + } - /* Scan bitmap for enough consecutive space */ - { - // num_blocks: The number of blocks we need to find - // bitmap: bitmap of blocks (1 == allocatable) - // bitmap_entries: number of blocks in the system/number of bits in bitmap - // reg_start: The block index where our allocation will start + + if (run_len < num_blocks) { + fprintf(stderr, "Could not find enough consecutive memory blocks... (found %d)\n", run_len); + return -1; + } + } + - int i = 0; - int run_len = 0; + /* Offline memory blocks starting at reg_start */ + { + int i = 0; - for (i = 0; i < bitmap_entries; i++) { - int i_major = i / 8; - int i_minor = i % 8; + for (i = 0; i < num_blocks; i++) { + FILE * block_file = NULL; + char fname[256]; + memset(fname, 0, 256); + + snprintf(fname, 256, "%smemory%d/state", SYS_PATH, i + reg_start); + + block_file = fopen(fname, "r+"); + + if (block_file == NULL) { + perror("Could not open block file"); + return -1; + } - if (!(bitmap[i_major] & (0x1 << i_minor))) { - reg_start = i + 1; // skip the region start to next entry - run_len = 0; - continue; - } - run_len++; + printf("Offlining block %d (%s)\n", i + reg_start, fname); + fprintf(block_file, "offline\n"); - if (run_len >= num_blocks) { - break; + fclose(block_file); } } - free(bitmap); - - if (run_len < num_blocks) { - fprintf(stderr, "Could not find enough consecutive memory blocks... (found %d)\n", run_len); - return -1; - } - } - - /* Offline memory blocks starting at reg_start */ - { - int i = 0; + /* We asked to offline set of blocks, but Linux could have lied. + * To be safe, check whether blocks were offlined and start again if not + */ - for (i = 0; i < num_blocks; i++) { - FILE * block_file = NULL; - char fname[256]; + { + int i = 0; - memset(fname, 0, 256); + mem_ready = 1; // Hopefully we are ok... - snprintf(fname, 256, "%smemory%d/state", SYS_PATH, i + reg_start); - - block_file = fopen(fname, "r+"); - if (block_file == NULL) { - perror("Could not open block file"); - return -1; - } + for (i = 0; i < num_blocks; i++) { + int block_fd = 0; + char fname[BUF_SIZE]; + char status_buf[BUF_SIZE]; + + + memset(fname, 0, BUF_SIZE); + memset(status_buf, 0, BUF_SIZE); + snprintf(fname, BUF_SIZE, "%smemory%d/state", SYS_PATH, i + reg_start); - printf("Offlining block %d (%s)\n", i + reg_start, fname); - fprintf(block_file, "offline\n"); + + block_fd = open(fname, O_RDONLY); + + if (block_fd == -1) { + perror("Could not open block file"); + return -1; + } + + if (read(block_fd, status_buf, BUF_SIZE) <= 0) { + perror("Could not read block status"); + return -1; + } - fclose(block_file); + printf("Checking offlined block %d (%s)...", i + reg_start, fname); + + int ret = strncmp(status_buf, "offline", strlen("offline")); + + if (ret != 0) { + int j = 0; + int major = (i + reg_start) / 8; + int minor = (i + reg_start) % 8; + + bitmap[major] &= ~(0x1 << minor); // mark the block as not removable in bitmap + + mem_ready = 0; // Keep searching + + printf("ERROR (%d)\n", ret); + + for (j = 0; j < i; j++) { + FILE * block_file = NULL; + char fname[256]; + + memset(fname, 0, 256); + + snprintf(fname, 256, "%smemory%d/state", SYS_PATH, j + reg_start); + + block_file = fopen(fname, "r+"); + + if (block_file == NULL) { + perror("Could not open block file"); + return -1; + } + + fprintf(block_file, "online\n"); + + fclose(block_file); + } + + break; + } + + printf("OK\n"); + + } + + } } + free(bitmap); /* Memory is offlined. Calculate size and phys start addr to send to Palacios */ { int v3_fd = 0; struct v3_mem_region mem; - unsigned long long num_bytes = num_blocks * block_size_bytes; - unsigned long long base_addr = reg_start * block_size_bytes; + unsigned long long num_bytes = (unsigned long long)(num_blocks) * (unsigned long long)(block_size_bytes); + unsigned long long base_addr = (unsigned long long)(reg_start) * (unsigned long long)(block_size_bytes); - printf("Giving Palacios %dMB of memory at (%p) \n", + printf("Giving Palacios %lluMB of memory at (%p) \n", num_bytes / (1024 * 1024), base_addr); mem.base_addr = base_addr;