d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* Flesh out elf_exec and bootinfo.

Browse Source 
* Add EFI network support.
This commit is contained in:
Doug Rabson 2001-09-22 19:10:56 +00:00
parent 22374865a2
commit 1271403685
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=83828
7 changed files with 1162 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sys/boot/efi/libefi/Makefile
View File

@ -7,7 +7,7 @@ INTERNALLIB= true
INTERNALSTATICLIB= true
SRCS= libefi.c efi_console.c time.c copy.c devicename.c module.c exit.c
SRCS+= delay.c efifs.c elf_freebsd.c
SRCS+= delay.c efifs.c efinet.c elf_freebsd.c bootinfo.c
CFLAGS+= -fpic
CFLAGS+= -I${.CURDIR}/../include

346
sys/boot/efi/libefi/bootinfo.c Normal file
View File

@ -0,0 +1,346 @@
/*-
* Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <stand.h>
#include <string.h>
#include <sys/param.h>
#include <sys/reboot.h>
#include <sys/linker.h>
#include <machine/elf.h>
#include <machine/bootinfo.h>
#include <efi.h>
#include <efilib.h>
#include "bootstrap.h"
/*
* Return a 'boothowto' value corresponding to the kernel arguments in
* (kargs) and any relevant environment variables.
*/
static struct
{
const char *ev;
int mask;
} howto_names[] = {
{"boot_askname", RB_ASKNAME},
{"boot_cdrom", RB_CDROM},
{"boot_userconfig", RB_CONFIG},
{"boot_ddb", RB_KDB},
{"boot_gdb", RB_GDB},
{"boot_single", RB_SINGLE},
{"boot_verbose", RB_VERBOSE},
{NULL, 0}
};
extern char *efi_fmtdev(void *vdev);
int
bi_getboothowto(char *kargs)
{
char *cp;
int howto;
int active;
int i;
/* Parse kargs */
howto = 0;
if (kargs != NULL) {
cp = kargs;
active = 0;
while (*cp != 0) {
if (!active && (*cp == '-')) {
active = 1;
} else if (active)
switch (*cp) {
case 'a':
howto |= RB_ASKNAME;
break;
case 'c':
howto |= RB_CONFIG;
break;
case 'C':
howto |= RB_CDROM;
break;
case 'd':
howto |= RB_KDB;
break;
case 'm':
howto |= RB_MUTE;
break;
case 'g':
howto |= RB_GDB;
break;
case 'h':
howto |= RB_SERIAL;
break;
case 'r':
howto |= RB_DFLTROOT;
break;
case 's':
howto |= RB_SINGLE;
break;
case 'v':
howto |= RB_VERBOSE;
break;
default:
active = 0;
break;
}
cp++;
}
}
/* get equivalents from the environment */
for (i = 0; howto_names[i].ev != NULL; i++)
if (getenv(howto_names[i].ev) != NULL)
howto |= howto_names[i].mask;
if (!strcmp(getenv("console"), "comconsole"))
howto |= RB_SERIAL;
if (!strcmp(getenv("console"), "nullconsole"))
howto |= RB_MUTE;
return(howto);
}
/*
* Copy the environment into the load area starting at (addr).
* Each variable is formatted as <name>=<value>, with a single nul
* separating each variable, and a double nul terminating the environment.
*/
vm_offset_t
bi_copyenv(vm_offset_t addr)
{
struct env_var *ep;
/* traverse the environment */
for (ep = environ; ep != NULL; ep = ep->ev_next) {
efi_copyin(ep->ev_name, addr, strlen(ep->ev_name));
addr += strlen(ep->ev_name);
efi_copyin("=", addr, 1);
addr++;
if (ep->ev_value != NULL) {
efi_copyin(ep->ev_value, addr, strlen(ep->ev_value));
addr += strlen(ep->ev_value);
}
efi_copyin("", addr, 1);
addr++;
}
efi_copyin("", addr, 1);
addr++;
return(addr);
}
/*
* Copy module-related data into the load area, where it can be
* used as a directory for loaded modules.
*
* Module data is presented in a self-describing format. Each datum
* is preceded by a 32-bit identifier and a 32-bit size field.
*
* Currently, the following data are saved:
*
* MOD_NAME (variable) module name (string)
* MOD_TYPE (variable) module type (string)
* MOD_ARGS (variable) module parameters (string)
* MOD_ADDR sizeof(vm_offset_t) module load address
* MOD_SIZE sizeof(size_t) module size
* MOD_METADATA (variable) type-specific metadata
*/
#define COPY32(v, a) { \
u_int32_t x = (v); \
efi_copyin(&x, a, sizeof(x)); \
a += sizeof(x); \
}
#define MOD_STR(t, a, s) { \
COPY32(t, a); \
COPY32(strlen(s) + 1, a); \
efi_copyin(s, a, strlen(s) + 1); \
a += roundup(strlen(s) + 1, sizeof(u_int64_t));\
}
#define MOD_NAME(a, s) MOD_STR(MODINFO_NAME, a, s)
#define MOD_TYPE(a, s) MOD_STR(MODINFO_TYPE, a, s)
#define MOD_ARGS(a, s) MOD_STR(MODINFO_ARGS, a, s)
#define MOD_VAR(t, a, s) { \
COPY32(t, a); \
COPY32(sizeof(s), a); \
efi_copyin(&s, a, sizeof(s)); \
a += roundup(sizeof(s), sizeof(u_int64_t)); \
}
#define MOD_ADDR(a, s) MOD_VAR(MODINFO_ADDR, a, s)
#define MOD_SIZE(a, s) MOD_VAR(MODINFO_SIZE, a, s)
#define MOD_METADATA(a, mm) { \
COPY32(MODINFO_METADATA | mm->md_type, a); \
COPY32(mm->md_size, a); \
efi_copyin(mm->md_data, a, mm->md_size); \
a += roundup(mm->md_size, sizeof(u_int64_t));\
}
#define MOD_END(a) { \
COPY32(MODINFO_END, a); \
COPY32(0, a); \
}
vm_offset_t
bi_copymodules(vm_offset_t addr)
{
struct preloaded_file *fp;
struct file_metadata *md;
/* start with the first module on the list, should be the kernel */
for (fp = file_findfile(NULL, NULL); fp != NULL; fp = fp->f_next) {
MOD_NAME(addr, fp->f_name); /* this field must come first */
MOD_TYPE(addr, fp->f_type);
if (fp->f_args)
MOD_ARGS(addr, fp->f_args);
MOD_ADDR(addr, fp->f_addr);
MOD_SIZE(addr, fp->f_size);
for (md = fp->f_metadata; md != NULL; md = md->md_next)
if (!(md->md_type & MODINFOMD_NOCOPY))
MOD_METADATA(addr, md);
}
MOD_END(addr);
return(addr);
}
/*
* Load the information expected by an alpha kernel.
*
* - The kernel environment is copied into kernel space.
* - Module metadata are formatted and placed in kernel space.
*/
int
bi_load(struct bootinfo *bi, struct preloaded_file *fp, char *args)
{
char *rootdevname;
struct efi_devdesc *rootdev;
struct preloaded_file *xp;
vm_offset_t addr, bootinfo_addr;
u_int pad;
char *kernelname;
vm_offset_t ssym, esym;
struct file_metadata *md;
EFI_STATUS status;
UINTN key;
/*
* Version 1 bootinfo.
*/
bi->bi_magic = BOOTINFO_MAGIC;
bi->bi_version = 1;
/*
* Calculate boothowto.
*/
bi->bi_boothowto = bi_getboothowto(fp->f_args);
/*
* Stash EFI System Table.
*/
bi->bi_systab = (u_int64_t) ST;
/*
* Allow the environment variable 'rootdev' to override the supplied device
* This should perhaps go to MI code and/or have $rootdev tested/set by
* MI code before launching the kernel.
*/
rootdevname = getenv("rootdev");
efi_getdev((void **)(&rootdev), rootdevname, NULL);
if (rootdev == NULL) { /* bad $rootdev/$currdev */
printf("can't determine root device\n");
return(EINVAL);
}
/* Try reading the /etc/fstab file to select the root device */
getrootmount(efi_fmtdev((void *)rootdev));
free(rootdev);
ssym = esym = 0;
if ((md = file_findmetadata(fp, MODINFOMD_SSYM)) != NULL)
ssym = *((vm_offset_t *)&(md->md_data));
if ((md = file_findmetadata(fp, MODINFOMD_ESYM)) != NULL)
esym = *((vm_offset_t *)&(md->md_data));
if (ssym == 0 || esym == 0)
ssym = esym = 0; /* sanity */
bi->bi_symtab = ssym;
bi->bi_esymtab = esym;
/* find the last module in the chain */
addr = 0;
for (xp = file_findfile(NULL, NULL); xp != NULL; xp = xp->f_next) {
if (addr < (xp->f_addr + xp->f_size))
addr = xp->f_addr + xp->f_size;
}
/* pad to a page boundary */
pad = (u_int)addr & PAGE_MASK;
if (pad != 0) {
pad = PAGE_SIZE - pad;
addr += pad;
}
/* copy our environment */
bi->bi_envp = addr;
addr = bi_copyenv(addr);
/* pad to a page boundary */
pad = (u_int)addr & PAGE_MASK;
if (pad != 0) {
pad = PAGE_SIZE - pad;
addr += pad;
}
/* copy module list and metadata */
bi->bi_modulep = addr;
addr = bi_copymodules(addr);
/* all done copying stuff in, save end of loaded object space */
bi->bi_kernend = addr;
kernelname = getenv("kernelname");
if (kernelname) {
strncpy(bi->bi_kernel, kernelname, sizeof(bi->bi_kernel) - 1);
}
/* read memory map and stash it after bootinfo */
bi->bi_memmap = (u_int64_t)(bi + 1);
bi->bi_memmap_size = 8192 - sizeof(struct bootinfo);
status = BS->GetMemoryMap(&bi->bi_memmap_size,
(EFI_MEMORY_DESCRIPTOR *)bi->bi_memmap,
&key,
&bi->bi_memdesc_size,
&bi->bi_memdesc_version);
if (EFI_ERROR(status)) {
printf("bi_load: Can't read memory map\n");
}
return(0);
}

7
sys/boot/efi/libefi/efiboot.h
View File

@ -66,6 +66,9 @@ extern struct devsw efifs_dev;
extern struct devsw efi_disk;
extern struct netif_driver efi_net;
/* Find EFI network resources */
extern void efinet_init_driver(void);
/* Wrapper over EFI filesystems. */
extern struct fs_ops efi_fsops;
@ -79,3 +82,7 @@ extern ssize_t efi_readin(int fd, vm_offset_t dest, size_t len);
extern int efi_boot(void);
extern int efi_autoload(void);
struct bootinfo;
struct preloaded_file;
extern int bi_load(struct bootinfo *, struct preloaded_file *);

176
sys/boot/efi/libefi/efinet.c Normal file
View File

@ -0,0 +1,176 @@
/*-
* Copyright (c) 2001 Doug Rabson
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <sys/param.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <stand.h>
#include <net.h>
#include <netif.h>
#include <efi.h>
#include <efilib.h>
extern struct netif_driver efi_net;
int
efinet_match(struct netif *nif, void *machdep_hint)
{
return (1);
}
int
efinet_probe(struct netif *nif, void *machdep_hint)
{
return (0);
}
int
efinet_put(struct iodesc *desc, void *pkt, size_t len)
{
EFI_SIMPLE_NETWORK *net = desc->io_netif->nif_devdata;
EFI_STATUS status;
int i;
status = net->Transmit(net, 0, len, pkt, 0, 0, 0);
if (!EFI_ERROR(status))
return len;
else
return -1;
}
int
efinet_get(struct iodesc *desc, void *pkt, size_t len, time_t timeout)
{
EFI_SIMPLE_NETWORK *net = desc->io_netif->nif_devdata;
EFI_STATUS status;
UINTN bufsz;
time_t t;
t = time(0);
while ((time(0) - t) < timeout) {
bufsz = len;
status = net->Receive(net, 0, &bufsz, pkt, 0, 0, 0);
if (status == EFI_SUCCESS)
return bufsz;
if (status != EFI_NOT_READY)
return 0;
}
return 0;
}
void
efinet_init(struct iodesc *desc, void *machdep_hint)
{
struct netif *nif;
EFI_SIMPLE_NETWORK *net;
int i;
nif = desc->io_netif;
net = nif->nif_driver->netif_ifs[nif->nif_unit].dif_private;
desc->io_netif->nif_devdata = net;
net->Start(net);
net->Initialize(net, 0, 0);
bcopy(net->Mode->CurrentAddress.Addr, desc->myea, 6);
desc->xid = 1;
return;
}
void
efinet_init_driver()
{
EFI_STATUS status;
UINTN sz;
static EFI_GUID netid = EFI_SIMPLE_NETWORK_PROTOCOL;
EFI_HANDLE *handles;
int nifs, i;
#define MAX_INTERFACES 4
static struct netif_dif difs[MAX_INTERFACES];
static struct netif_stats stats[MAX_INTERFACES];
sz = 0;
status = BS->LocateHandle(ByProtocol, &netid, 0, &sz, 0);
if (status != EFI_BUFFER_TOO_SMALL)
return;
handles = (EFI_HANDLE *) malloc(sz);
status = BS->LocateHandle(ByProtocol, &netid, 0, &sz, handles);
if (EFI_ERROR(status)) {
free(handles);
return;
}
nifs = sz / sizeof(EFI_HANDLE);
if (nifs > MAX_INTERFACES)
nifs = MAX_INTERFACES;
efi_net.netif_nifs = nifs;
efi_net.netif_ifs = difs;
bzero(stats, sizeof(stats));
for (i = 0; i < nifs; i++) {
struct netif_dif *dif = &efi_net.netif_ifs[i];
dif->dif_unit = i;
dif->dif_nsel = 1;
dif->dif_stats = &stats[i];
dif->dif_private = handles[i];
BS->HandleProtocol(handles[i], &netid,
(VOID**) &dif->dif_private);
}
return;
}
void
efinet_end(struct netif *nif)
{
EFI_SIMPLE_NETWORK *net = nif->nif_devdata;
net->Shutdown(net);
}
struct netif_driver efi_net = {
"net", /* netif_bname */
efinet_match, /* netif_match */
efinet_probe, /* netif_probe */
efinet_init, /* netif_init */
efinet_get, /* netif_get */
efinet_put, /* netif_put */
efinet_end, /* netif_end */
0, /* netif_ifs */
0 /* netif_nifs */
};

178
sys/boot/efi/libefi/elf_freebsd.c
View File

@ -92,46 +92,154 @@ static int elf_exec(struct preloaded_file *amp);
struct file_format ia64_elf = { elf_loadfile, elf_exec };
#define PTE_MA_WB 0
#define PTE_MA_UC 4
#define PTE_MA_UCE 5
#define PTE_MA_WC 6
#define PTE_MA_NATPAGE 7
#define PTE_PL_KERN 0
#define PTE_PL_USER 3
#define PTE_AR_R 0
#define PTE_AR_RX 1
#define PTE_AR_RW 2
#define PTE_AR_RWX 3
#define PTE_AR_R_RW 4
#define PTE_AR_RX_RWX 5
#define PTE_AR_RWX_RW 6
#define PTE_AR_X_RX 7
static __inline u_int64_t
disable_ic()
{
u_int64_t psr;
__asm __volatile("mov %0=psr;;" : "=r" (psr));
__asm __volatile("rsm psr.ic;; srlz.i;;");
return psr;
}
static __inline void
restore_ic(u_int64_t psr)
{
__asm __volatile("mov psr.l=%0;; srlz.i" :: "r" (psr));
}
/*
* A short-format VHPT entry. Also matches the TLB insertion format.
*/
struct ia64_pte {
u_int64_t pte_p :1; /* bits 0..0 */
u_int64_t pte_rv1 :1; /* bits 1..1 */
u_int64_t pte_ma :3; /* bits 2..4 */
u_int64_t pte_a :1; /* bits 5..5 */
u_int64_t pte_d :1; /* bits 6..6 */
u_int64_t pte_pl :2; /* bits 7..8 */
u_int64_t pte_ar :3; /* bits 9..11 */
u_int64_t pte_ppn :38; /* bits 12..49 */
u_int64_t pte_rv2 :2; /* bits 50..51 */
u_int64_t pte_ed :1; /* bits 52..52 */
u_int64_t pte_ig :11; /* bits 53..63 */
};
void
enter_kernel(const char* filename, u_int64_t start)
{
u_int64_t psr;
printf("Entering %s at 0x%lx...\n", filename, start);
psr = disable_ic();
__asm __volatile("srlz.i;;");
__asm __volatile("mov cr.ipsr=%0"
:: "r"(IA64_PSR_IC
| IA64_PSR_DT
| IA64_PSR_RT
| IA64_PSR_IT
| IA64_PSR_BN));
__asm __volatile("mov cr.iip=%0" :: "r"(start));
__asm __volatile("mov cr.ifs=r0;;");
__asm __volatile("mov ar.rsc=0;; flushrs;;");
__asm __volatile("1: mov r8=ip;; add r8=2f-1b,r8; mov r9=%0; rfi;; 2:"
:: "r"(psr));
}
static int
elf_exec(struct preloaded_file *fp)
{
#if 0
static struct bootinfo_v1 bootinfo_v1;
struct file_metadata *md;
Elf_Ehdr *hdr;
int err;
struct file_metadata *md;
Elf_Ehdr *hdr;
struct ia64_pte pte;
struct bootinfo *bi;
u_int64_t psr;
if ((md = file_findmetadata(fp, MODINFOMD_ELFHDR)) == NULL)
return(EFTYPE); /* XXX actually EFUCKUP */
hdr = (Elf_Ehdr *)&(md->md_data);
if ((md = file_findmetadata(fp, MODINFOMD_ELFHDR)) == NULL)
return(EFTYPE); /* XXX actually EFUCKUP */
hdr = (Elf_Ehdr *)&(md->md_data);
/* XXX ffp_save does not appear to be used in the kernel.. */
bzero(&bootinfo_v1, sizeof(bootinfo_v1));
err = bi_load(&bootinfo_v1, &ffp_save, fp);
if (err)
return(err);
/*
* Ugly hack, similar to linux. Dump the bootinfo into a
* special page reserved in the link map.
*/
bi = (struct bootinfo *) 0x508000;
bzero(bi, sizeof(struct bootinfo));
bi_load(bi, fp);
/*
* Fill in the bootinfo for the kernel.
*/
strncpy(bootinfo_v1.booted_kernel, fp->f_name,
sizeof(bootinfo_v1.booted_kernel));
prom_getenv(PROM_E_BOOTED_OSFLAGS, bootinfo_v1.boot_flags,
sizeof(bootinfo_v1.boot_flags));
bootinfo_v1.hwrpb = (void *)HWRPB_ADDR;
bootinfo_v1.hwrpbsize = ((struct rpb *)HWRPB_ADDR)->rpb_size;
bootinfo_v1.cngetc = NULL;
bootinfo_v1.cnputc = NULL;
bootinfo_v1.cnpollc = NULL;
/*
* Region 6 is direct mapped UC and region 7 is direct mapped
* WC. The details of this is controlled by the Alt {I,D}TLB
* handlers. Here we just make sure that they have the largest
* possible page size to minimise TLB usage.
*/
ia64_set_rr(IA64_RR_BASE(6), (6 << 8) | (28 << 2));
ia64_set_rr(IA64_RR_BASE(7), (7 << 8) | (28 << 2));
printf("Entering %s at 0x%lx...\n", fp->f_name, hdr->e_entry);
exit(0);
closeall();
alpha_pal_imb();
(*(void (*)())hdr->e_entry)(ffp_save, ptbr_save,
BOOTINFO_MAGIC, &bootinfo_v1, 1, 0);
#endif
bzero(&pte, sizeof(pte));
pte.pte_p = 1;
pte.pte_ma = PTE_MA_WB;
pte.pte_a = 1;
pte.pte_d = 1;
pte.pte_pl = PTE_PL_KERN;
pte.pte_ar = PTE_AR_RWX;
pte.pte_ppn = 0;
psr = disable_ic();
__asm __volatile("mov cr.ifa=%0" :: "r"(IA64_RR_BASE(7)));
__asm __volatile("mov cr.itir=%0" :: "r"(28 << 2));
__asm __volatile("ptr.i %0,%1" :: "r"(IA64_RR_BASE(7)), "r"(28<<2));
__asm __volatile("ptr.d %0,%1" :: "r"(IA64_RR_BASE(7)), "r"(28<<2));
__asm __volatile("srlz.i;;");
__asm __volatile("itr.i itr[%0]=%1;;"
:: "r"(0), "r"(*(u_int64_t*)&pte));
__asm __volatile("itr.d dtr[%0]=%1;;"
:: "r"(0), "r"(*(u_int64_t*)&pte));
__asm __volatile("srlz.i;;");
restore_ic(psr);
bzero(&pte, sizeof(pte));
pte.pte_p = 1;
pte.pte_ma = PTE_MA_UC;
pte.pte_a = 1;
pte.pte_d = 1;
pte.pte_pl = PTE_PL_KERN;
pte.pte_ar = PTE_AR_RWX;
pte.pte_ppn = 0xffffc000000 >> 12;
psr = disable_ic();
__asm __volatile("mov cr.ifa=%0" :: "r"(IA64_PHYS_TO_RR6(0xffffc000000)));
__asm __volatile("mov cr.itir=%0" :: "r"(26 << 2));
__asm __volatile("ptr.d %0,%1" :: "r"(IA64_PHYS_TO_RR6(0xffffc000000)), "r"(26<<2));
__asm __volatile("srlz.i;;");
__asm __volatile("itr.d dtr[%0]=%1;;"
:: "r"(1), "r"(*(u_int64_t*)&pte));
__asm __volatile("srlz.i;;");
restore_ic(psr);
enter_kernel(fp->f_name, hdr->e_entry);
}

346
sys/boot/ia64/common/bootinfo.c Normal file
View File

@ -0,0 +1,346 @@
/*-
* Copyright (c) 1998 Michael Smith <msmith@freebsd.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
#include <stand.h>
#include <string.h>
#include <sys/param.h>
#include <sys/reboot.h>
#include <sys/linker.h>
#include <machine/elf.h>
#include <machine/bootinfo.h>
#include <efi.h>
#include <efilib.h>
#include "bootstrap.h"
/*
* Return a 'boothowto' value corresponding to the kernel arguments in
* (kargs) and any relevant environment variables.
*/
static struct
{
const char *ev;
int mask;
} howto_names[] = {
{"boot_askname", RB_ASKNAME},
{"boot_cdrom", RB_CDROM},
{"boot_userconfig", RB_CONFIG},
{"boot_ddb", RB_KDB},
{"boot_gdb", RB_GDB},
{"boot_single", RB_SINGLE},
{"boot_verbose", RB_VERBOSE},
{NULL, 0}
};
extern char *efi_fmtdev(void *vdev);
int
bi_getboothowto(char *kargs)
{
char *cp;
int howto;
int active;
int i;
/* Parse kargs */
howto = 0;
if (kargs != NULL) {
cp = kargs;
active = 0;
while (*cp != 0) {
if (!active && (*cp == '-')) {
active = 1;
} else if (active)
switch (*cp) {
case 'a':
howto |= RB_ASKNAME;
break;
case 'c':
howto |= RB_CONFIG;
break;
case 'C':
howto |= RB_CDROM;
break;
case 'd':
howto |= RB_KDB;
break;
case 'm':
howto |= RB_MUTE;
break;
case 'g':
howto |= RB_GDB;
break;
case 'h':
howto |= RB_SERIAL;
break;
case 'r':
howto |= RB_DFLTROOT;
break;
case 's':
howto |= RB_SINGLE;
break;
case 'v':
howto |= RB_VERBOSE;
break;
default:
active = 0;
break;
}
cp++;
}
}
/* get equivalents from the environment */
for (i = 0; howto_names[i].ev != NULL; i++)
if (getenv(howto_names[i].ev) != NULL)
howto |= howto_names[i].mask;
if (!strcmp(getenv("console"), "comconsole"))
howto |= RB_SERIAL;
if (!strcmp(getenv("console"), "nullconsole"))
howto |= RB_MUTE;
return(howto);
}
/*
* Copy the environment into the load area starting at (addr).
* Each variable is formatted as <name>=<value>, with a single nul
* separating each variable, and a double nul terminating the environment.
*/
vm_offset_t
bi_copyenv(vm_offset_t addr)
{
struct env_var *ep;
/* traverse the environment */
for (ep = environ; ep != NULL; ep = ep->ev_next) {
efi_copyin(ep->ev_name, addr, strlen(ep->ev_name));
addr += strlen(ep->ev_name);
efi_copyin("=", addr, 1);
addr++;
if (ep->ev_value != NULL) {
efi_copyin(ep->ev_value, addr, strlen(ep->ev_value));
addr += strlen(ep->ev_value);
}
efi_copyin("", addr, 1);
addr++;
}
efi_copyin("", addr, 1);
addr++;
return(addr);
}
/*
* Copy module-related data into the load area, where it can be
* used as a directory for loaded modules.
*
* Module data is presented in a self-describing format. Each datum
* is preceded by a 32-bit identifier and a 32-bit size field.
*
* Currently, the following data are saved:
*
* MOD_NAME (variable) module name (string)
* MOD_TYPE (variable) module type (string)
* MOD_ARGS (variable) module parameters (string)
* MOD_ADDR sizeof(vm_offset_t) module load address
* MOD_SIZE sizeof(size_t) module size
* MOD_METADATA (variable) type-specific metadata
*/
#define COPY32(v, a) { \
u_int32_t x = (v); \
efi_copyin(&x, a, sizeof(x)); \
a += sizeof(x); \
}
#define MOD_STR(t, a, s) { \
COPY32(t, a); \
COPY32(strlen(s) + 1, a); \
efi_copyin(s, a, strlen(s) + 1); \
a += roundup(strlen(s) + 1, sizeof(u_int64_t));\
}
#define MOD_NAME(a, s) MOD_STR(MODINFO_NAME, a, s)
#define MOD_TYPE(a, s) MOD_STR(MODINFO_TYPE, a, s)
#define MOD_ARGS(a, s) MOD_STR(MODINFO_ARGS, a, s)
#define MOD_VAR(t, a, s) { \
COPY32(t, a); \
COPY32(sizeof(s), a); \
efi_copyin(&s, a, sizeof(s)); \
a += roundup(sizeof(s), sizeof(u_int64_t)); \
}
#define MOD_ADDR(a, s) MOD_VAR(MODINFO_ADDR, a, s)
#define MOD_SIZE(a, s) MOD_VAR(MODINFO_SIZE, a, s)
#define MOD_METADATA(a, mm) { \
COPY32(MODINFO_METADATA | mm->md_type, a); \
COPY32(mm->md_size, a); \
efi_copyin(mm->md_data, a, mm->md_size); \
a += roundup(mm->md_size, sizeof(u_int64_t));\
}
#define MOD_END(a) { \
COPY32(MODINFO_END, a); \
COPY32(0, a); \
}
vm_offset_t
bi_copymodules(vm_offset_t addr)
{
struct preloaded_file *fp;
struct file_metadata *md;
/* start with the first module on the list, should be the kernel */
for (fp = file_findfile(NULL, NULL); fp != NULL; fp = fp->f_next) {
MOD_NAME(addr, fp->f_name); /* this field must come first */
MOD_TYPE(addr, fp->f_type);
if (fp->f_args)
MOD_ARGS(addr, fp->f_args);
MOD_ADDR(addr, fp->f_addr);
MOD_SIZE(addr, fp->f_size);
for (md = fp->f_metadata; md != NULL; md = md->md_next)
if (!(md->md_type & MODINFOMD_NOCOPY))
MOD_METADATA(addr, md);
}
MOD_END(addr);
return(addr);
}
/*
* Load the information expected by an alpha kernel.
*
* - The kernel environment is copied into kernel space.
* - Module metadata are formatted and placed in kernel space.
*/
int
bi_load(struct bootinfo *bi, struct preloaded_file *fp, char *args)
{
char *rootdevname;
struct efi_devdesc *rootdev;
struct preloaded_file *xp;
vm_offset_t addr, bootinfo_addr;
u_int pad;
char *kernelname;
vm_offset_t ssym, esym;
struct file_metadata *md;
EFI_STATUS status;
UINTN key;
/*
* Version 1 bootinfo.
*/
bi->bi_magic = BOOTINFO_MAGIC;
bi->bi_version = 1;
/*
* Calculate boothowto.
*/
bi->bi_boothowto = bi_getboothowto(fp->f_args);
/*
* Stash EFI System Table.
*/
bi->bi_systab = (u_int64_t) ST;
/*
* Allow the environment variable 'rootdev' to override the supplied device
* This should perhaps go to MI code and/or have $rootdev tested/set by
* MI code before launching the kernel.
*/
rootdevname = getenv("rootdev");
efi_getdev((void **)(&rootdev), rootdevname, NULL);
if (rootdev == NULL) { /* bad $rootdev/$currdev */
printf("can't determine root device\n");
return(EINVAL);
}
/* Try reading the /etc/fstab file to select the root device */
getrootmount(efi_fmtdev((void *)rootdev));
free(rootdev);
ssym = esym = 0;
if ((md = file_findmetadata(fp, MODINFOMD_SSYM)) != NULL)
ssym = *((vm_offset_t *)&(md->md_data));
if ((md = file_findmetadata(fp, MODINFOMD_ESYM)) != NULL)
esym = *((vm_offset_t *)&(md->md_data));
if (ssym == 0 || esym == 0)
ssym = esym = 0; /* sanity */
bi->bi_symtab = ssym;
bi->bi_esymtab = esym;
/* find the last module in the chain */
addr = 0;
for (xp = file_findfile(NULL, NULL); xp != NULL; xp = xp->f_next) {
if (addr < (xp->f_addr + xp->f_size))
addr = xp->f_addr + xp->f_size;
}
/* pad to a page boundary */
pad = (u_int)addr & PAGE_MASK;
if (pad != 0) {
pad = PAGE_SIZE - pad;
addr += pad;
}
/* copy our environment */
bi->bi_envp = addr;
addr = bi_copyenv(addr);
/* pad to a page boundary */
pad = (u_int)addr & PAGE_MASK;
if (pad != 0) {
pad = PAGE_SIZE - pad;
addr += pad;
}
/* copy module list and metadata */
bi->bi_modulep = addr;
addr = bi_copymodules(addr);
/* all done copying stuff in, save end of loaded object space */
bi->bi_kernend = addr;
kernelname = getenv("kernelname");
if (kernelname) {
strncpy(bi->bi_kernel, kernelname, sizeof(bi->bi_kernel) - 1);
}
/* read memory map and stash it after bootinfo */
bi->bi_memmap = (u_int64_t)(bi + 1);
bi->bi_memmap_size = 8192 - sizeof(struct bootinfo);
status = BS->GetMemoryMap(&bi->bi_memmap_size,
(EFI_MEMORY_DESCRIPTOR *)bi->bi_memmap,
&key,
&bi->bi_memdesc_size,
&bi->bi_memdesc_version);
if (EFI_ERROR(status)) {
printf("bi_load: Can't read memory map\n");
}
return(0);
}

178
sys/boot/ia64/common/exec.c
View File

@ -92,46 +92,154 @@ static int elf_exec(struct preloaded_file *amp);
struct file_format ia64_elf = { elf_loadfile, elf_exec };
#define PTE_MA_WB 0
#define PTE_MA_UC 4
#define PTE_MA_UCE 5
#define PTE_MA_WC 6
#define PTE_MA_NATPAGE 7
#define PTE_PL_KERN 0
#define PTE_PL_USER 3
#define PTE_AR_R 0
#define PTE_AR_RX 1
#define PTE_AR_RW 2
#define PTE_AR_RWX 3
#define PTE_AR_R_RW 4
#define PTE_AR_RX_RWX 5
#define PTE_AR_RWX_RW 6
#define PTE_AR_X_RX 7
static __inline u_int64_t
disable_ic()
{
u_int64_t psr;
__asm __volatile("mov %0=psr;;" : "=r" (psr));
__asm __volatile("rsm psr.ic;; srlz.i;;");
return psr;
}
static __inline void
restore_ic(u_int64_t psr)
{
__asm __volatile("mov psr.l=%0;; srlz.i" :: "r" (psr));
}
/*
* A short-format VHPT entry. Also matches the TLB insertion format.
*/
struct ia64_pte {
u_int64_t pte_p :1; /* bits 0..0 */
u_int64_t pte_rv1 :1; /* bits 1..1 */
u_int64_t pte_ma :3; /* bits 2..4 */
u_int64_t pte_a :1; /* bits 5..5 */
u_int64_t pte_d :1; /* bits 6..6 */
u_int64_t pte_pl :2; /* bits 7..8 */
u_int64_t pte_ar :3; /* bits 9..11 */
u_int64_t pte_ppn :38; /* bits 12..49 */
u_int64_t pte_rv2 :2; /* bits 50..51 */
u_int64_t pte_ed :1; /* bits 52..52 */
u_int64_t pte_ig :11; /* bits 53..63 */
};
void
enter_kernel(const char* filename, u_int64_t start)
{
u_int64_t psr;
printf("Entering %s at 0x%lx...\n", filename, start);
psr = disable_ic();
__asm __volatile("srlz.i;;");
__asm __volatile("mov cr.ipsr=%0"
:: "r"(IA64_PSR_IC
| IA64_PSR_DT
| IA64_PSR_RT
| IA64_PSR_IT
| IA64_PSR_BN));
__asm __volatile("mov cr.iip=%0" :: "r"(start));
__asm __volatile("mov cr.ifs=r0;;");
__asm __volatile("mov ar.rsc=0;; flushrs;;");
__asm __volatile("1: mov r8=ip;; add r8=2f-1b,r8; mov r9=%0; rfi;; 2:"
:: "r"(psr));
}
static int
elf_exec(struct preloaded_file *fp)
{
#if 0
static struct bootinfo_v1 bootinfo_v1;
struct file_metadata *md;
Elf_Ehdr *hdr;
int err;
struct file_metadata *md;
Elf_Ehdr *hdr;
struct ia64_pte pte;
struct bootinfo *bi;
u_int64_t psr;
if ((md = file_findmetadata(fp, MODINFOMD_ELFHDR)) == NULL)
return(EFTYPE); /* XXX actually EFUCKUP */
hdr = (Elf_Ehdr *)&(md->md_data);
if ((md = file_findmetadata(fp, MODINFOMD_ELFHDR)) == NULL)
return(EFTYPE); /* XXX actually EFUCKUP */
hdr = (Elf_Ehdr *)&(md->md_data);
/* XXX ffp_save does not appear to be used in the kernel.. */
bzero(&bootinfo_v1, sizeof(bootinfo_v1));
err = bi_load(&bootinfo_v1, &ffp_save, fp);
if (err)
return(err);
/*
* Ugly hack, similar to linux. Dump the bootinfo into a
* special page reserved in the link map.
*/
bi = (struct bootinfo *) 0x508000;
bzero(bi, sizeof(struct bootinfo));
bi_load(bi, fp);
/*
* Fill in the bootinfo for the kernel.
*/
strncpy(bootinfo_v1.booted_kernel, fp->f_name,
sizeof(bootinfo_v1.booted_kernel));
prom_getenv(PROM_E_BOOTED_OSFLAGS, bootinfo_v1.boot_flags,
sizeof(bootinfo_v1.boot_flags));
bootinfo_v1.hwrpb = (void *)HWRPB_ADDR;
bootinfo_v1.hwrpbsize = ((struct rpb *)HWRPB_ADDR)->rpb_size;
bootinfo_v1.cngetc = NULL;
bootinfo_v1.cnputc = NULL;
bootinfo_v1.cnpollc = NULL;
/*
* Region 6 is direct mapped UC and region 7 is direct mapped
* WC. The details of this is controlled by the Alt {I,D}TLB
* handlers. Here we just make sure that they have the largest
* possible page size to minimise TLB usage.
*/
ia64_set_rr(IA64_RR_BASE(6), (6 << 8) | (28 << 2));
ia64_set_rr(IA64_RR_BASE(7), (7 << 8) | (28 << 2));
printf("Entering %s at 0x%lx...\n", fp->f_name, hdr->e_entry);
exit(0);
closeall();
alpha_pal_imb();
(*(void (*)())hdr->e_entry)(ffp_save, ptbr_save,
BOOTINFO_MAGIC, &bootinfo_v1, 1, 0);
#endif
bzero(&pte, sizeof(pte));
pte.pte_p = 1;
pte.pte_ma = PTE_MA_WB;
pte.pte_a = 1;
pte.pte_d = 1;
pte.pte_pl = PTE_PL_KERN;
pte.pte_ar = PTE_AR_RWX;
pte.pte_ppn = 0;
psr = disable_ic();
__asm __volatile("mov cr.ifa=%0" :: "r"(IA64_RR_BASE(7)));
__asm __volatile("mov cr.itir=%0" :: "r"(28 << 2));
__asm __volatile("ptr.i %0,%1" :: "r"(IA64_RR_BASE(7)), "r"(28<<2));
__asm __volatile("ptr.d %0,%1" :: "r"(IA64_RR_BASE(7)), "r"(28<<2));
__asm __volatile("srlz.i;;");
__asm __volatile("itr.i itr[%0]=%1;;"
:: "r"(0), "r"(*(u_int64_t*)&pte));
__asm __volatile("itr.d dtr[%0]=%1;;"
:: "r"(0), "r"(*(u_int64_t*)&pte));
__asm __volatile("srlz.i;;");
restore_ic(psr);
bzero(&pte, sizeof(pte));
pte.pte_p = 1;
pte.pte_ma = PTE_MA_UC;
pte.pte_a = 1;
pte.pte_d = 1;
pte.pte_pl = PTE_PL_KERN;
pte.pte_ar = PTE_AR_RWX;
pte.pte_ppn = 0xffffc000000 >> 12;
psr = disable_ic();
__asm __volatile("mov cr.ifa=%0" :: "r"(IA64_PHYS_TO_RR6(0xffffc000000)));
__asm __volatile("mov cr.itir=%0" :: "r"(26 << 2));
__asm __volatile("ptr.d %0,%1" :: "r"(IA64_PHYS_TO_RR6(0xffffc000000)), "r"(26<<2));
__asm __volatile("srlz.i;;");
__asm __volatile("itr.d dtr[%0]=%1;;"
:: "r"(1), "r"(*(u_int64_t*)&pte));
__asm __volatile("srlz.i;;");
restore_ic(psr);
enter_kernel(fp->f_name, hdr->e_entry);
}