/* Copyright (c) 2008, Sandia National Laboratories */

#include <lwk/liblwk.h>
#include <lwk/ctype.h>

/**
 * Verifies that an ELF header is sane.
 * Returns 0 if header is sane and random non-zero values if header is insane.
 */
int
elf_check_hdr(const struct elfhdr *hdr)
{
	if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0) {
		print(TYPE_ERR "bad e_ident %#x\n",
		               *((unsigned int *)hdr->e_ident));
		return -1;
	}
	if (hdr->e_ident[EI_CLASS] != ELF_CLASS) {
		print(TYPE_ERR "bad e_ident[EI_CLASS] %#x\n",
		               (unsigned int)hdr->e_ident[EI_CLASS]);
		return -1;
	}
	if (hdr->e_ident[EI_DATA] != ELF_DATA) {
		print(TYPE_ERR "bad e_ident[EI_DATA] %#x\n",
		               (unsigned int)hdr->e_ident[EI_DATA]);
		return -1;
	}
	if (hdr->e_ident[EI_VERSION] != EV_CURRENT) {
		print(TYPE_ERR "bad e_ident[EI_VERSION] %#x\n",
		               (unsigned int)hdr->e_ident[EI_VERSION]);
		return -1;
	}
	if (hdr->e_ident[EI_OSABI] != ELF_OSABI) {
		print(TYPE_ERR "bad e_dent[EI_OSABI] %#x\n",
		               (unsigned int)hdr->e_ident[EI_OSABI]);
		return -1;
	}
	if (hdr->e_type != ET_EXEC) {
		print(TYPE_ERR "bad e_type %#x\n",
		               (unsigned int)hdr->e_type);
		return -1;
	}
	if (hdr->e_machine != ELF_ARCH) {
		print(TYPE_ERR "bad e_machine %#x\n",
		               (unsigned int)hdr->e_machine);
		return -1;
	}
	if (hdr->e_version != EV_CURRENT) {
		print(TYPE_ERR "bad e_version %#x\n",
		               (unsigned int)hdr->e_version);
		return -1;
	}
	if (hdr->e_flags != 0) {
		print(TYPE_ERR "bad e_flags %#x\n",
		               (unsigned int)hdr->e_flags);
		return -1;
	}

	return 0;
}

/**
 * Prints the contents of an ELF file header to the console.
 */
void
elf_print_elfhdr(const struct elfhdr *hdr)
{
	print(TYPE_NORM "ELF File Header:\n");
	print(TYPE_NORM "  type      %0#10x\n",  (unsigned int)  hdr->e_type      );
	print(TYPE_NORM "  machine   %0#10x\n",  (unsigned int)  hdr->e_machine   );
	print(TYPE_NORM "  version   %0#10x\n",  (unsigned int)  hdr->e_version   );
	print(TYPE_NORM "  entry     %0#18lx\n", (unsigned long) hdr->e_entry     );
	print(TYPE_NORM "  phoff     %0#18lx\n", (unsigned long) hdr->e_phoff     );
	print(TYPE_NORM "  shoff     %0#18lx\n", (unsigned long) hdr->e_shoff     );
	print(TYPE_NORM "  flags     %0#10x\n",  (unsigned int)  hdr->e_flags     );
	print(TYPE_NORM "  ehsize    %0#10x\n",  (unsigned int)  hdr->e_ehsize    );
	print(TYPE_NORM "  phentsize %0#10x\n",  (unsigned int)  hdr->e_phentsize );
	print(TYPE_NORM "  phnum     %0#10x\n",  (unsigned int)  hdr->e_phnum     );
	print(TYPE_NORM "  shentsize %0#10x\n",  (unsigned int)  hdr->e_shentsize );
	print(TYPE_NORM "  shnum     %0#10x\n",  (unsigned int)  hdr->e_shnum     );
	print(TYPE_NORM "  shstrndx  %0#10x\n",  (unsigned int)  hdr->e_shstrndx  );
}

/**
 * Prints the contents of an ELF program header to the console.
 */
void
elf_print_phdr(const struct elf_phdr *hdr)
{
	char *name;

	switch (hdr->p_type) {
		case PT_NULL:    name = "NULL";    break;
		case PT_LOAD:    name = "LOAD";    break;
		case PT_DYNAMIC: name = "DYNAMIC"; break;
		case PT_INTERP:  name = "INTERP";  break;
		case PT_NOTE:    name = "NOTE";    break;
		case PT_SHLIB:   name = "SHLIB";   break;
		case PT_PHDR:    name = "PHDR";    break;
		case PT_LOPROC:  name = "LOPROC";  break;
		case PT_HIPROC:  name = "HIPROC";  break;
		default:         name = "UNDEFINED TYPE";
	}

	print(TYPE_NORM "ELF Program Segment Header:\n");
	print(TYPE_NORM "  type   %s\n", name);
	print(TYPE_NORM "  flags  %0#10x\n",  (unsigned int)  hdr->p_flags  );
	print(TYPE_NORM "  offset %0#18lx\n", (unsigned long) hdr->p_offset );
	print(TYPE_NORM "  vaddr  %0#18lx\n", (unsigned long) hdr->p_vaddr  );
	print(TYPE_NORM "  paddr  %0#18lx\n", (unsigned long) hdr->p_paddr  );
	print(TYPE_NORM "  filesz %0#18lx\n", (unsigned long) hdr->p_filesz );
	print(TYPE_NORM "  memsz  %0#18lx\n", (unsigned long) hdr->p_memsz  );
	print(TYPE_NORM "  align  %0#18lx\n", (unsigned long) hdr->p_align  );
}

/**
 * Converts ELF flags to the corresponding kernel memory subsystem flags.
 */
vmflags_t
elf_pflags_to_vmflags(unsigned int elf_pflags)
{
	vmflags_t vmflags = VM_USER;
	if ( elf_pflags & PF_R ) vmflags |= VM_READ;
	if ( elf_pflags & PF_W ) vmflags |= VM_WRITE;
	if ( elf_pflags & PF_X ) vmflags |= VM_EXEC;
	return vmflags;
}

/**
 * Determines an ELF executable's entry point... where to start executing.
 * Note: The address returned is in the context of the executing ELF
 *       image, not an address within the passed in elf_image.
 */
vaddr_t
elf_entry_point(const void *elf_image)
{
	const struct elfhdr *ehdr = elf_image;
	return ehdr->e_entry;
}

/**
 * Determines the address of an ELF executable's program header table.
 * Note: The address returned is in the context of the executing ELF
 *       image, not an address within the passed in elf_image.
 */
vaddr_t
elf_phdr_table_addr(const void *elf_image)
{
	const struct elfhdr *ehdr = elf_image;
	struct elf_phdr *phdr_array, *phdr;
	unsigned int i;

	phdr_array = (struct elf_phdr *)(elf_image + ehdr->e_phoff);

	for (i = 0; i < ehdr->e_phnum; i++) {
		phdr = &phdr_array[i];
		if (phdr->p_type == PT_LOAD)
			return phdr->p_vaddr - phdr->p_offset + ehdr->e_phoff;
	}
	return 0;
}

/**
 * Returns the number of entries in an ELF executable's program header table.
 */
unsigned int
elf_num_phdrs(const void *elf_image)
{
	const struct elfhdr *ehdr = elf_image;
	return ehdr->e_phnum;
}

/**
 * Determines where the UNIX heap should start for a given ELF executable.
 * Note: The address returned is in the context of the executing ELF
 *       image, not an address relative to the passed in elf_image.
 */
vaddr_t
elf_heap_start(const void *elf_image)
{
	const struct elfhdr *ehdr;
	const struct elf_phdr *phdr_array;
	const struct elf_phdr *phdr;
	vaddr_t end, heap_start=0;
	size_t i;

	/* Locate the program header array (in this context) */
	ehdr       = elf_image;
	phdr_array = (struct elf_phdr *)(elf_image + ehdr->e_phoff);

	for (i = 0; i < ehdr->e_phnum; i++) {
		phdr = &phdr_array[i];
		if (phdr->p_type != PT_LOAD)
			continue;

		/* Calculate the end of the LOAD segment in memory */
		end = phdr->p_vaddr + phdr->p_memsz;

		if (end > heap_start)
			heap_start = end;
	}

	return heap_start;
}

/**
 * Given an argument string like "arg1=foo arg2=bar", parses it into
 * an argv[] or envp[] style array of string pointers. Useful for
 * constructing the argv and envp arguments to elf_init_stack().
 */
int
elf_init_str_array(
	size_t  size,
	char *  ptrs[],
	char *  str
)
{ 
	size_t pos = 0;
	char *tmp;

	while (strlen(str)) {
		/* move past white space */
		while (*str && isspace(*str))
			++str;

		tmp = str;

		/* find the end of the string */
		while (*str && !isspace(*str))
			++str;

		*str++ = 0;

		if (strlen(tmp)) {
			if (pos == size - 1)
				return -1;
			ptrs[pos++] = tmp; 
		}
	
	}
	ptrs[pos] = "";
	return 0;
}

/**
 * Writes an auxiliary info table entry.
 */
static void
write_aux(
	struct aux_ent * table,
	int              index,
	unsigned long    id,
	unsigned long    val
)
{
	table[index].id  = id;
	table[index].val = val;
}

/**
 * Determines the value of the current stack pointer in the target
 * address space. The sp argument is the stack pointer in this context
 * (i.e., the context this code is executing in), stack_mapping is the
 * address of the stack in this context, stack_start is the address
 * of the stack in the target address space, and extent is the size
 * of the stack.
 */
static vaddr_t
sp_in_aspace(void *sp,
             void *stack_mapping, vaddr_t stack_start, size_t extent)
{
	vaddr_t stack_end    = (vaddr_t)stack_mapping + extent;
	vaddr_t stack_vend   = stack_start + extent;
	size_t  stack_offset = stack_end - (vaddr_t)sp;

	return stack_vend - stack_offset;
}

/**
 * Sets up the initial stack for a new task.  This includes storing the
 * argv[] argument array, envp[] environment array, and auxiliary info table
 * to the top of the user stack in the format that the C library expects them.
 * Eventually the arguments get passed to the application's
 * main(argc, argv, envp) function.
 * 
 * If successful, the initial stack pointer value that should be used when
 * starting the new task is returned in >stack_ptr.
 *
 * This function sets up the initial stack as follows (stack grows down):
 *
 *                 Environment Strings
 *                 Argument Strings
 *                 Platform String
 *                 Auxiliary Info Table
 *                 envp[]
 *                 argv[]
 *                 argc
 *
 * Arguments:
 *       [IN]  elf_image     The ELF executable, needed to setup aux info.
 *       [IN]  stack_mapping Where the stack is mapped in this context.
 *       [IN]  stack_start   Where the stack is located in the target aspace.
 *       [IN]  stack_extent  Size of the stack.
 *       [IN]  argv[]        Array of pointers to argument strings.
 *       [IN]  envp[]        Array of pointers to environment strings.
 *       [IN]  uid           User ID of the task
 *       [IN]  gid           Group ID of the task
 *       [IN]  hwcap         Hardware capability bitfield
 *                           (used for AT_HWCAP entry in aux info table)
 *       [OUT] stack_ptr     The initial stack pointer value for the new task.
 *                           (note this is an address in the target aspace)
 *
 * Returns:
 *       Success: 0
 *       Failure: Error Code, stack may have been partially initialized
 */
int
elf_init_stack(
	void *    elf_image,
	void *    stack_mapping,
	vaddr_t   stack_start,
	size_t    stack_extent,
	char *    argv[],
	char *    envp[],
	uid_t     uid,
	gid_t     gid,
	uint32_t  hwcap,
	vaddr_t * stack_ptr
)
{
	size_t i, len;
	uintptr_t sp;
	const char *platform_str = ELF_PLATFORM;
	struct aux_ent auxv[AT_ENTRIES];
	size_t argc=0, envc=0, auxc=0;
	size_t arg_len=0, env_len=0, auxv_len=0;
	size_t platform_str_len=0;

	char *strings_sp;
	char *platform_str_sp;
	unsigned long *auxv_sp;
	unsigned long *envp_sp;
	unsigned long *argv_sp;
	unsigned long *argc_sp;

	/* Count # of arguments and their total string length */
	while ((len = strlen(argv[argc])) != 0) {
		arg_len += (len + 1);
		++argc;
	}

	/* Count # of environment variables and their total string length */
	while ((len = strlen(envp[envc])) != 0) {
		env_len += (len + 1);
		++envc;
	}

	/* Calculate length of the arch's platform string, if there is one */
	if (platform_str)
		platform_str_len = strlen(platform_str) + 1;

	/* Make room on stack for arg, env, and platform strings */
	sp = (uintptr_t)((vaddr_t)stack_mapping + stack_extent);
	sp -= (arg_len + env_len + platform_str_len);
	strings_sp = (void *) sp;

	/* Build the auxilliary information table */
	write_aux(auxv, auxc++, AT_HWCAP, hwcap);
	write_aux(auxv, auxc++, AT_PAGESZ, ELF_EXEC_PAGESIZE);
	write_aux(auxv, auxc++, AT_CLKTCK, 1000000l);
	write_aux(auxv, auxc++, AT_PHDR, elf_phdr_table_addr(elf_image));
	write_aux(auxv, auxc++, AT_PHENT, sizeof(struct elf_phdr));
	write_aux(auxv, auxc++, AT_PHNUM, elf_num_phdrs(elf_image));
	write_aux(auxv, auxc++, AT_BASE, 0);
	write_aux(auxv, auxc++, AT_FLAGS, 0);
	write_aux(auxv, auxc++, AT_ENTRY, elf_entry_point(elf_image));
	write_aux(auxv, auxc++, AT_UID, uid);
	write_aux(auxv, auxc++, AT_EUID, uid);
	write_aux(auxv, auxc++, AT_GID, gid);
	write_aux(auxv, auxc++, AT_EGID, gid);
	write_aux(auxv, auxc++, AT_SECURE, 0);
	if (platform_str) {
		platform_str_sp = strings_sp;
		write_aux(
			auxv, auxc++, AT_PLATFORM,
			sp_in_aspace(platform_str_sp,
			             stack_mapping, stack_start,
			             stack_extent)
		);
	}
	write_aux(auxv, auxc++, AT_NULL, 0);

	/* Make room on stack for aux info table */
	auxv_len = auxc * sizeof(struct aux_ent);
	sp -= auxv_len;

	/* Make room on stack for argc, argv[], envp[] */
	sp -= ((1 + (argc + 1) + (envc + 1)) * sizeof(unsigned long));

	/* Align stack to 16-byte boundary */
	sp = round_down(sp, 16);

	/* Calculate stack address to store argc, argv[], envp[], and auxv[] */
	argc_sp = (unsigned long *) sp;
	argv_sp = argc_sp  + 1;
	envp_sp = argv_sp  + argc + 1;
	auxv_sp = envp_sp  + envc + 1;

	/* Store arch's platform string, if there is one */
	if (platform_str) {
		memcpy(strings_sp, platform_str, platform_str_len);
		strings_sp += platform_str_len;
	}

	/* Store the auxiliary information array */
	memcpy(auxv_sp, auxv, auxv_len);

	/* Store argv[] */
	for (i = 0; i < argc; i++) {
		len = strlen(argv[i]) + 1;
		memcpy(strings_sp, argv[i], len);
		argv_sp[i] = sp_in_aspace(strings_sp,
		                          stack_mapping, stack_start,
		                          stack_extent),
		strings_sp += len;
	}
	argv_sp[i] = 0;  /* NULL terminate argv[] */

	/* Store envp[] */
	for (i = 0; i < envc; i++) {
		len = strlen(envp[i]) + 1;
		memcpy(strings_sp, envp[i], len);
		envp_sp[i] = sp_in_aspace(strings_sp,
		                          stack_mapping, stack_start,
		                          stack_extent),
		strings_sp += len;
	}
	envp_sp[i] = 0;  /* NULL terminate argv[] */

	/* Store argc */
	*argc_sp = argc;

	if (stack_ptr) {
		*stack_ptr = sp_in_aspace((void *)sp,
		                          stack_mapping, stack_start,
		                          stack_extent);
	}
	return 0;
}

/**
 * A "default" alloc_pmem() function for use with elf_load_executable().
 * A user may wish to define a custom replacement alloc_pmem() function
 * to, for example, keep track of the physical memory that is allocated.
 */
paddr_t
elf_dflt_alloc_pmem(size_t size, size_t alignment, uintptr_t arg)
{
	struct pmem_region result;

	if (pmem_alloc_umem(size, alignment, &result))
		return 0;

	/* Mark the memory as being used by the init task */
	result.type = PMEM_TYPE_INIT_TASK;
	BUG_ON(pmem_update(&result));
	
	return result.start;
}

static int
load_writable_segment(
	void *            elf_image,
	struct elf_phdr * phdr,
	id_t              aspace_id,
	vaddr_t           start,
	size_t            extent,
	vmpagesize_t      pagesz,
	uintptr_t         alloc_pmem_arg,
	paddr_t (*alloc_pmem)(size_t size, size_t alignment, uintptr_t arg)
)
{
	int status;
	paddr_t pmem;
	vaddr_t local_start;
	vaddr_t src, dst;
	id_t my_aspace_id;

	/* Figure out my address space ID */
	if ((status = aspace_get_myid(&my_aspace_id)))
		return status;

	/* Allocate physical memory for the segment */
	if (!(pmem = alloc_pmem(extent, pagesz, alloc_pmem_arg)))
		return -ENOMEM;

	/* Map the segment into the target address space */
	status =
	aspace_map_region(
		aspace_id,
		start,
		extent,
		elf_pflags_to_vmflags(phdr->p_flags),
		pagesz,
		"ELF",
		pmem
	);
	if (status)
		return status;

	/* Map the segment into this address space */
	status =
	aspace_map_region_anywhere(
		my_aspace_id,
		&local_start,
		extent,
		(VM_USER|VM_READ|VM_WRITE),
		pagesz,
		"temporary",
		pmem
	);
	if (status)
		return status;

	/* Copy segment data from ELF image into the target address space
 	 * (via its temporary mapping in our address space) */
	dst = local_start + (phdr->p_vaddr - start);
	src = (vaddr_t)elf_image + phdr->p_offset;
	memcpy((void *)dst, (void *)src, phdr->p_filesz);

	/* Unmap the segment from this address space */
	status = aspace_del_region(my_aspace_id, local_start, extent);
	if (status)
		return status;

	return 0;
}

static int
load_readonly_segment(
	paddr_t           elf_image_paddr,
	struct elf_phdr * phdr,
	id_t              aspace_id,
	vaddr_t           start,
	size_t            extent,
	vmpagesize_t      pagesz
)
{
	return aspace_map_region(
		aspace_id,
		start,
		extent,
		elf_pflags_to_vmflags(phdr->p_flags),
		pagesz,
		"ELF (mapped)",
		elf_image_paddr +
			round_down(phdr->p_offset, pagesz)
	);
}

/**
 * Loads an ELF executable image into the specified address space. 
 *
 * Arguments:
 *       [IN]  elf_image:        Location of ELF image in this address space.
 *       [IN]  elf_image_paddr:  Location of ELF image in physical memory.
 *       [IN]  aspace_id:        Address space to load ELF image into.
 *       [IN]  pagesz:           Page size to use when mapping ELF image.
 *       [IN]  alloc_pmem_arg:   Argument to pass to alloc_pmem().
 *       [IN]  alloc_pmem:       Function pointer to use to allocate physical
 *                               memory for the region.  alloc_mem() returns 
 *                               the physical address of the memory allocated.
 *
 * Returns:
 *       Success: 0
 *       Failure: Error Code, the target address space is left in an
 *                undefined state and should be destroyed.
 */
int
elf_load_executable(
	void *       elf_image,
	paddr_t      elf_image_paddr,
	id_t         aspace_id,
	vmpagesize_t pagesz,
	uintptr_t    alloc_pmem_arg,
	paddr_t (*alloc_pmem)(size_t size, size_t alignment, uintptr_t arg)
)
{
	struct elfhdr *   ehdr;
	struct elf_phdr * phdr_array;
	struct elf_phdr * phdr;
	size_t            i;
	vaddr_t           start, end;
	size_t            extent;
	size_t            num_load_segments=0;
	int               status;

	/* Locate the program header array (in this context) */
	ehdr       = elf_image;
	phdr_array = (struct elf_phdr *)(elf_image + ehdr->e_phoff);

	/* Set up a region for each program segment */
	for (i = 0; i < ehdr->e_phnum; i++) {
		phdr = &phdr_array[i];
		if (phdr->p_type != PT_LOAD)
			continue;

		/* Calculate the segment's bounds */
		start  = round_down(phdr->p_vaddr, pagesz);
		end    = round_up(phdr->p_vaddr + phdr->p_memsz, pagesz);
		extent = end - start;

		if (phdr->p_flags & PF_W) {
			/* Writable segments must be copied into the
			 * target address space */
			status =
			load_writable_segment(
				elf_image,
				phdr,
				aspace_id,
				start,
				extent,
				pagesz,
				alloc_pmem_arg,
				alloc_pmem
			);
			if (status)
				return status;
		} else {
			/* Read-only segments are mapped directly
			 * from the ELF image */
			status =
			load_readonly_segment(
				elf_image_paddr,
				phdr,
				aspace_id,
				start,
				extent,
				pagesz
			);
			if (status)
				return status;
		}

		++num_load_segments;
	}

	return (num_load_segments) ? 0 : -ENOENT;
}

static int
make_region(
	id_t         aspace_id,
	vaddr_t      start,
	size_t       extent,
	vmflags_t    flags,
	vmpagesize_t pagesz,
	const char * name,
	uintptr_t    alloc_pmem_arg,
	paddr_t (*alloc_pmem)(size_t size, size_t alignment, uintptr_t arg),
	paddr_t *    pmem
)
{
	int status;

	*pmem = alloc_pmem(extent, pagesz, alloc_pmem_arg);
	if (*pmem == 0) {
		print("Failed to allocate physical memory for %s.", name);
		return -ENOMEM;
	}

	status = aspace_map_region(aspace_id, start, extent,
	                           flags, pagesz,
	                           name, *pmem);
	if (status) {
		print("Failed to map physical memory for %s (status=%d).",
		       name, status);
		return status;
	}

	return 0;
}

/**
 * Maximum number of arguments and environment variables that may
 * be passed to the new task created by elf_load().
 */
#define MAX_ARGC 32
#define MAX_ENVC 32

/**
 * Kitchen-sink ELF image load function.
 * If something more custom is desired, this function can be used as a guide
 * for what needs to be done to load an ELF executable and setup the
 * accompanying address space.
 */
int
elf_load(
	void *          elf_image,
	paddr_t         elf_image_paddr,
	const char *    name,
	id_t            desired_aspace_id,
	vmpagesize_t    pagesz,
	size_t          heap_size,
	size_t          stack_size,
	char *          argv_str,
	char *          envp_str,
	start_state_t * start_state,
	uintptr_t       alloc_pmem_arg,
	paddr_t (*alloc_pmem)(size_t size, size_t alignment, uintptr_t arg)
)
{
	int status;
	char *argv[MAX_ARGC] = { (char *)name };
	char *envp[MAX_ENVC];
	id_t my_aspace_id, aspace_id;
	vaddr_t heap_start, stack_start, stack_end, stack_ptr;
	vaddr_t local_stack_start;
	size_t heap_extent, stack_extent;
	paddr_t heap_pmem, stack_pmem;
	uint32_t hwcap;

	if (!elf_image || !start_state || !alloc_pmem)
		return -EINVAL;

	if (elf_init_str_array(MAX_ARGC-1, argv+1, argv_str)) {
		print("Too many ARGV strings.");
		return -EINVAL;
	}

	if (elf_init_str_array(MAX_ENVC, envp, envp_str)) {
		print("Too many ENVP strings.");
		return -EINVAL;
	}

	if ((status = aspace_create(desired_aspace_id, "init_task", &aspace_id))) {
		print("Failed to create aspace (status=%d).", status);
		return status;
	}

	/* Load the ELF executable's LOAD segments */
	status =
	elf_load_executable(
		elf_image,       /* where I can access the ELF image */
		elf_image_paddr, /* where it is in physical memory */
		aspace_id,       /* the address space to map it into */
		pagesz,          /* page size to map it with */
		0,               /* arg to pass to alloc_pmem */
		alloc_pmem       /* func to use to allocate phys mem */
	);
	if (status) {
		print("Failed to load ELF image (status=%d).", status);
		return status;
	}

	/* Create the UNIX heap */
	heap_start  = round_up(elf_heap_start(elf_image), pagesz);
	heap_extent = round_up(heap_size, pagesz);
	status =
	make_region(
		aspace_id,
		heap_start,
		heap_extent,
		(VM_USER|VM_READ|VM_WRITE|VM_EXEC|VM_HEAP),
		pagesz,
		"heap",
		alloc_pmem_arg,
		alloc_pmem,
		&heap_pmem
	);
	if (status) {
		print("Failed to create heap (status=%d).", status);
		return status;
	}

	/* Create the stack region */
	stack_end    = SMARTMAP_ALIGN;
	stack_start  = round_down(stack_end - stack_size, pagesz);
	stack_extent = stack_end - stack_start;
	status = 
	make_region(
		aspace_id,
		stack_start,
		stack_extent,
		(VM_USER|VM_READ|VM_WRITE|VM_EXEC),
		pagesz,
		"stack",
		alloc_pmem_arg,
		alloc_pmem,
		&stack_pmem
	);
	if (status) {
		print("Failed to create stack (status=%d).", status);
		return status;
	}

	/* Map the stack region into this address space */
	if ((status = aspace_get_myid(&my_aspace_id)))
		return status;
	status =
	aspace_map_region_anywhere(
		my_aspace_id,
		&local_stack_start,
		stack_extent,
		(VM_USER|VM_READ|VM_WRITE),
		pagesz,
		"temporary",
		stack_pmem
	);
	if (status) {
		print("Failed to map stack locally (status=%d).", status);
		return status;
	}

	/* Initialize the stack */
	status = elf_hwcap(start_state->cpu_id, &hwcap);
	if (status) {
		print("Failed to get hw capabilities (status=%d).", status);
		return status;
	}
	status =
	elf_init_stack(
		elf_image,
		(void *)local_stack_start,  /* Where I can access it */
		stack_start,                /* Where it is in target aspace */
		stack_extent,
		argv, envp,
		start_state->uid, start_state->gid,
		hwcap,
		&stack_ptr
	);
	if (status) {
		print("Failed to initialize stack (status=%d).", status);
		return status;
	}

	start_state->aspace_id   = aspace_id;
	start_state->entry_point = elf_entry_point(elf_image);
	start_state->stack_ptr   = stack_ptr;

	return 0;
}