/*

 * void amd64_tramp_inline(uint64_t stack, uint64_t kernend,

 *			uint64_t modulep, uint64_t pagetable, uint64_t entry,

 *			uint64_t copy_dst, uint64_t copy_src, uint64_t copy_src_end)

 */

	.globl	amd64_tramp_inline

amd64_tramp_inline:

	cli			/* Make sure we don't get interrupted. */

	movq	%rsi,%r12	/* Stash the kernel values for later. */

	movq	%rdx,%r13

	movq	%rcx,%r14

	movq	%r8,%r15

	/* Copy the kernel from the staging area to the expected location

	 * in memory. The following code is equivalent to the efi_copy_finish

	 * function that amd64_tramp used to call. Inlining this code avoids

	 * a scenario when the system froze because efi_copy_finish

	 * overwrote its own code that just happened to be located somewhere

	 * in the destination range.

	 *

	 * while (copy_src < copy_src_end) *copy_dst++ = *copy_src++;

	 */

	movq	8(%rsp), %rax	/* rax = copy_src */

	movq	16(%rsp), %rcx	/* rcx = copy_src_end */

	cmpq	%rcx, %rax

	jnb	copy_done

	subq	%rax, %r9		/* r9 = copy_dst - copy_src */

loop:

	movq	(%rax), %rdx

	movq	%rdx, (%rax,%r9)

	addq	$8, %rax

	cmpq	%rax, %rcx

	ja	loop

copy_done:

	movq	%rdi,%rsp	/* Switch to our temporary stack. */

	pushq	%r12		/* Push kernend. */

	salq	$32,%r13	/* Shift modulep and push it. */

	pushq	%r13

	pushq	%r15		/* Push the entry address. */

	movq	%r14,%cr3	/* Switch page tables. */

	ret			/* "Return" to kernel entry. */

	ALIGN_TEXT

amd64_tramp_inline_end:

	.globl	amd64_tramp_inline_size

amd64_tramp_inline_size:

	.long	amd64_tramp_inline_end-amd64_tramp_inline

	uint64_t		copy_dst, copy_src, copy_src_end;

	EFI_STATUS		status;

	if (EFI_ERROR(status)) {

		printf("Failed to allocate pages for trampoline code: %lu\n",

		    EFI_ERROR_CODE(status));

		return(ENOMEM);

	}

	if (EFI_ERROR(status)) {

		printf("Failed to allocate pages for PT4: %lu\n",

		    EFI_ERROR_CODE(status));

		return(ENOMEM);

	}

	/* Check the type of memory pages that will be overwritten

	 * by the trampoline and print a warning message for easier

	 * debugging. The memory map will most likely change until

	 * then, but I don't expect new reserved memory blocks to

	 * suddenly appear. */

	if (!efi_verify_destination_type()) {

		printf("Important memory pages may get overwritten!\n");

	}

	int err;

		/* XXX: For now, it is better to stop

		 * booting instead of ignoring it. */

		panic("efi_copyin: Staging area is too small");

		/* XXX: For now, it is better to stop

		 * booting instead of ignoring it. */

		panic("efi_copyout: Staging area is too small");

	/* XXX: Callers don't seem to differentiate between a read failure

	 * from fd and an insufficient space in the staging area. */

		/* XXX: For now, at least print that the size of

		 * the staging area is at fault and should be larger. */

		printf("efi_readin: Staging area is too small\n");

void

efi_copy_get_locations(uint64_t *dst, uint64_t *src, uint64_t *src_end)

{

	*src = (uint64_t)staging;

	*dst = (uint64_t)(staging - stage_offset);

	*src_end = (uint64_t)staging_end;

}

bool

efi_verify_destination_type(void)

{

	EFI_MEMORY_DESCRIPTOR *map = NULL, *p;

	EFI_PHYSICAL_ADDRESS dest, dest_end;

	EFI_PHYSICAL_ADDRESS page_start, page_end, overlap_start, overlap_end;

	UINTN sz, key, dsz;

	UINT32 dver;

	EFI_STATUS status;

	int i, ndesc;

	bool safe;

	dest = staging - stage_offset;

	dest_end = dest + (staging_end - staging);

	safe = false;

	sz = 0;

	for (;;) {

		status = BS->GetMemoryMap(&sz, map, &key, &dsz, &dver);

		if (!EFI_ERROR(status))

			break;

		if (status != EFI_BUFFER_TOO_SMALL) {

			printf("Can't read memory map: %lu\n",

			    EFI_ERROR_CODE(status));

			goto out;

		}

		free(map);

		/* Allocate 10 descriptors more than the size reported,

		 * to allow for any fragmentation caused by calling

		 * malloc */

		map = malloc(sz + (10 * dsz));

		if (map == NULL) {

			printf("Unable to allocate memory\n");

			goto out;

		}

	}

	safe = true;

	ndesc = sz / dsz;

	for (i = 0, p = map; i < ndesc;

	     i++, p = NextMemoryDescriptor(p, dsz)) {

		page_start = p->PhysicalStart;

		page_end = page_start + p->NumberOfPages * EFI_PAGE_SIZE;

		overlap_start = page_start > dest ? page_start : dest;

		overlap_end = page_end < dest_end ? page_end : dest_end;

		if (overlap_start < overlap_end &&

		    p->Type != EfiLoaderCode &&

		    p->Type != EfiLoaderData &&

		    p->Type != EfiBootServicesCode &&

		    p->Type != EfiBootServicesData &&

		    p->Type != EfiConventionalMemory) {

			safe = false;

			break;

		}

	}

out:

	free(map);

	return safe;

}

void efi_copy_get_locations(uint64_t *dst, uint64_t *src, uint64_t *src_end);

bool efi_verify_destination_type(void);