cmake: fix debug qemu rules using wrong kernel executable

arch/x86_64/QEMU.cmake

@@ -66,7 +66,7 @@ if (LLDB)
 	add_custom_target(debug-kernel
 		COMMAND
 			${QEMU}
-				-kernel $<TARGET_FILE:${kernel_name}>
+				-kernel ${patched_kernel}
 				-initrd ${sys_dir}/${bsp_name}
 				${generic_flags}
 				-s -S &
@@ -74,7 +74,7 @@ if (LLDB)
 				-o "file ${CMAKE_BINARY_DIR}/kernel/${kernel_name}.debug"
 				-o "gdb-remote localhost:1234"
 		USES_TERMINAL
-		DEPENDS ${kernel_name} bsp)
+		DEPENDS ${patched_kernel} bsp)
 
 	if (image_cdrom)
 		message(STATUS "QEMU: Enable CD-ROM debug with LLDB")
@@ -95,7 +95,7 @@ elseif (GDB)
 	add_custom_target(debug-kernel
 		COMMAND
 			${QEMU}
-				-kernel $<TARGET_FILE:${kernel_name}>
+				-kernel ${patched_kernel}
 				-initrd ${sys_dir}/${bsp_name}
 				${generic_flags}
 				-s -S &
@@ -103,7 +103,7 @@ elseif (GDB)
 				-o "file ${CMAKE_BINARY_DIR}/kernel/${kernel_name}.debug"
 				-o "remote localhost:1234"
 		USES_TERMINAL
-		DEPENDS ${kernel_name} bsp)
+		DEPENDS ${patched_kernel} bsp)
 
 	if (image_cdrom)
 		message(STATUS "QEMU: Enable CD-ROM debug with GDB")

lib/liblaunch/elf.c

@@ -190,7 +190,10 @@ static kern_status_t create_exec_regions(struct elf_image *image)
 	}
 
 	if (status != KERN_OK) {
-		/* TODO cleanup e_local_exec */
+		vm_region_kill(image->e_local_exec);
+		kern_handle_close(image->e_local_exec);
+		image->e_local_exec = KERN_HANDLE_INVALID;
+
 		return status;
 	}
 
@@ -478,7 +481,10 @@ void elf_image_init(struct elf_image *out)
 {
 	memset(out, 0x0, sizeof(*out));
 
-	kern_config_get(KERN_CFG_PAGE_SIZE, &out->e_page_size, sizeof out->e_page_size);
+	kern_config_get(
+		KERN_CFG_PAGE_SIZE,
+		&out->e_page_size,
+		sizeof out->e_page_size);
 	out->e_image = KERN_HANDLE_INVALID;
 	out->e_data = KERN_HANDLE_INVALID;
 	out->e_local_space = KERN_HANDLE_INVALID;
@@ -543,6 +549,7 @@ void elf_image_cleanup(struct elf_image *image)
 {
 	vm_region_unmap_relative(image->e_local_exec, 0, image->e_total_size);
 	kern_handle_close(image->e_data);
+	vm_region_kill(image->e_local_exec);
 	kern_handle_close(image->e_local_exec);
 	kern_handle_close(image->e_remote_exec);
 }

lib/ulibc/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(source_dirs string stdio unistd)
+set(source_dirs string stdio unistd stdlib)
 foreach (dir ${source_dirs})
 	file(GLOB dir_sources ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/*.c)
 	file(GLOB dir_headers ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/*.h)

lib/ulibc/include/errno.h

@@ -0,0 +1,7 @@
+#ifndef ERRNO_H_
+#define ERRNO_H_
+
+#define EINVAL 1
+#define ENOMEM 2
+
+#endif

lib/ulibc/include/stdlib.h

@@ -0,0 +1,13 @@
+#ifndef STDLIB_H_
+#define STDLIB_H_
+
+#include <stddef.h>
+
+extern void abort(void);
+
+extern void *malloc(size_t count);
+extern void *calloc(size_t count, size_t size);
+extern void *realloc(void *p, size_t count);
+extern void free(void *p);
+
+#endif

lib/ulibc/stdlib/abort.c

@@ -0,0 +1,4 @@
+void abort(void)
+{
+	/* TODO */
+}

lib/ulibc/stdlib/malloc.c

@@ -589,7 +589,15 @@ MAX_RELEASE_CHECK_RATE   default: 4095 unless not HAVE_MMAP
 #endif  /* DARWIN */
 
 #if defined(__mango__)
-#define LACKS_SYS_TYPES_H
+#include <stddef.h>
+#define LACKS_SYS_TYPES_H 1
+#define NO_MALLOC_STATS 1
+#define HAVE_MORECORE 1
+#define HAVE_MMAP 0
+#define LACKS_TIME_H 1
+#define LACKS_SCHED_H 1
+#define LACKS_SYS_PARAM_H 1
+#define MALLOC_FAILURE_ACTION
 #endif
 
 #ifndef LACKS_SYS_TYPES_H

lib/ulibc/unistd/sbrk.c

@@ -1,25 +1,96 @@
+#include <mango/handle.h>
+#include <mango/task.h>
 #include <mango/types.h>
 #include <mango/vm.h>
 #include <stdint.h>
 
 #define BRK_SIZE 0x400000
 
-static kern_handle_t heap_region = KERN_HANDLE_INVALID;
+static virt_addr_t brk_base = 0, brk_ptr = 0;
-static kern_handle_t heap_object = KERN_HANDLE_INVALID;
+static kern_handle_t brk_region = KERN_HANDLE_INVALID;
+static kern_handle_t brk_object = KERN_HANDLE_INVALID;
 
 static void *init_brk(size_t size)
 {
 	kern_status_t status = KERN_OK;
-	return NULL;
+	kern_handle_t self, address_space;
+	status = task_self(&self);
+	if (status != KERN_OK) {
+		return (void *)-1;
+	}
+
+	status = task_get_address_space(self, &address_space);
+	if (status != KERN_OK) {
+		kern_handle_close(self);
+		return (void *)-1;
+	}
+
+	status = vm_object_create(
+		"ulibc-brk",
+		10,
+		BRK_SIZE,
+		VM_PROT_READ | VM_PROT_WRITE | VM_PROT_USER,
+		&brk_object);
+	if (status != KERN_OK) {
+		kern_handle_close(address_space);
+		kern_handle_close(self);
+		return (void *)-1;
+	}
+
+	status = vm_region_create(
+		address_space,
+		"ulibc-brk",
+		10,
+		VM_REGION_ANY_OFFSET,
+		BRK_SIZE,
+		VM_PROT_READ | VM_PROT_WRITE | VM_PROT_USER,
+		&brk_region,
+		&brk_base);
+	if (status != KERN_OK) {
+		kern_handle_close(brk_object);
+		kern_handle_close(address_space);
+		kern_handle_close(self);
+
+		brk_object = KERN_HANDLE_INVALID;
+		return (void *)-1;
+	}
+
+	status = vm_region_map_relative(
+		brk_region,
+		0,
+		brk_object,
+		0,
+		BRK_SIZE,
+		VM_PROT_READ | VM_PROT_WRITE | VM_PROT_USER,
+		NULL);
+	if (status != KERN_OK) {
+		kern_handle_close(brk_object);
+		kern_handle_close(brk_region);
+		kern_handle_close(address_space);
+		kern_handle_close(self);
+
+		brk_region = KERN_HANDLE_INVALID;
+		brk_object = KERN_HANDLE_INVALID;
+		return (void *)-1;
+	}
+
+	brk_ptr = brk_base;
+	return (void *)brk_ptr;
 }
 
 void *sbrk(intptr_t increment)
 {
 	kern_status_t status = KERN_OK;
-	if (heap_region == KERN_HANDLE_INVALID
+	if (brk_region == KERN_HANDLE_INVALID
-	    || heap_object == KERN_HANDLE_INVALID) {
+	    || brk_object == KERN_HANDLE_INVALID) {
-		return init_brk(BRK_SIZE);
+		init_brk(BRK_SIZE);
 	}
 
+	if (brk_ptr == 0 || brk_ptr >= brk_base + BRK_SIZE) {
 		return (void *)-1;
+	}
+
+	void *result = (void *)brk_ptr;
+	brk_ptr += increment;
+	return result;
 }

sys/ld/main.c

@@ -2,6 +2,9 @@
 #include <mango/msg.h>
 #include <mango/types.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
 
 int main(
 	int argc,
@@ -11,6 +14,17 @@ int main(
 	uintptr_t bsp_base)
 {
 	kern_log("ld!");
+	void *brk = sbrk(0);
+	kern_logf("brk=%p", brk);
+
+	void *buf = malloc(64);
+	if (buf) {
+		memset(buf, 0x0, 64);
+		kern_logf("allocated 64 bytes at %p", buf);
+	} else {
+		kern_logf("malloc() failed");
+	}
+
 	kern_handle_t port;
 	kern_status_t status = port_create(&port);
 	if (status != KERN_OK) {