Annotation of sys/arch/sparc/stand/boot/loadfile.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: loadfile.c,v 1.5 2003/08/14 17:13:57 deraadt Exp $ */
! 2: /* $NetBSD: loadfile.c,v 1.3 1997/04/06 08:40:59 cgd Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1992, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to Berkeley by
! 9: * Ralph Campbell.
! 10: *
! 11: * Redistribution and use in source and binary forms, with or without
! 12: * modification, are permitted provided that the following conditions
! 13: * are met:
! 14: * 1. Redistributions of source code must retain the above copyright
! 15: * notice, this list of conditions and the following disclaimer.
! 16: * 2. Redistributions in binary form must reproduce the above copyright
! 17: * notice, this list of conditions and the following disclaimer in the
! 18: * documentation and/or other materials provided with the distribution.
! 19: * 3. Neither the name of the University nor the names of its contributors
! 20: * may be used to endorse or promote products derived from this software
! 21: * without specific prior written permission.
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 26: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 33: * SUCH DAMAGE.
! 34: *
! 35: * @(#)boot.c 8.1 (Berkeley) 6/10/93
! 36: */
! 37:
! 38: #define ELFSIZE 32
! 39:
! 40: #include <lib/libkern/libkern.h>
! 41: #include <lib/libsa/stand.h>
! 42: #include <sparc/stand/common/promdev.h>
! 43:
! 44: #include <sys/param.h>
! 45: #include <sys/exec.h>
! 46: #include <sys/exec_elf.h>
! 47:
! 48: #include <ddb/db_aout.h>
! 49:
! 50: #ifdef SPARC_BOOT_AOUT
! 51: static int aout_exec(int, struct exec *, vaddr_t *);
! 52: #endif
! 53: #ifdef SPARC_BOOT_ELF
! 54: static int elf_exec(int, Elf_Ehdr *, vaddr_t *);
! 55: #endif
! 56: int loadfile(int, vaddr_t *);
! 57:
! 58: vaddr_t ssym, esym;
! 59:
! 60: union {
! 61: #ifdef SPARC_BOOT_AOUT
! 62: struct exec aout;
! 63: #endif
! 64: #ifdef SPARC_BOOT_ELF
! 65: Elf_Ehdr elf;
! 66: #endif
! 67: } hdr;
! 68:
! 69: /*
! 70: * Open 'filename', read in program and return the entry point or -1 if error.
! 71: */
! 72: int
! 73: loadfile(int fd, vaddr_t *entryp)
! 74: {
! 75: struct devices *dp;
! 76: int rval;
! 77:
! 78: /* Read the exec header. */
! 79: if (read(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) {
! 80: printf("read header: %s\n", strerror(errno));
! 81: goto err;
! 82: }
! 83:
! 84: #ifdef SPARC_BOOT_ELF
! 85: if (memcmp(ELFMAG, hdr.elf.e_ident, SELFMAG) == 0) {
! 86: rval = elf_exec(fd, &hdr.elf, entryp);
! 87: } else
! 88: #endif
! 89: #ifdef SPARC_BOOT_AOUT
! 90: if (!N_BADMAG(hdr.aout)) {
! 91: rval = aout_exec(fd, &hdr.aout, entryp);
! 92: } else
! 93: #endif
! 94: {
! 95: printf("unknown executable format\n");
! 96: }
! 97:
! 98: err:
! 99: if (fd >= 0)
! 100: close(fd);
! 101: return (rval);
! 102: }
! 103:
! 104: #ifdef SPARC_BOOT_AOUT
! 105: static int
! 106: aout_exec(int fd, struct exec *aout, vaddr_t *entryp)
! 107: {
! 108: caddr_t addr = (caddr_t)LOADADDR;
! 109: int strtablen;
! 110: char *strtab;
! 111: vaddr_t entry = (vaddr_t)LOADADDR;
! 112: int i;
! 113:
! 114: printf("%d", aout->a_text);
! 115: if (N_GETMAGIC(*aout) == ZMAGIC) {
! 116: entry = (vaddr_t)(addr+sizeof(struct exec));
! 117: addr += sizeof(struct exec);
! 118: }
! 119: /* we can't lseek() here - we may be booting off tape */
! 120: bcopy((char *)aout + sizeof(struct exec), addr,
! 121: sizeof(hdr) - sizeof(struct exec));
! 122: if (read(fd, (char *)addr + sizeof(hdr) - sizeof(struct exec),
! 123: aout->a_text - (sizeof(hdr) - sizeof(struct exec))) !=
! 124: aout->a_text - (sizeof(hdr) - sizeof(struct exec)))
! 125: goto shread;
! 126: addr += aout->a_text;
! 127: if (N_GETMAGIC(*aout) == ZMAGIC || N_GETMAGIC(*aout) == NMAGIC)
! 128: while ((int)addr & __LDPGSZ)
! 129: *addr++ = 0;
! 130: printf("+%d", aout->a_data);
! 131: if (read(fd, addr, aout->a_data) != aout->a_data)
! 132: goto shread;
! 133: addr += aout->a_data;
! 134: printf("+%d", aout->a_bss);
! 135: for (i = aout->a_bss; i ; --i)
! 136: *addr++ = 0;
! 137: if (aout->a_syms != 0) {
! 138: bcopy(&aout->a_syms, addr, sizeof(aout->a_syms));
! 139: addr += sizeof(aout->a_syms);
! 140: printf("+[%d", aout->a_syms);
! 141: if (read(fd, addr, aout->a_syms) != aout->a_syms)
! 142: goto shread;
! 143: addr += aout->a_syms;
! 144:
! 145: if (read(fd, &strtablen, sizeof(int)) != sizeof(int))
! 146: goto shread;
! 147:
! 148: bcopy(&strtablen, addr, sizeof(int));
! 149: if (i = strtablen) {
! 150: i -= sizeof(int);
! 151: addr += sizeof(int);
! 152: if (read(fd, addr, i) != i)
! 153: goto shread;
! 154: addr += i;
! 155: }
! 156: printf("+%d]", i);
! 157: esym = ((u_int)aout->a_entry - (u_int)LOADADDR) +
! 158: (((int)addr + sizeof(int) - 1) & ~(sizeof(int) - 1));
! 159: }
! 160: printf("=0x%x\n", addr);
! 161: close(fd);
! 162:
! 163: *entryp = entry;
! 164: return (0);
! 165:
! 166: shread:
! 167: printf("boot: short read\n");
! 168: return (1);
! 169: }
! 170: #endif /* SPARC_BOOT_AOUT */
! 171:
! 172: #ifdef SPARC_BOOT_ELF
! 173:
! 174: /*
! 175: * If we're booting off tape, we can't seek.
! 176: * Emulate forward moves with reads, and give up on backwards moves.
! 177: * bsd.rd ought to be correctly ordered.
! 178: */
! 179: static int
! 180: elf_seek(int fd, off_t relpos)
! 181: {
! 182: #define DUMBBUFSIZE 4096
! 183: char dumbbuf[DUMBBUFSIZE];
! 184: int len;
! 185:
! 186: if (relpos < 0) {
! 187: #ifdef DEBUG
! 188: printf("elf_seek: attempting to seek backwards from %llx bytes, "
! 189: "may fail!\n", -relpos);
! 190: #endif
! 191: if (lseek(fd, relpos, SEEK_CUR) < 0)
! 192: return (-1);
! 193: return (0);
! 194: }
! 195:
! 196: while (relpos != 0) {
! 197: len = relpos > DUMBBUFSIZE ? DUMBBUFSIZE : relpos;
! 198: if (read(fd, dumbbuf, len) != len)
! 199: return (-1);
! 200: relpos -= len;
! 201: }
! 202:
! 203: return (0);
! 204: #undef DUMBBUFSIZE
! 205: }
! 206:
! 207: static int
! 208: elf_exec(int fd, Elf_Ehdr *elf, vaddr_t *entryp)
! 209: {
! 210: int i;
! 211: int first = 1, havesyms;
! 212: Elf_Shdr *shp;
! 213: Elf_Off off;
! 214: size_t sz;
! 215: vaddr_t addr = 0;
! 216: Elf_Ehdr *fake_elf;
! 217: #define NUM_HEADERS 12 /* should be more than enough */
! 218: Elf_Phdr headers[NUM_HEADERS], *phdr;
! 219: off_t pos, newpos;
! 220:
! 221: *entryp = 0;
! 222:
! 223: #define A(x) ((x) - *entryp + (vaddr_t)LOADADDR)
! 224:
! 225: pos = sizeof(hdr);
! 226:
! 227: /* load the headers */
! 228: if (elf->e_phnum > NUM_HEADERS)
! 229: elf->e_phnum = NUM_HEADERS; /* amnesia rules */
! 230: newpos = elf->e_phoff;
! 231: if (elf_seek(fd, newpos - pos))
! 232: return (1);
! 233: pos = newpos;
! 234: if (read(fd, (void *)headers, elf->e_phnum * sizeof(Elf_Phdr)) !=
! 235: elf->e_phnum * sizeof(Elf_Phdr)) {
! 236: printf("read phdr: %s\n", strerror(errno));
! 237: return (1);
! 238: }
! 239: pos += elf->e_phnum * sizeof(Elf_Phdr);
! 240:
! 241: /* loop through the pheaders and find the entry point. */
! 242: for (i = 0; i < elf->e_phnum; i++) {
! 243: phdr = &headers[i];
! 244: if (phdr->p_type != PT_LOAD ||
! 245: (phdr->p_flags & (PF_W|PF_X)) == 0 ||
! 246: (phdr->p_vaddr != elf->e_entry))
! 247: continue;
! 248:
! 249: *entryp = phdr->p_vaddr;
! 250: }
! 251:
! 252: if (*entryp == 0) {
! 253: printf("Can't find entry point.\n");
! 254: return (-1);
! 255: }
! 256:
! 257: for (i = 0; i < elf->e_phnum; i++) {
! 258: phdr = &headers[i];
! 259: if (phdr->p_type != PT_LOAD ||
! 260: (phdr->p_flags & (PF_W|PF_X)) == 0)
! 261: continue;
! 262:
! 263: /* Read in segment. */
! 264: printf("%s%lu", first ? "" : "+", phdr->p_filesz);
! 265: newpos = phdr->p_offset;
! 266: if (elf_seek(fd, newpos - pos))
! 267: return (1);
! 268: pos = newpos;
! 269:
! 270: if (read(fd, (caddr_t)A(phdr->p_vaddr), phdr->p_filesz) !=
! 271: phdr->p_filesz) {
! 272: (void)printf("read text: %s\n", strerror(errno));
! 273: return (1);
! 274: }
! 275: pos += phdr->p_filesz;
! 276:
! 277: /* keep track of highest addr we loaded. */
! 278: if (first || addr < (phdr->p_vaddr + phdr->p_memsz))
! 279: addr = (phdr->p_vaddr + phdr->p_memsz);
! 280:
! 281: /* Zero out bss. */
! 282: if (phdr->p_filesz < phdr->p_memsz) {
! 283: printf("+%lu", phdr->p_memsz - phdr->p_filesz);
! 284: bzero((caddr_t)A(phdr->p_vaddr) + phdr->p_filesz,
! 285: phdr->p_memsz - phdr->p_filesz);
! 286: }
! 287: first = 0;
! 288: }
! 289:
! 290: addr = A(addr);
! 291: addr = roundup(addr, sizeof(long));
! 292:
! 293: ssym = addr;
! 294: /*
! 295: * Retrieve symbols.
! 296: */
! 297: addr += sizeof(Elf_Ehdr);
! 298:
! 299: newpos = elf->e_shoff;
! 300: if (elf_seek(fd, newpos - pos)) {
! 301: printf("seek to section headers: %s\n", strerror(errno));
! 302: return (1);
! 303: }
! 304: pos = newpos;
! 305:
! 306: sz = elf->e_shnum * sizeof(Elf_Shdr);
! 307: shp = (Elf_Shdr *)addr;
! 308: addr += roundup(sz, sizeof(long));
! 309:
! 310: if (read(fd, shp, sz) != sz) {
! 311: printf("read section headers: %d\n", strerror(errno));
! 312: return (1);
! 313: }
! 314: pos += sz;
! 315:
! 316: /*
! 317: * Now load the symbol sections themselves. Make sure the
! 318: * sections are aligned. Don't bother with string tables if
! 319: * there are no symbol sections.
! 320: */
! 321: off = roundup((sizeof(Elf_Ehdr) + sz), sizeof(long));
! 322:
! 323: for (havesyms = i = 0; i < elf->e_shnum; i++)
! 324: if (shp[i].sh_type == SHT_SYMTAB)
! 325: havesyms = 1;
! 326:
! 327: if (!havesyms)
! 328: goto no_syms;
! 329:
! 330: for (first = 1, i = 0; i < elf->e_shnum; i++) {
! 331: if (shp[i].sh_type == SHT_SYMTAB ||
! 332: shp[i].sh_type == SHT_STRTAB) {
! 333: printf("%s%ld", first ? " [" : "+",
! 334: (u_long)shp[i].sh_size);
! 335: newpos = shp[i].sh_offset;
! 336: if (elf_seek(fd, newpos - pos)) {
! 337: printf("lseek symbols: %s\n", strerror(errno));
! 338: return (1);
! 339: }
! 340: pos = newpos;
! 341: if (read(fd, (void *)addr, shp[i].sh_size) !=
! 342: shp[i].sh_size) {
! 343: printf("read symbols: %s\n", strerror(errno));
! 344: return (1);
! 345: }
! 346: pos += shp[i].sh_size;
! 347: addr += roundup(shp[i].sh_size, sizeof(long));
! 348: shp[i].sh_offset = off;
! 349: off += roundup(shp[i].sh_size, sizeof(long));
! 350: first = 0;
! 351: }
! 352: }
! 353: if (havesyms && first == 0)
! 354: printf("]");
! 355:
! 356: elf->e_phoff = 0;
! 357: elf->e_shoff = sizeof(Elf_Ehdr);
! 358: elf->e_phentsize = 0;
! 359: elf->e_phnum = 0;
! 360: bcopy(elf, (void *)ssym, sizeof(*elf));
! 361:
! 362: no_syms:
! 363: esym = (addr - (vaddr_t)LOADADDR) + *entryp;
! 364:
! 365: *entryp = (vaddr_t)LOADADDR;
! 366:
! 367: printf("\n");
! 368: return (0);
! 369: #undef NUM_HEADERS
! 370: }
! 371: #endif /* SPARC_BOOT_ELF */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to loadfile.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc / stand / boot