diff --git a/arch/x86/mm/memory.c b/arch/x86/mm/memory.c
index 84da0f6d6..c4db0eb32 100644
--- a/arch/x86/mm/memory.c
+++ b/arch/x86/mm/memory.c
@@ -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;
 }
diff --git a/tools/uhyve-ibv.c b/tools/uhyve-ibv.c
index 56b2d2be8..6b8366bb3 100644
--- a/tools/uhyve-ibv.c
+++ b/tools/uhyve-ibv.c
@@ -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;
 }
 
 
diff --git a/tools/uhyve.c b/tools/uhyve.c
index adca6088b..db2b95a9a 100644
--- a/tools/uhyve.c
+++ b/tools/uhyve.c
@@ -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);
diff --git a/usr/tests/ib-test.c b/usr/tests/ib-test.c
index 1ae9d05b9..8b14b7131 100644
--- a/usr/tests/ib-test.c
+++ b/usr/tests/ib-test.c
@@ -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;
 }