plain_loader.c

EFI（Extensible Firmware Interface)是下一代BIOS

/*
 *  Copyright (C) 2001-2003 Hewlett-Packard Co.
 *	Contributed by Stephane Eranian <[e-mail]>
 *
 *  Copyright (C) 2001 Silicon Graphics, Inc.
 *      Contributed by Brent Casavant <[e-mail]>
 *
 * This file is part of the ELILO, the EFI Linux boot loader.
 *
 *  ELILO is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *
 *  ELILO is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with ELILO; see the file COPYING.  If not, write to the Free
 *  Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 *  02111-1307, USA.
 *
 * Please check out the elilo.txt for complete documentation on how
 * to use this program.
 */

#include <efi.h>
#include <efilib.h>

#include "elilo.h"
#include "loader.h"
#include "elf.h"
#include "private.h"

#define LD_NAME L"plain_elf64"

#define PLAIN_MIN_BLOCK_SIZE	sizeof(Elf64_Ehdr) /* see load_elf() for details */

#define SKIPBUFSIZE	2048	/* minimal default size of the skip buffer */
static CHAR8 *skip_buffer;	/* used to skip over unneeded data */
static UINTN skip_bufsize;
static UINTN elf_is_big_endian;	/* true if ELF file is big endian */

static inline UINT64 
bswap64(UINT64 v)
{
        if(elf_is_big_endian) v = __ia64_swab64(v);
        return v;
}

static inline UINT32
bswap32(UINT32 v)
{
        if(elf_is_big_endian) v = __ia64_swab32(v);
        return v;
}

static inline UINT16
bswap16(UINT16 v)
{
        if(elf_is_big_endian) v = __ia64_swab16(v);
        return v;
}

static INTN
is_valid_header(Elf64_Ehdr *ehdr)
{
	UINT16 type, machine;

        if (ehdr->e_ident[EI_DATA] == ELFDATA2MSB) {
		type    = __ia64_swab16(ehdr->e_type);
		machine = __ia64_swab16(ehdr->e_machine);
	} else {
		type    = ehdr->e_type;
		machine = ehdr->e_machine;
	}
	DBG_PRT((L"class=%d type=%d data=%d machine=%d\n", 
		ehdr->e_ident[EI_CLASS],
		type,
		ehdr->e_ident[EI_DATA],
		machine));

	return    ehdr->e_ident[EI_MAG0]  == 0x7f 
	       && ehdr->e_ident[EI_MAG1]  == 'E'
	       && ehdr->e_ident[EI_MAG2]  == 'L'
	       && ehdr->e_ident[EI_MAG3]  == 'F'
	       && ehdr->e_ident[EI_CLASS] == ELFCLASS64 
	       && type                    == ET_EXEC	/* must be executable */
	       && machine                 == EM_IA_64 ? 0 : -1;
}

static INTN
plain_probe(CHAR16 *kname)
{
	Elf64_Ehdr ehdr;
	EFI_STATUS status;
	INTN ret = -1;
	fops_fd_t fd;
	UINTN size = sizeof(ehdr);

	status = fops_open(kname, &fd);
	if (EFI_ERROR(status)) return -1;

	status = fops_read(fd, &ehdr, &size);

	if (EFI_ERROR(status) || size != sizeof(ehdr)) goto error;

	ret = is_valid_header(&ehdr);
error:
	fops_close(fd);
	return ret;
}

/*
 * move skip bytes forward in the file
 * this is required because we cannot assume fileops has
 * seek() capabilities.
 */
static INTN
skip_bytes(fops_fd_t fd, UINTN curpos, UINTN newpos)
{
	EFI_STATUS status;
	UINTN n, skip;

	skip = newpos - curpos;
	/* check if seek capability exists */	

	status = fops_seek(fd, newpos);
	if (status == EFI_SUCCESS) return 0;

	if (status != EFI_UNSUPPORTED) goto error;

	/* unsupported case */

	if (skip_buffer == NULL) {
		skip_bufsize = MAX(skip, SKIPBUFSIZE);
		skip_buffer= (CHAR8 *)alloc(skip_bufsize, EfiLoaderData);
		if (skip_buffer == NULL) return -1;
	}
	while (skip) {
		n = skip > skip_bufsize? skip_bufsize : skip;

		status = fops_read(fd, skip_buffer, &n);
		if (EFI_ERROR(status)) goto error;

		skip -=n;
	}
	return 0;

error:
	ERR_PRT((L"%s : cannot skip %d bytes\n", LD_NAME, n));
	return -1;
}

static INTN
load_elf(fops_fd_t fd, kdesc_t *kd)
{
	Elf64_Ehdr ehdr;
	Elf64_Phdr *phdrs;
	EFI_STATUS status;
	INTN ret = ELILO_LOAD_ERROR;
	UINTN i, total_size = 0;
	UINTN pages, size, bss_sz, osize;
	UINTN offs = 0;
	VOID *low_addr = (VOID *)~0;
	VOID *max_addr = (VOID *)0;
	UINTN load_offset = 0;
	UINTN paddr, memsz, filesz, poffs;
	UINT16 phnum;

	Print(L"Loading Linux... ");

	size = sizeof(ehdr);

	status = fops_read(fd, &ehdr, &size);
	if (EFI_ERROR(status) ||size < sizeof(ehdr)) return ELILO_LOAD_ERROR;

	offs += size;

	/*
	 * do some sanity checking on the file
	 */
	if (is_valid_header(&ehdr) == -1) {
		ERR_PRT((L"%s : not an elf 64-bit file\n", LD_NAME));
		return ELILO_LOAD_ERROR;
	}	 

	/* determine file endianess */
        elf_is_big_endian = ehdr.e_ident[EI_DATA] == ELFDATA2MSB ? 1 : 0;

	VERB_PRT(3, { 
			Print(L"ELF file is %s\n", elf_is_big_endian ? L"big endian" : L"little endian");
			Print(L"Entry point 0x%lx\n", bswap64(ehdr.e_entry));
			Print(L"%d program headers\n", bswap16(ehdr.e_phnum));
			Print(L"%d segment headers\n", bswap16(ehdr.e_shnum));
		   });

	phnum = bswap16(ehdr.e_phnum);

	if (skip_bytes(fd, offs, bswap64(ehdr.e_phoff)) != 0) {
		ERR_PRT((L"%s : skip tp %ld for phdrs failed", LD_NAME, offs));
		return ELILO_LOAD_ERROR;
	}
	offs  = bswap64(ehdr.e_phoff);

	size = osize = phnum*sizeof(Elf64_Phdr);

	DBG_PRT((L"%s : phdrs allocate %d bytes sizeof=%d entsize=%d\n", LD_NAME, size,sizeof(Elf64_Phdr), bswap16(ehdr.e_phentsize)));

	phdrs = (Elf64_Phdr *)alloc(size, 0);
	if (phdrs == NULL) {
		ERR_PRT((L"%s : allocate phdrs failed", LD_NAME));
		return ELILO_LOAD_ERROR;
	}

	status = fops_read(fd, phdrs, &size);
	if (EFI_ERROR(status) || size != osize) {
		ERR_PRT((L"%s : load phdrs failed", LD_NAME, status));
		goto out;
	}
	offs += size;
	/*
	 * First pass to figure out:
	 *	- lowest physical address
	 *	- total memory footprint
	 */
	for (i = 0; i < phnum; i++) {

		paddr = bswap64(phdrs[i].p_paddr);
		memsz = bswap64(phdrs[i].p_memsz);

		DBG_PRT((L"Phdr %d paddr [0x%lx-0x%lx] offset %ld"
			   " filesz %ld memsz=%ld bss_sz=%ld p_type=%d\n",
			   1+i, 
			   paddr, 
			   paddr+bswap64(phdrs[i].p_filesz), 
			   bswap64(phdrs[i].p_offset), 
			   bswap64(phdrs[i].p_filesz), 
			   memsz, 
			   memsz - bswap64(phdrs[i].p_filesz), bswap32(phdrs[i].p_type)));
	
		if (bswap32(phdrs[i].p_type) != PT_LOAD) continue;


		if (paddr < (UINTN)low_addr) low_addr = (VOID *)paddr;

		if (paddr + memsz > (UINTN)max_addr) 
			max_addr = (VOID *)paddr + memsz;
	}

	if ((UINTN)low_addr & (EFI_PAGE_SIZE - 1)) {
		ERR_PRT((L"%s : kernel low address 0x%lx not page aligned\n", LD_NAME, low_addr));
		goto out;
	}

	/* how many bytes are needed to hold the kernel */
	total_size = (UINTN)max_addr - (UINTN)low_addr;

	/* round up to get required number of pages */
	pages = EFI_SIZE_TO_PAGES(total_size);

	/* keep track of location where kernel ends for
	 * the initrd ramdisk (it will be put right after the kernel) 
	 */
	kd->kstart = low_addr;
	kd->kend   = low_addr+ (pages << EFI_PAGE_SHIFT);

	/*
	 * that's the kernel entry point (virtual address)
	 */
	kd->kentry = (VOID *)bswap64(ehdr.e_entry);
	
	if (((UINTN)kd->kentry >> 61) != 0) {
		ERR_PRT((L"%s:  <<ERROR>> entry point is a virtual address 0x%lx : not supported anymore\n", LD_NAME, kd->kentry));
	}

	VERB_PRT(3, {
		Print(L"Lowest PhysAddr: 0x%lx\nTotalMemSize:%d bytes (%d pages)\n",
	      		low_addr, total_size, pages);
		Print(L"Kernel entry @ 0x%lx\n", kd->kentry);
	});

	/*
	 * now allocate memory for the kernel at the exact requested spot
	 */
	if (alloc_kmem(low_addr, pages) == -1) {
		VOID *new_addr;

		ERR_PRT((L"%s : AllocatePages(%d, 0x%lx) for kernel failed\n", LD_NAME, pages, low_addr));

		if (ia64_can_relocate() == 0) {
			ERR_PRT((L"relocation is disabled, cannot load kernel"));
			goto out;
		}

		/*
		 * could not allocate at requested spot, try to find a
		 * suitable location to relocate the kernel
		 *
		 * The maximum sized Itanium TLB translation entry is 256 MB.
		 * If we relocate the kernel by this amount we know for sure
		 * that alignment constraints will be satisified, regardless
		 * of the kernel used.
		 */
		Print(L"Attempting to relocate kernel.\n");
		if (find_kernel_memory(low_addr, max_addr, 256*MB, &new_addr) == -1) {
			ERR_PRT((L"%s : find_kernel_memory(0x%lx, 0x%lx, 0x%lx, 0x%lx) failed\n", LD_NAME, low_addr, max_addr, 256*MB, &load_offset));
			goto out;
		}
		/* unsigned arithmetic */
                load_offset = (UINTN) (new_addr - ROUNDDOWN((UINTN) low_addr,256*MB));

		VERB_PRT(3, Print(L"low_addr=0x%lx new_addr=0x%lx offset=0x%lx", low_addr, new_addr, load_offset));

		/*
		 * correct various addesses for non-zero load_offset
		 */
		low_addr = (VOID*) ((UINTN) low_addr + load_offset);
		max_addr = (VOID*) ((UINTN) max_addr + load_offset);
		kd->kstart = (VOID *) ((UINTN) kd->kstart + load_offset);
		kd->kend = (VOID *) ((UINTN) kd->kend + load_offset);
		kd->kentry = (VOID *) ((UINTN) kd->kentry + load_offset);

		/*
		 * try one last time to get memory for the kernel
		 */
		if (alloc_kmem(low_addr, pages) == -1) {
			ERR_PRT((L"%s : AllocatePages(%d, 0x%lx) for kernel failed\n", LD_NAME, pages, low_addr));
			ERR_PRT((L"Relocation by 0x%lx bytes failed.\n", load_offset));
			goto out;
		}
	}

	VERB_PRT(1, Print(L"Press any key to interrupt\n"));

	/* Second pass:
	 * Walk through the program headers
	 * and actually load data into physical memory
	 */
	for (i = 0; i < phnum; i++) {

		/*
		 * Check for pure loadable segment; ignore if not loadable
		 */
		if (bswap32(phdrs[i].p_type) != PT_LOAD) continue;

		poffs = bswap64(phdrs[i].p_offset);

		size = poffs - offs;

		VERB_PRT(3, Print(L"\noff=%ld poffs=%ld size=%ld\n", offs, poffs, size));

		filesz = bswap64(phdrs[i].p_filesz);
                /*
                 * correct p_paddr for non-zero load offset
                 */
		phdrs[i].p_paddr = (Elf64_Addr) ((UINTN) bswap64(phdrs[i].p_paddr) + load_offset);

		/*
		 * Move to the right position
		 */
		if (size && skip_bytes(fd, offs, poffs) != 0) goto out_kernel;

		/*
		 * Keep track of current position in file
		 */
		offs += size;

		/*
		 * How many BSS bytes to clear
		 */
		bss_sz = bswap64(phdrs[i].p_memsz) - filesz;

		VERB_PRT(4, {
			Print(L"\nHeader #%d\n", i);
			Print(L"offset %ld\n", poffs);
			Print(L"Phys addr 0x%lx\n", phdrs[i].p_paddr); /* already endian adjusted */
			Print(L"BSS size %ld bytes\n", bss_sz);
			Print(L"skip=%ld offs=%ld\n", size, offs);
		});

		/*
		 * Read actual segment into memory
		 */
		ret = read_file(fd, filesz, (CHAR8 *)phdrs[i].p_paddr);
		if (ret == ELILO_LOAD_ABORTED) goto load_abort;
		if (ret == ELILO_LOAD_ERROR) goto out;

		/*
		 * update file position
		 */
		offs += filesz;

		/*
		 * Clear bss section
		 */
		if (bss_sz) Memset((VOID *) phdrs[i].p_paddr+filesz, 0, bss_sz);
	}

	free(phdrs);

	Print(L"..done\n");
	return ELILO_LOAD_SUCCESS;

load_abort:
	Print(L"..Aborted\n");
	ret = ELILO_LOAD_ABORTED;
out_kernel:
	/* free kernel memory */
	free_kmem();
out:
	free(phdrs);
	return ret;
}

static INTN
plain_load_kernel(CHAR16 *kname, kdesc_t *kd)
{	
	INTN ret;
	fops_fd_t fd;
	EFI_STATUS status;

	/*
	 * Moving the open here simplifies the load_elf() error handling
	 */
	status = fops_open(kname, &fd);
	if (EFI_ERROR(status)) return ELILO_LOAD_ERROR;

	Print(L"Loading %s...", kname);

	ret = load_elf(fd, kd);

	fops_close(fd);

	/*
	 * if the skip buffer was ever used, free it
	 */
	if (skip_buffer) {
		free(skip_buffer);
		/* in case we come back */
		skip_buffer = NULL;
	}
	return ret;
}

loader_ops_t plain_loader={
	NULL,
	LD_NAME,
	plain_probe,
	plain_load_kernel
};