![[BACK]](/icons/back.gif){kind=icon}
Return to elf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / prex-old / boot / common|
Return to elf.c CVS log | Up to [local] / prex-old / boot / common |
1.1 nbrk 1: /*-
2: * Copyright (c) 2005-2006, Kohsuke Ohtani
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. Neither the name of the author nor the names of any co-contributors
14: * may be used to endorse or promote products derived from this software
15: * without specific prior written permission.
16: *
17: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27: * SUCH DAMAGE.
28: */
29:
30: /*
31: * elf.c - ELF file format support
32: */
33:
34: #include <boot.h>
35: #include <prex/bootinfo.h>
36: #include <sys/elf.h>
37: #include <platform.h>
38:
39: extern int nr_img; /* number of images */
40:
41: #define SHF_VALID (SHF_ALLOC | SHF_EXECINSTR | SHF_ALLOC | SHF_WRITE)
42:
43: static char *sect_addr[32]; /* array of section address */
44:
45: static int
46: load_executable(char *img, struct module *m)
47: {
48: Elf32_Ehdr *ehdr;
49: Elf32_Phdr *phdr;
50: u_long phys_base;
51: int i;
52:
53: phys_base = load_base;
54: ehdr = (Elf32_Ehdr *)img;
55: phdr = (Elf32_Phdr *)((u_long)ehdr + ehdr->e_phoff);
56: m->phys = load_base;
57: phys_base = load_base;
58: elf_print("phys addr=%x\n", phys_base);
59:
60: for (i = 0; i < (int)ehdr->e_phnum; i++, phdr++) {
61: if (phdr->p_type != PT_LOAD)
62: continue;
63:
64: elf_print("p_flags=%x\n", (int)phdr->p_flags);
65: elf_print("p_align=%x\n", (int)phdr->p_align);
66: elf_print("p_paddr=%x\n", (int)phdr->p_paddr);
67:
68: if (i >= 2) {
69: elf_print("skipping extra phdr\n");
70: continue;
71: }
72: if (phdr->p_flags & PF_X) {
73: /* Text */
74: m->text = phdr->p_vaddr;
75: m->textsz = (size_t)phdr->p_memsz;
76: } else {
77: /* Data & BSS */
78: m->data = phdr->p_vaddr;
79: m->datasz = (size_t)phdr->p_filesz;
80: m->bsssz =
81: (size_t)(phdr->p_memsz - phdr->p_filesz);
82: load_base = phys_base + (m->data - m->text);
83: }
84: if (phdr->p_filesz > 0) {
85: memcpy((char *)load_base, img + phdr->p_offset,
86: (size_t)phdr->p_filesz);
87: elf_print("load: offset=%x size=%x\n",
88: load_base, (int)phdr->p_filesz);
89: }
90: if (!(phdr->p_flags & PF_X)) {
91: if (m->bsssz > 0) {
92: /* Zero fill BSS */
93: memset((char *)load_base + m->datasz,
94: 0, m->bsssz);
95: }
96: load_base += phdr->p_memsz;
97: }
98: }
99: /* workaround for data/bss size is 0 */
100: if (m->data == 0)
101: load_base = phys_base + m->textsz;
102:
103: load_base = PAGE_ALIGN(load_base);
104: m->size = (size_t)(load_base - m->phys);
105: m->entry = ehdr->e_entry;
106: elf_print("module size=%x entry=%x\n", m->size, m->entry);
107: return 0;
108: }
109:
110: static int
111: relocate_section_rela(Elf32_Sym *sym_table, Elf32_Rela *rela,
112: char *target_sect, int nr_reloc)
113: {
114: Elf32_Sym *sym;
115: Elf32_Addr sym_val;
116: int i;
117:
118: for (i = 0; i < nr_reloc; i++) {
119: sym = &sym_table[ELF32_R_SYM(rela->r_info)];
120: if (sym->st_shndx != STN_UNDEF) {
121: sym_val = (Elf32_Addr)sect_addr[sym->st_shndx]
122: + sym->st_value;
123: if (relocate_rela(rela, sym_val, target_sect) != 0)
124: return -1;
125: } else if (ELF32_ST_BIND(sym->st_info) != STB_WEAK) {
126: printk("Undefined symbol for rela[%x] sym=%x\n",
127: i, sym);
128: return -1;
129: } else {
130: elf_print("Undefined weak symbol for rela[%x]\n", i);
131: }
132: rela++;
133: }
134: return 0;
135: }
136:
137: static int
138: relocate_section_rel(Elf32_Sym *sym_table, Elf32_Rel *rel,
139: char *target_sect, int nr_reloc)
140: {
141: Elf32_Sym *sym;
142: Elf32_Addr sym_val;
143: int i;
144:
145: for (i = 0; i < nr_reloc; i++) {
146: sym = &sym_table[ELF32_R_SYM(rel->r_info)];
147: if (sym->st_shndx != STN_UNDEF) {
148: sym_val = (Elf32_Addr)sect_addr[sym->st_shndx]
149: + sym->st_value;
150: if (relocate_rel(rel, sym_val, target_sect) != 0)
151: return -1;
152: } else if (ELF32_ST_BIND(sym->st_info) != STB_WEAK) {
153: printk("Undefined symbol for rel[%x] sym=%x\n",
154: i, sym);
155: return -1;
156: } else {
157: elf_print("Undefined weak symbol for rel[%x]\n", i);
158: }
159: rel++;
160: }
161: return 0;
162: }
163:
164: static int
165: relocate_section(char *img, Elf32_Shdr *shdr)
166: {
167: Elf32_Sym *sym_table;
168: char *target_sect;
169: int nr_reloc, err;
170:
171: if (shdr->sh_entsize == 0)
172: return 0;
173: if ((target_sect = sect_addr[shdr->sh_info]) == 0)
174: return -1;
175: if ((sym_table = (Elf32_Sym *)sect_addr[shdr->sh_link]) == 0)
176: return -1;
177:
178: nr_reloc = (int)(shdr->sh_size / shdr->sh_entsize);
179: switch (shdr->sh_type) {
180: case SHT_REL:
181: err = relocate_section_rel(sym_table,
182: (Elf32_Rel *)(img + shdr->sh_offset),
183: target_sect, nr_reloc);
184: break;
185:
186: case SHT_RELA:
187: err = relocate_section_rela(sym_table,
188: (Elf32_Rela *)(img + shdr->sh_offset),
189: target_sect, nr_reloc);
190: break;
191:
192: default:
193: err = -1;
194: break;
195: }
196: return err;
197: }
198:
199: static int
200: load_relocatable(char *img, struct module *m)
201: {
202: Elf32_Ehdr *ehdr;
203: Elf32_Shdr *shdr;
204: u_long sect_base, bss_base;
205: int i;
206:
207: ehdr = (Elf32_Ehdr *)img;
208: shdr = (Elf32_Shdr *)((u_long)ehdr + ehdr->e_shoff);
209: bss_base = 0;
210: m->phys = load_base;
211: elf_print("phys addr=%x\n", load_base);
212:
213: /* Copy sections */
214: for (i = 0; i < (int)ehdr->e_shnum; i++, shdr++) {
215: sect_addr[i] = 0;
216: if (shdr->sh_type == SHT_PROGBITS) {
217:
218: elf_print("sh_addr=%x\n", shdr->sh_addr);
219: elf_print("sh_size=%x\n", shdr->sh_size);
220: elf_print("sh_offset=%x\n", shdr->sh_offset);
221: elf_print("sh_flags=%x\n", shdr->sh_flags);
222:
223: switch (shdr->sh_flags & SHF_VALID) {
224: case (SHF_ALLOC | SHF_EXECINSTR):
225: /* Text */
226: m->text = (u_long)phys_to_virt(load_base);
227: break;
228: case (SHF_ALLOC | SHF_WRITE):
229: /* Data */
230: if (m->data == 0)
231: m->data =
232: (u_long)phys_to_virt(load_base + shdr->sh_addr);
233: break;
234: case SHF_ALLOC:
235: /* rodata */
236: /* Note: rodata is treated as text. */
237: break;
238: default:
239: continue;
240: }
241: sect_base = load_base + shdr->sh_addr;
242: memcpy((char *)sect_base, img + shdr->sh_offset,
243: (size_t)shdr->sh_size);
244: elf_print("load: offset=%x size=%x\n",
245: sect_base, (int)shdr->sh_size);
246:
247: sect_addr[i] = (char *)sect_base;
248: } else if (shdr->sh_type == SHT_NOBITS) {
249: /* BSS */
250: m->bsssz = (size_t)shdr->sh_size;
251: sect_base = load_base + shdr->sh_addr;
252: bss_base = sect_base;
253:
254: /* Zero fill BSS */
255: memset((char *)sect_base, 0, (size_t)shdr->sh_size);
256:
257: sect_addr[i] = (char *)sect_base;
258: } else if (shdr->sh_type == SHT_SYMTAB) {
259: /* Symbol table */
260: sect_addr[i] = img + shdr->sh_offset;
261: }
262: }
263: m->textsz = (size_t)(m->data - m->text);
264: m->datasz = (size_t)(bss_base - m->data);
265:
266: load_base = bss_base + m->bsssz;
267: load_base = PAGE_ALIGN(load_base);
268:
269: elf_print("module load_base=%x text=%x\n", load_base, m->text);
270: m->size = (size_t)(load_base - (u_long)virt_to_phys(m->text));
271: m->entry = (u_long)phys_to_virt(ehdr->e_entry + m->phys);
272: elf_print("module size=%x entry=%x\n", m->size, m->entry);
273:
274: /* Process relocation */
275: shdr = (Elf32_Shdr *)((u_long)ehdr + ehdr->e_shoff);
276: for (i = 0; i < (int)ehdr->e_shnum; i++, shdr++) {
277: if (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA) {
278: if (relocate_section(img, shdr) != 0)
279: return -1;
280: }
281: }
282: return 0;
283: }
284:
285: /*
286: * Load the program from specified ELF image data stored in memory.
287: * The boot information is filled after loading the program.
288: */
289: int
290: elf_load(char *img, struct module *m)
291: {
292: Elf32_Ehdr *ehdr;
293: Elf32_Phdr *phdr;
294:
295: elf_print("\nelf_load\n");
296:
297: ehdr = (Elf32_Ehdr *)img;
298:
299: /* Check ELF header */
300: if ((ehdr->e_ident[EI_MAG0] != ELFMAG0) ||
301: (ehdr->e_ident[EI_MAG1] != ELFMAG1) ||
302: (ehdr->e_ident[EI_MAG2] != ELFMAG2) ||
303: (ehdr->e_ident[EI_MAG3] != ELFMAG3))
304: return -1;
305:
306: phdr = (Elf32_Phdr *)((u_long)ehdr + ehdr->e_ehsize);
307:
308: if (nr_img == 0) {
309: /* Initialize the load address */
310: load_base = (u_long)phys_to_virt(phdr->p_paddr);
311: if (load_base == 0)
312: return -1;
313: elf_print("kernel base=%x\n", load_base);
314: load_start = load_base;
315: }
316: else if (nr_img == 1) {
317: /* Second image => Driver */
318: elf_print("driver base=%x\n", load_base);
319: }
320: else {
321: /* Other images => Boot tasks */
322: elf_print("task base=%x\n", load_base);
323: }
324:
325: switch (ehdr->e_type) {
326: case ET_EXEC:
327: if (load_executable(img, m) != 0)
328: return -1;
329: break;
330: case ET_REL:
331: if (load_relocatable(img, m) != 0)
332: return -1;
333: break;
334: default:
335: elf_print("Unsupported file type\n");
336: return -1;
337: }
338: nr_img++;
339: return 0;
340: }