AcessKernel - cleaning up debug messages
[tpg/acess2.git] / AcessNative / ld-acess_src / elf_load.c
1 /*\r
2  * Acess2 - AcessNative\r
3  *\r
4  * ELF Executable Loader Code\r
5  */\r
6 #define DEBUG   0\r
7 #include <stdlib.h>\r
8 #include <stdio.h>\r
9 #include <string.h>\r
10 #include <unistd.h>\r
11 #include <inttypes.h>   // PRIx64\r
12 #include "common.h"\r
13 #include "elf32.h"\r
14 #include "elf64.h"\r
15 \r
16 #define DEBUG_WARN      1\r
17 \r
18 #define MKPTR(_type,_val)       ((_type*)(uintptr_t)(_val))\r
19 #define PTRMK(_type,_val)       MKPTR(_type,_val)\r
20 #define PTR(_val)       ((void*)(uintptr_t)(_val))\r
21 \r
22 #if DEBUG\r
23 # define ENTER(...)     printf("%s: ---- ENTER ----\n", __func__);\r
24 # define LOG(s, ...)    printf("%s: " s, __func__, __VA_ARGS__)\r
25 # define LOGS(s)        printf("%s: " s, __func__)\r
26 # define LEAVE(...)     printf("%s: ---- LEAVE ----\n", __func__);\r
27 #else\r
28 # define ENTER(...)\r
29 # define LOG(...)\r
30 # define LOGS(...)\r
31 # define LEAVE(...)\r
32 #endif\r
33 \r
34 // === PROTOTYPES ===\r
35 void    *Elf_Load(int FD);\r
36 void    *Elf32Load(int FD, Elf32_Ehdr *hdr);\r
37 void    *Elf64Load(int FD, Elf64_Ehdr *hdr);\r
38 \r
39 // === CODE ===\r
40 void *Elf_Load(int FD)\r
41 {\r
42         Elf64_Ehdr      hdr;\r
43         \r
44         // Read ELF Header\r
45         acess_read(FD, &hdr, sizeof(hdr));\r
46         \r
47         // Check the file type\r
48         if(hdr.e_ident[0] != 0x7F || hdr.e_ident[1] != 'E' || hdr.e_ident[2] != 'L' || hdr.e_ident[3] != 'F') {\r
49                 Warning("Non-ELF File was passed to the ELF loader\n");\r
50                 return NULL;\r
51         }\r
52 \r
53         switch(hdr.e_ident[4])\r
54         {\r
55         case ELFCLASS32:\r
56                 return Elf32Load(FD, (void*)&hdr);\r
57         case ELFCLASS64:\r
58                 return Elf64Load(FD, &hdr);\r
59         default:\r
60                 Warning("Unknown ELF class (%i)", hdr.e_ident[4]);\r
61                 return NULL;\r
62         }\r
63 }\r
64 \r
65 void *Elf32Load(int FD, Elf32_Ehdr *hdr)\r
66 {\r
67         Elf32_Phdr      *phtab;\r
68          int    i;\r
69          int    iPageCount;\r
70         uint32_t        max, base;\r
71         uint32_t        addr;\r
72         uint32_t        baseDiff = 0;\r
73         \r
74         ENTER("iFD", FD);\r
75         \r
76         // Check for a program header\r
77         if(hdr->phoff == 0) {\r
78                 #if DEBUG_WARN\r
79                 Warning("ELF File does not contain a program header\n");\r
80                 #endif\r
81                 LEAVE('n');\r
82                 return NULL;\r
83         }\r
84         \r
85         // Read Program Header Table\r
86         phtab = malloc( sizeof(Elf32_Phdr) * hdr->phentcount );\r
87         if( !phtab ) {\r
88                 LEAVE('n');\r
89                 return NULL;\r
90         }\r
91         LOG("hdr.phoff = 0x%08x\n", hdr->phoff);\r
92         acess_seek(FD, hdr->phoff, ACESS_SEEK_SET);\r
93         acess_read(FD, phtab, sizeof(Elf32_Phdr) * hdr->phentcount);\r
94         \r
95         // Count Pages\r
96         iPageCount = 0;\r
97         LOG("hdr.phentcount = %i\n", hdr->phentcount);\r
98         for( i = 0; i < hdr->phentcount; i++ )\r
99         {\r
100                 // Ignore Non-LOAD types\r
101                 if(phtab[i].Type != PT_LOAD)\r
102                         continue;\r
103                 iPageCount += ((phtab[i].VAddr&0xFFF) + phtab[i].MemSize + 0xFFF) >> 12;\r
104                 LOG("phtab[%i] = {VAddr:0x%x, MemSize:0x%x}\n", i, phtab[i].VAddr, phtab[i].MemSize);\r
105         }\r
106         \r
107         LOG("iPageCount = %i\n", iPageCount);\r
108         \r
109         // Allocate Information Structure\r
110         //ret = malloc( sizeof(tBinary) + sizeof(tBinaryPage)*iPageCount );\r
111         // Fill Info Struct\r
112         //ret->Entry = hdr.entrypoint;\r
113         //ret->Base = -1;               // Set Base to maximum value\r
114         //ret->NumPages = iPageCount;\r
115         //ret->Interpreter = NULL;\r
116 \r
117         // Prescan for base and size\r
118         max = 0;\r
119         base = 0xFFFFFFFF;\r
120         for( i = 0; i < hdr->phentcount; i ++)\r
121         {\r
122                 if( phtab[i].Type != PT_LOAD )\r
123                         continue;\r
124                 if( phtab[i].VAddr < base )\r
125                         base = phtab[i].VAddr;\r
126                 if( phtab[i].VAddr + phtab[i].MemSize > max )\r
127                         max = phtab[i].VAddr + phtab[i].MemSize;\r
128         }\r
129 \r
130         LOG("base = %08x, max = %08x\n", base, max);\r
131 \r
132         if( base == 0 ) {\r
133                 // Find a nice space (47 address bits allowed)\r
134                 base = FindFreeRange( max, 47 );\r
135                 LOG("new base = %08x\n", base);\r
136                 if( base == 0 ) return NULL;\r
137                 baseDiff = base;\r
138         }\r
139         \r
140         // Load Pages\r
141         for( i = 0; i < hdr->phentcount; i++ )\r
142         {\r
143                 // Get Interpreter Name\r
144                 if( phtab[i].Type == PT_INTERP )\r
145                 {\r
146                         char *tmp;\r
147                         //if(ret->Interpreter)  continue;\r
148                         tmp = malloc(phtab[i].FileSize);\r
149                         acess_seek(FD, phtab[i].Offset, ACESS_SEEK_SET);\r
150                         acess_read(FD, tmp, phtab[i].FileSize);\r
151                         //ret->Interpreter = Binary_RegInterp(tmp);\r
152                         LOG("Interpreter '%s'\n", tmp);\r
153                         free(tmp);\r
154                         continue;\r
155                 }\r
156                 // Ignore non-LOAD types\r
157                 if(phtab[i].Type != PT_LOAD)    continue;\r
158                 \r
159                 LOG("phtab[%i] = PT_LOAD {Adj VAddr:0x%x, Offset:0x%x, FileSize:0x%x, MemSize:0x%x}\n",\r
160                         i, phtab[i].VAddr+baseDiff, phtab[i].Offset, phtab[i].FileSize, phtab[i].MemSize);\r
161                 \r
162                 addr = phtab[i].VAddr + baseDiff;\r
163 \r
164                 if( AllocateMemory( addr, phtab[i].MemSize ) ) {\r
165                         fprintf(stderr, "Elf_Load: Unable to map memory at %x (0x%x bytes)\n",\r
166                                 addr, phtab[i].MemSize);\r
167                         free( phtab );\r
168                         return NULL;\r
169                 }\r
170                 \r
171                 acess_seek(FD, phtab[i].Offset, ACESS_SEEK_SET);\r
172                 acess_read(FD, PTRMK(void, addr), phtab[i].FileSize);\r
173                 memset( PTRMK(char, addr) + phtab[i].FileSize, 0, phtab[i].MemSize - phtab[i].FileSize );\r
174         }\r
175         \r
176         // Clean Up\r
177         free(phtab);\r
178         // Return\r
179         LEAVE('p', base);\r
180         return PTRMK(void, base);\r
181 }\r
182 \r
183 void *Elf64Load(int FD, Elf64_Ehdr *hdr)\r
184 {\r
185         Elf64_Phdr      *phtab;\r
186          int    i;\r
187          int    iPageCount;\r
188         uint64_t        max, base;\r
189         uint64_t        addr;\r
190         uint64_t        baseDiff = 0;\r
191         \r
192         ENTER("iFD", FD);\r
193         \r
194         if( sizeof(void*) == 4) {\r
195                 Warning("ELF64 being loaded in 32-bit env, this may not work");\r
196         }\r
197 \r
198         // Check for a program header\r
199         if(hdr->e_phoff == 0) {\r
200                 #if DEBUG_WARN\r
201                 Warning("ELF File does not contain a program header\n");\r
202                 #endif\r
203                 LEAVE('n');\r
204                 return NULL;\r
205         }\r
206         \r
207         // Read Program Header Table\r
208         phtab = malloc( sizeof(Elf64_Phdr) * hdr->e_phnum );\r
209         if( !phtab ) {\r
210                 LEAVE('n');\r
211                 return NULL;\r
212         }\r
213         LOG("hdr.phoff = 0x%08llx\n", (long long)hdr->e_phoff);\r
214         acess_seek(FD, hdr->e_phoff, ACESS_SEEK_SET);\r
215         acess_read(FD, phtab, sizeof(Elf64_Phdr) * hdr->e_phnum);\r
216         \r
217         // Count Pages\r
218         iPageCount = 0;\r
219         LOG("hdr.phentcount = %i\n", hdr->e_phnum);\r
220         for( i = 0; i < hdr->e_phnum; i++ )\r
221         {\r
222                 // Ignore Non-LOAD types\r
223                 if(phtab[i].p_type != PT_LOAD)\r
224                         continue;\r
225                 iPageCount += ((phtab[i].p_vaddr&0xFFF) + phtab[i].p_memsz + 0xFFF) >> 12;\r
226                 LOG("phtab[%i] = {VAddr:0x%llx, MemSize:0x%llx}\n",\r
227                         i, (long long)phtab[i].p_vaddr, (long long)phtab[i].p_memsz);\r
228         }\r
229         \r
230         LOG("iPageCount = %i\n", iPageCount);\r
231         \r
232         // Allocate Information Structure\r
233         //ret = malloc( sizeof(tBinary) + sizeof(tBinaryPage)*iPageCount );\r
234         // Fill Info Struct\r
235         //ret->Entry = hdr.entrypoint;\r
236         //ret->Base = -1;               // Set Base to maximum value\r
237         //ret->NumPages = iPageCount;\r
238         //ret->Interpreter = NULL;\r
239 \r
240         // Prescan for base and size\r
241         max = 0;\r
242         base = 0xFFFFFFFF;\r
243         for( i = 0; i < hdr->e_phnum; i ++)\r
244         {\r
245                 if( phtab[i].p_type != PT_LOAD )\r
246                         continue;\r
247                 if( phtab[i].p_vaddr < base )\r
248                         base = phtab[i].p_vaddr;\r
249                 if( phtab[i].p_vaddr + phtab[i].p_memsz > max )\r
250                         max = phtab[i].p_vaddr + phtab[i].p_memsz;\r
251         }\r
252 \r
253         LOG("base = %08lx, max = %08lx\n", base, max);\r
254 \r
255         if( base == 0 ) {\r
256                 // Find a nice space (31 address bits allowed)\r
257                 base = FindFreeRange( max, 31 );\r
258                 LOG("new base = %08lx\n", base);\r
259                 if( base == 0 ) return NULL;\r
260                 baseDiff = base;\r
261         }\r
262         \r
263         // Load Pages\r
264         for( i = 0; i < hdr->e_phnum; i++ )\r
265         {\r
266                 // Get Interpreter Name\r
267                 if( phtab[i].p_type == PT_INTERP )\r
268                 {\r
269                         char *tmp;\r
270                         //if(ret->Interpreter)  continue;\r
271                         tmp = malloc(phtab[i].p_filesz+1);\r
272                         tmp[ phtab[i].p_filesz ] = 0;\r
273                         acess_seek(FD, phtab[i].p_offset, ACESS_SEEK_SET);\r
274                         acess_read(FD, tmp, phtab[i].p_filesz);\r
275                         //ret->Interpreter = Binary_RegInterp(tmp);\r
276                         LOG("Interpreter '%s'\n", tmp);\r
277                         free(tmp);\r
278                         continue;\r
279                 }\r
280                 // Ignore non-LOAD types\r
281                 if(phtab[i].p_type != PT_LOAD)  continue;\r
282                 \r
283                 LOG("phtab[%i] = PT_LOAD {Adj VAddr:0x%llx, Offset:0x%llx, FileSize:0x%llx, MemSize:0x%llx}\n",\r
284                         i,\r
285                         (long long)phtab[i].p_vaddr+baseDiff, (long long)phtab[i].p_offset,\r
286                         (long long)phtab[i].p_filesz, (long long)phtab[i].p_memsz\r
287                         );\r
288                 \r
289                 addr = phtab[i].p_vaddr + baseDiff;\r
290 \r
291                 if( AllocateMemory( addr, phtab[i].p_memsz ) ) {\r
292                         fprintf(stderr, "Elf_Load: Unable to map memory at %"PRIx64" (0x%"PRIx64" bytes)\n",\r
293                                 (uint64_t)addr, (uint64_t)phtab[i].p_memsz);\r
294                         free( phtab );\r
295                         return NULL;\r
296                 }\r
297                 \r
298                 acess_seek(FD, phtab[i].p_offset, ACESS_SEEK_SET);\r
299                 acess_read(FD, PTRMK(void, addr), phtab[i].p_filesz);\r
300                 memset( PTRMK(char, addr) + phtab[i].p_filesz, 0, phtab[i].p_memsz - phtab[i].p_filesz );\r
301         }\r
302         \r
303         // Clean Up\r
304         free(phtab);\r
305         // Return\r
306         LEAVE('p', base);\r
307         return PTRMK(void, base);\r
308 }\r
309 \r

UCC git Repository :: git.ucc.asn.au