Mirrors/libhermit
1
0
Fork 0
mirror of https://github.com/hermitcore/libhermit.git synced 2025-03-09 00:00:03 +01:00
Code Issues Releases Wiki Activity

Added realloc and memalign (dummy for now) hooks and debugging prints

Browse source
This commit is contained in:
Annika Wierichs 2017-12-04 16:19:50 +01:00
parent 16b9e0583c
commit dd19b1e87b
4 changed files with 173 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
arch/x86/mm/memory.c
View file

@ -376,8 +376,6 @@ oom:
void * ib_memory_init(void)
{
LOG_INFO("ib_memory_init\n");
size_t phyaddr, viraddr, bits;
int err;
@ -389,6 +387,11 @@ void * ib_memory_init(void)
return NULL;
}
LOG_INFO("ib_memory_init, size: %lu\n", IB_MEMORY_SIZE);
LOG_INFO("\tGuest Phys Start: %p\tEnd: %p\n", (uint8_t *) phyaddr, (uint8_t *) &kernel_end);
/* LOG_INFO("\tHost Virt Start: %p\tEnd: %p\n", */
/* phyaddr + host_kernel_start, (size_t) &kernel_end + host_kernel_start); */
err = page_map(viraddr, phyaddr, IB_MEMORY_NPAGES, bits);
if (BUILTIN_EXPECT(err, 0)) {
LOG_INFO("BUILTIN_EXPECT failed: ib_memory_init 2\n");
@ -396,6 +399,6 @@ void * ib_memory_init(void)
return NULL;
}
LOG_INFO("ib_memory_init\n");
LOG_INFO("ib_memory_init finished\n");
return (void *) viraddr;
}

28
tools/uhyve-ibv.c
View file

@ -38,25 +38,26 @@
*/
void call_ibv_get_device_list(struct kvm_run * run, uint8_t * guest_mem) {
ib_malloc = true;
printf("LOG: UHYVE - call_ibv_get_device_list\n");
printf("temp check 1\n");
int * temp = malloc(sizeof(int));
*temp = 42;
free(temp);
ib_malloc = true;
unsigned data = *((unsigned *)((size_t)run+run->io.data_offset));
uhyve_ibv_get_device_list_t * args = (uhyve_ibv_get_device_list_t *) (guest_mem + data);
// Call IBV function from hypervisor
/* int num_devices; */
/* struct ibv_device **host_ret = ibv_get_device_list(&num_devices); */
printf("temp check 2\n");
temp = malloc(sizeof(int));
*temp = 42;
free(temp);
printf("LOG: UHYVE - call_ibv_get_device_list -- before ibv call\n");
args->ret = ibv_get_device_list(args->num_devices);
printf("LOG: UHYVE - call_ibv_get_device_list -- after ibv call\n");
// Copy number of devices and device structs to kernel memory
/* if (args->num_devices) { */
/* memcpy(args->num_devices, &num_devices, sizeof(num_devices)); */
/* } */
/* for (int d = 0; d < num_devices; d++) { */
/* memcpy(args->ret[d], host_ret[d], sizeof(struct ibv_device)); */
/* } */
ib_malloc = false;
}
@ -84,6 +85,9 @@ void call_ibv_get_device_name(struct kvm_run * run, uint8_t * guest_mem) {
void call_ibv_open_device(struct kvm_run * run, uint8_t * guest_mem) {
printf("LOG: UHYVE - call_ibv_open_device\n");
ib_malloc = true;
unsigned data = *((unsigned*)((size_t)run+run->io.data_offset));
uhyve_ibv_open_device_t * args = (uhyve_ibv_open_device_t *) (guest_mem + data);
@ -95,6 +99,8 @@ void call_ibv_open_device(struct kvm_run * run, uint8_t * guest_mem) {
// TODO: Convert ptrs contained in return value.
free(host_ret);
printf("LOG: UHYVE - call_ibv_open_device\n");
ib_malloc = false;
}

177
tools/uhyve.c
View file

@ -196,65 +196,184 @@ static __thread uint32_t cpuid = 0;
static uint8_t * ib_mem = NULL;
bool ib_malloc = false;
static const size_t std_alignment = 16; // TODO: Use sizeof(maxint_t) (?) or similar
// Definition of malloc hooks for IBV library
static void ib_init_hook(void);
static void * ib_malloc_hook(size_t, const void *);
static void * ib_realloc_hook(void *, size_t, const void *);
static void * ib_memalign_hook(size_t, size_t, const void *);
static void ib_free_hook(void *, const void *);
static void * (* default_malloc_hook)(size_t, const void *);
static void (* default_free_hook)(void *, const void *);
static void * (* default_malloc_hook) (size_t, const void *);
static void * (* default_realloc_hook) (void *, size_t, const void *);
static void * (* default_memalign_hook)(size_t, size_t, const void *);
static void (* default_free_hook) (void *, const void *);
/* void (* __malloc_initialize_hook) (void) = ib_init_hook; */
/* __malloc_initialize_hook = ib_init_hook; */
static void ib_init_hook(void) {
printf("ib_init_hook\n");
default_malloc_hook = __malloc_hook;
default_free_hook = __free_hook;
void * new_ib_malloc_region(size_t size) {
void * result = NULL;
__malloc_hook = ib_malloc_hook;
__free_hook = ib_free_hook;
if (size > 0) {
ib_mem -= size;
ib_mem -= (size_t) ((uintptr_t) ib_mem % std_alignment);
printf("ib_mem aligned: %p\n", ib_mem);
result = ib_mem;
ib_mem -= std_alignment;
size_t * block_size = (size_t *) ib_mem;
*block_size = size;
}
if ((uint8_t *) result < guest_mem + guest_size - (size_t) (1UL << 20)) { // TODO: remove this
printf("WARNING, IB MEM OUT OF BOUNDS\n\n");
}
return result;
}
static void ib_init_hook(void) {
/* printf("ib_init_hook\n"); */
default_malloc_hook = __malloc_hook;
default_realloc_hook = __realloc_hook;
default_memalign_hook = __memalign_hook;
default_free_hook = __free_hook;
__malloc_hook = ib_malloc_hook;
__realloc_hook = ib_realloc_hook;
__memalign_hook = ib_memalign_hook;
__free_hook = ib_free_hook;
}
static void * ib_malloc_hook(size_t size, const void * caller) {
printf("ib_malloc_hook");
__malloc_hook = default_malloc_hook;
__realloc_hook = default_realloc_hook;
__memalign_hook = default_memalign_hook;
__free_hook = default_free_hook;
printf(" ib_malloc_hook\tib_malloc %s\t Args:\tsize = %lu\t", ib_malloc ? "true " : "false", size);
void * result;
__malloc_hook = default_malloc_hook;
__free_hook = default_free_hook;
if (ib_malloc) {
printf(" - ib_malloc true -- ib_mem: %p\n", ib_mem);
ib_mem -= size;
result = (size == 0) ? NULL : ib_mem;
} else {
printf(" - ib_malloc false\n");
result = new_ib_malloc_region(size);
} else { // !ib_malloc
printf("\n");
result = malloc(size);
}
default_malloc_hook = __malloc_hook;
default_free_hook = __free_hook;
default_malloc_hook = __malloc_hook;
default_realloc_hook = __realloc_hook;
default_memalign_hook = __memalign_hook;
default_free_hook = __free_hook;
__malloc_hook = ib_malloc_hook;
__free_hook = ib_free_hook;
__malloc_hook = ib_malloc_hook;
__realloc_hook = ib_realloc_hook;
__memalign_hook = ib_memalign_hook;
__free_hook = ib_free_hook;
return result;
}
static void * ib_realloc_hook(void * ptr, size_t new_size, const void * caller) {
__malloc_hook = default_malloc_hook;
__realloc_hook = default_realloc_hook;
__memalign_hook = default_memalign_hook;
__free_hook = default_free_hook;
printf("ib_realloc_hook\tib_malloc %s\t Args:\tptr = %p, size = %lu\t", ib_malloc ? "true " : "false", ptr, new_size);
void * result;
if (ib_malloc) {
size_t * mem_block_size_ptr = (size_t *) (ptr - std_alignment);
size_t orig_size = *mem_block_size_ptr;
if (new_size <= 0 || ptr == NULL) {
printf("new_size <= 0 || ptr == NULL\n");
result = NULL;
} else if (new_size <= orig_size) {
printf("new_size <= orig_size = %lu\n", orig_size);
*mem_block_size_ptr = new_size;
result = ptr;
} else { // new_size > orig_size
result = new_ib_malloc_region(new_size);
memcpy(result, ptr, orig_size);
}
} else { // !ib_malloc
printf("\n");
result = realloc(ptr, new_size);
}
default_malloc_hook = __malloc_hook;
default_realloc_hook = __realloc_hook;
default_memalign_hook = __memalign_hook;
default_free_hook = __free_hook;
__malloc_hook = ib_malloc_hook;
__realloc_hook = ib_realloc_hook;
__memalign_hook = ib_memalign_hook;
__free_hook = ib_free_hook;
return result;
}
static void * ib_memalign_hook(size_t alignment, size_t size, const void * caller) {
__malloc_hook = default_malloc_hook;
__realloc_hook = default_realloc_hook;
__memalign_hook = default_memalign_hook;
__free_hook = default_free_hook;
printf("\tCALLED! ib_memalign_hook\tib_malloc %s\t Args:\talignment = %lu\tsize = %lu\t",
ib_malloc ? "true " : "false", alignment, size);
void * result;
if (ib_malloc) {
/* result = new_ib_malloc_region(size); */
} else { // !ib_malloc
printf("\n");
result = memalign(alignment, size);
}
default_malloc_hook = __malloc_hook;
default_realloc_hook = __realloc_hook;
default_memalign_hook = __memalign_hook;
default_free_hook = __free_hook;
__malloc_hook = ib_malloc_hook;
__realloc_hook = ib_realloc_hook;
__memalign_hook = ib_memalign_hook;
__free_hook = ib_free_hook;
return result;
}
static void ib_free_hook(void * ptr, const void * caller) {
__malloc_hook = default_malloc_hook;
__free_hook = default_free_hook;
__malloc_hook = default_malloc_hook;
__realloc_hook = default_realloc_hook;
__memalign_hook = default_memalign_hook;
__free_hook = default_free_hook;
printf(" ib_free_hook\tib_malloc %s\t Args:\tptr = %p", ib_malloc ? "true " : "false", ptr);
if (!ib_malloc) {
free(ptr);
} else if (ptr != NULL && (ptr <= ib_mem || ptr > guest_mem + guest_size)) {
printf("\t!!! ptr out of ib bounds !!!");
}
printf("\n");
default_malloc_hook = __malloc_hook;
default_free_hook = __free_hook;
default_malloc_hook = __malloc_hook;
default_realloc_hook = __realloc_hook;
default_memalign_hook = __memalign_hook;
default_free_hook = __free_hook;
__malloc_hook = ib_malloc_hook;
__free_hook = ib_free_hook;
__malloc_hook = ib_malloc_hook;
__realloc_hook = ib_realloc_hook;
__memalign_hook = ib_memalign_hook;
__free_hook = ib_free_hook;
}
@ -1494,7 +1613,7 @@ int uhyve_init(char *path)
err(1, "unable to initialized network");
}
printf("ib_mem initialization\n");
printf("UHYVE: Initialize malloc hooks (ib_init_hook())\n");
ib_mem = guest_mem + guest_size;
printf("guest_mem: %p, guest_size: %p\n", guest_mem, guest_size);
printf("ib_mem = guest_mem + guest_size: %p\n", ib_mem);

5
usr/tests/ib-test.c
View file

@ -43,8 +43,9 @@
int main(int argc, char** argv)
{
/* printf("checking kernel outputs.\n"); */
int i, random;
FILE* file;
// ---------------------------------------------------------------------------
@ -69,8 +70,6 @@ int main(int argc, char** argv)
struct ibv_context * context = ibv_open_device(dev_list[0]);
printf("after open device\n");
return 0;
}