static int
commonllp64(int, Fhdr *fp, ExecHdr *hp)
{
long pgsize;
uvlong entry;
hswal(&hp->e, sizeof(Exec)/sizeof(long), beswal);
if(!(hp->e.magic & HDR_MAGIC))
return 0;
/*
* There can be more magic here if the
* header ever needs more expansion.
* For now just catch use of any of the
* unused bits.
*/
if((hp->e.magic & ~DYN_MAGIC)>>16)
return 0;
entry = beswav(hp->e.hdr[0]);
pgsize = mach->pgsize;
settext(fp, entry, pgsize+fp->hdrsz, hp->e.text, fp->hdrsz);
setdata(fp, _round(pgsize+fp->txtsz+fp->hdrsz, pgsize),
hp->e.data, fp->txtsz+fp->hdrsz, hp->e.bss);
setsym(fp, hp->e.syms, hp->e.spsz, hp->e.pcsz, fp->datoff+fp->datsz);
if(hp->e.magic & DYN_MAGIC) {
fp->txtaddr = 0;
fp->dataddr = fp->txtsz;
return 1;
}
commonboot(fp);
return 1;
}
static int
commonllp64(int unused, Fhdr *fp, ExecHdr *hp)
{
int32 pgsize;
uvlong entry;
USED(unused);
hswal(&hp->e, sizeof(Exec)/sizeof(int32), beswal);
if(!(hp->e.exechdr.magic & HDR_MAGIC))
return 0;
/*
* There can be more magic here if the
* header ever needs more expansion.
* For now just catch use of any of the
* unused bits.
*/
if((hp->e.exechdr.magic & ~DYN_MAGIC)>>16)
return 0;
union {
char *p;
uvlong *v;
} u;
u.p = (char*)&hp->e.exechdr;
entry = beswav(*u.v);
pgsize = mach->pgsize;
settext(fp, entry, pgsize+fp->hdrsz, hp->e.exechdr.text, fp->hdrsz);
setdata(fp, _round(pgsize+fp->txtsz+fp->hdrsz, pgsize),
hp->e.exechdr.data, fp->txtsz+fp->hdrsz, hp->e.exechdr.bss);
setsym(fp, fp->datoff+fp->datsz, hp->e.exechdr.syms, 0, hp->e.exechdr.spsz, 0, hp->e.exechdr.pcsz);
if(hp->e.exechdr.magic & DYN_MAGIC) {
fp->txtaddr = 0;
fp->dataddr = fp->txtsz;
return 1;
}
commonboot(fp);
return 1;
}
int
bootpass(Boot *b, void *vbuf, int nbuf)
{
char *buf, *ebuf;
Hdr *hdr;
ulong magic, entry, data, text, bss;
uvlong entry64;
if(b->state == FAILED)
return FAIL;
if(nbuf == 0)
goto Endofinput;
buf = vbuf;
ebuf = buf+nbuf;
while(addbytes(&b->wp, b->ep, &buf, ebuf) == 0) {
switch(b->state) {
case INITKERNEL:
b->state = READEXEC;
b->bp = (char*)&b->hdr;
b->wp = b->bp;
b->ep = b->bp+sizeof(Hdr);
break;
case READEXEC:
hdr = &b->hdr;
magic = GLLONG(hdr->magic);
if(magic == I_MAGIC || magic == S_MAGIC) {
b->state = READ9TEXT;
b->bp = (char*)PADDR(GLLONG(hdr->entry));
b->wp = b->bp;
b->ep = b->wp+GLLONG(hdr->text);
if(magic == I_MAGIC){
memmove(b->bp, b->hdr.uvl, sizeof(b->hdr.uvl));
b->wp += sizeof(b->hdr.uvl);
}
print("%lud", GLLONG(hdr->text));
break;
}
/* check for gzipped kernel */
if(b->bp[0] == 0x1F && (uchar)b->bp[1] == 0x8B && b->bp[2] == 0x08) {
b->state = READGZIP;
b->bp = (char*)malloc(1440*1024);
b->wp = b->bp;
b->ep = b->wp + 1440*1024;
memmove(b->bp, &b->hdr, sizeof(Hdr));
b->wp += sizeof(Hdr);
print("gz...");
break;
}
/*
* Check for ELF.
*/
if(memcmp(b->bp, elfident, 4) == 0){
b->state = READEHDR;
b->bp = (char*)&ehdr;
b->wp = b->bp;
b->ep = b->wp + sizeof(Ehdr);
memmove(b->bp, &b->hdr, sizeof(Hdr));
b->wp += sizeof(Hdr);
print("elf...");
break;
}
print("bad kernel format (magic == %#lux)\n", magic);
b->state = FAILED;
return FAIL;
case READ9TEXT:
hdr = &b->hdr;
b->state = READ9DATA;
b->bp = (char*)PGROUND(PADDR(GLLONG(hdr->entry))+GLLONG(hdr->text));
b->wp = b->bp;
b->ep = b->wp + GLLONG(hdr->data);
print("+%ld", GLLONG(hdr->data));
break;
case READ9DATA:
hdr = &b->hdr;
bss = GLLONG(hdr->bss);
memset(b->ep, 0, bss);
print("+%ld=%ld\n",
bss, GLLONG(hdr->text)+GLLONG(hdr->data)+bss);
b->state = TRYBOOT;
return ENOUGH;
case READEHDR:
if(!readehdr(b)){
print("readehdr failed\n");
b->state = FAILED;
return FAIL;
}
break;
case READPHDR:
if(!readphdr(b)){
b->state = FAILED;
return FAIL;
}
break;
case READEPAD:
if(!readepad(b)){
b->state = FAILED;
return FAIL;
}
break;
case READEDATA:
if(!readedata(b)){
b->state = FAILED;
return FAIL;
}
if(b->state == TRYBOOT)
return ENOUGH;
break;
case TRYBOOT:
case TRYEBOOT:
case READGZIP:
return ENOUGH;
case READ9LOAD:
case INIT9LOAD:
panic("9load");
default:
panic("bootstate");
}
}
return MORE;
Endofinput:
/* end of input */
switch(b->state) {
case INITKERNEL:
case READEXEC:
case READ9TEXT:
case READ9DATA:
case READEHDR:
case READPHDR:
case READEPAD:
case READEDATA:
print("premature EOF\n");
b->state = FAILED;
return FAIL;
case TRYBOOT:
entry = GLLONG(b->hdr.entry);
magic = GLLONG(b->hdr.magic);
if(magic == I_MAGIC){
print("entry: 0x%lux\n", entry);
warp9(PADDR(entry));
}
else if(magic == S_MAGIC){
entry64 = beswav(b->hdr.uvl[0]);
warp64(entry64);
}
b->state = FAILED;
return FAIL;
case TRYEBOOT:
entry = GLLONG(b->hdr.entry);
if(ehdr.machine == I386){
print("entry: 0x%lux\n", entry);
warp9(PADDR(entry));
}
else if(ehdr.machine == AMD64){
print("entry: 0x%lux\n", entry);
warp64(entry);
}
b->state = FAILED;
return FAIL;
case READGZIP:
hdr = &b->hdr;
if(b->bp[0] != 0x1F || (uchar)b->bp[1] != 0x8B || b->bp[2] != 0x08)
print("lost magic\n");
print("%ld => ", b->wp - b->bp);
if(gunzip((uchar*)hdr, sizeof(*hdr), (uchar*)b->bp, b->wp - b->bp) < sizeof(*hdr)) {
print("badly compressed kernel\n");
return FAIL;
}
entry = GLLONG(hdr->entry);
text = GLLONG(hdr->text);
data = GLLONG(hdr->data);
bss = GLLONG(hdr->bss);
print("%lud+%lud+%lud=%lud\n", text, data, bss, text+data+bss);
if(gunzip((uchar*)PADDR(entry)-sizeof(Exec), sizeof(Exec)+text+data,
(uchar*)b->bp, b->wp-b->bp) < sizeof(Exec)+text+data) {
print("error uncompressing kernel\n");
return FAIL;
}
/* relocate data to start at page boundary */
memmove((void*)PGROUND(PADDR(entry+text)), (void*)(PADDR(entry+text)), data);
entry = GLLONG(b->hdr.entry);
magic = GLLONG(b->hdr.magic);
if(magic == I_MAGIC){
print("entry: 0x%lux\n", entry);
warp9(PADDR(entry));
}
else if(magic == S_MAGIC){
entry64 = beswav(b->hdr.uvl[0]);
warp64(entry64);
}
b->state = FAILED;
return FAIL;
case INIT9LOAD:
case READ9LOAD:
panic("end 9load");
default:
panic("bootdone");
}
b->state = FAILED;
return FAIL;
}
