| blob | 346ca88ce07a066d61e76a3b48f4faa721c9e87a |
1 [PATCH] mkelfImage: Take elf64 vmlinux and produce elf32
3 change to use e_entry instead of hardcode for vmlinux
4 if e_entry is not equal to paddr of fist phdr, will use paddr instead, and not switch to 64bit in convert
5 otherwise will use e_entry and switch to 64bit in convert
7 also fix the bss_size calculation.
9 Signed-off-By: Yinghai Lu <yinghai.lu@amd.com>
11 diff -uNr mkelfImage-2.7/linux-i386/convert.h mkelfImage-2.7.new/linux-i386/convert.h
12 --- mkelfImage-2.7/linux-i386/convert.h 2006-03-17 06:08:21.000000000 -0800
13 +++ mkelfImage-2.7.new/linux-i386/convert.h 2006-11-08 12:32:15.000000000 -0800
14 @@ -3,6 +3,8 @@
15 #define CONVERTLOC 0x10000
16 #define REAL_MODE_DATA_LOC 0x20000
17 #define GDTLOC 0x21000
18 +#define GDT64LOC 0x22000
19 +#define PGTLOC 0x23000
21 #define DEFAULT_ROOT_DEV ((0x3<<8)| 0)
23 @@ -18,10 +20,13 @@
24 struct image_parameters {
25 uint32_t convert_magic; /* a signature to verify mkelfImage was built properly */
26 uint32_t gdt_size;
27 + uint32_t gdt64_size;
28 + uint32_t pgt_size;
29 uint32_t bss_size;
30 uint16_t ramdisk_flags;
31 uint16_t root_dev;
32 uint32_t entry;
33 + uint32_t switch_64;
34 uint32_t initrd_start;
35 uint32_t initrd_size;
36 uint8_t cmdline[CMDLINE_MAX];
37 diff -uNr mkelfImage-2.7/linux-i386/convert.lds mkelfImage-2.7.new/linux-i386/convert.lds
38 --- mkelfImage-2.7/linux-i386/convert.lds 2003-01-16 13:41:14.000000000 -0800
39 +++ mkelfImage-2.7.new/linux-i386/convert.lds 2006-11-08 12:19:12.000000000 -0800
40 @@ -27,7 +27,7 @@
41 *(.bss)
42 }
43 _end = . ;
44 - bss_size = _end - _bss;
45 + bss_sizex = _end - _bss;
47 /DISCARD/ : {
48 *(.comment)
49 diff -uNr mkelfImage-2.7/linux-i386/head.S mkelfImage-2.7.new/linux-i386/head.S
50 --- mkelfImage-2.7/linux-i386/head.S 2003-01-24 14:48:03.000000000 -0800
51 +++ mkelfImage-2.7.new/linux-i386/head.S 2006-11-08 12:19:32.000000000 -0800
52 @@ -59,7 +59,7 @@
53 movl $GDTLOC, %edi
54 movl $(gdt_end - gdt), %ecx
55 rep movsb
56 -
57 +
58 # Linux makes stupid assumptions about the segments
59 # that are already setup, so setup a new gdt & ldt
60 # and then reload the segment registers.
61 @@ -95,22 +95,113 @@
62 # Flag to indicate we are the bootstrap processor
63 xorl %ebx, %ebx
65 + movl switch_64, %eax
66 + cmp $1, %eax
67 + jz switch_to_64
68 +
69 # Clear the unspecified registers for good measure
70 xorl %eax, %eax
71 xorl %ecx, %ecx
72 xorl %edx, %edx
73 xorl %edi, %edi
74 - xorl %esp, %esp
75 xorl %ebp, %ebp
76 +
77 + # do not clear esp, we still need to use lret later
78 +
79 + pushl $PROT_CODE_SEG
80 + movl entry, %eax
81 + pushl %eax
82 +
83 + lret
84 +
85 +switch_to_64:
86 +
87 + /* We need to switch to 64bit before use startup_64 entry go to kernel */
88 + /*
89 + * Prepare for entering 64 bit mode
90 + */
91 + # Move the gdt64 where Linux will not smash it during decompression
92 + movl %esi, %eax # save the real mode pointer
93 + movl $gdt64, %esi
94 + movl $GDT64LOC, %edi
95 + movl $(gdt64_end - gdt64), %ecx
96 + rep movsb
97 + movl %eax, %esi
98 +
99 + /* Load new GDT with the 64bit segments using 32bit descriptor */
100 + lgdt gdt64
101 +
102 + /* Enable PAE mode */
103 + xorl %eax, %eax
104 + btsl $5, %eax
105 + movl %eax, %cr4
106 +
107 + /*
108 + * Build early 4G boot pagetable
109 + */
110 + /* Initialize Page tables to 0*/
111 + movl $PGTLOC, %edi
112 + xorl %eax, %eax
113 + movl $((4096*6)/4), %ecx
114 + rep stosl
115 +
116 + /* Build Level 4 */
117 + movl $(PGTLOC + 0), %edi
118 + leal 0x1007 (%edi), %eax
119 + movl %eax, 0(%edi)
120 +
121 + /* Build Level 3 */
122 + movl $(PGTLOC + 0x1000), %edi
123 + leal 0x1007(%edi), %eax
124 + movl $4, %ecx
125 +1: movl %eax, 0x00(%edi)
126 + addl $0x00001000, %eax
127 + addl $8, %edi
128 + decl %ecx
129 + jnz 1b
130 +
131 + /* Build Level 2 */
132 + movl $(PGTLOC + 0x2000), %edi
133 + movl $0x00000183, %eax
134 + movl $2048, %ecx
135 +1: movl %eax, 0(%edi)
136 + addl $0x00200000, %eax
137 + addl $8, %edi
138 + decl %ecx
139 + jnz 1b
140 +
141 + /* Enable the boot page tables */
142 + movl $PGTLOC, %eax
143 + movl %eax, %cr3
144 +
145 + /* Enable Long mode in EFER (Extended Feature Enable Register) */
146 + movl $0xc0000080, %ecx
147 + rdmsr
148 + btsl $8, %eax
149 + wrmsr
150 +
151 + /* Preparing for 64bit jmp */
152 + pushl $PROT_CODE_SEG
153 + movl entry, %eax
154 + pushl %eax
155 +
156 + /* Enter paged protected Mode, activating Long Mode */
157 + xorl %eax, %eax
158 + btsl $31, %eax
159 + btsl $0, %eax
160 + movl %eax, %cr0
161 +
162 + /*
163 + * At this point we're in long mode but in 32bit compatibility mode
164 + * with EFER.LME = 1, CS.L = 0, CS.D = 1 (and in turn
165 + * EFER.LMA = 1). Now we want to jump in 64bit mode, to do that we use
166 + * the new gdt/idt that has __KERNEL_CS with CS.L = 1.
167 + */
169 -
170 - # Jump to the linux kernel
171 - ljmp $ PROT_CODE_SEG , $ 0x100000
172 + lret
175 /* Routines to query the BIOS... */
176 -
177 -
178 /**************************************************************************
179 E820_MEMSIZE - Get a listing of memory regions
180 **************************************************************************/
181 @@ -409,6 +500,7 @@
182 .word 0x9200 # data read/write
183 .word 0x00CF # granularity = 4096, 386
184 # (+5th nibble of limit)
185 +
186 /*
187 * The layout of the per-CPU GDT under Linux:
188 *
189 @@ -446,7 +538,14 @@
190 */
191 gdt_end:
193 -
194 +gdt64:
195 + .word gdt64_end - gdt64
196 + .long GDT64LOC
197 + .word 0
198 + .quad 0x0000000000000000 /* NULL descriptor */
199 + .quad 0x00af9a000000ffff /* __KERNEL_CS */
200 + .quad 0x00cf92000000ffff /* __KERNEL_DS */
201 +gdt64_end:
203 .section ".trailer", "a"
204 /* Constants set at build time, these are at the very end of my image */
205 @@ -458,14 +557,20 @@
206 .long CONVERT_MAGIC
207 gdt_size:
208 .long gdt_end - gdt
209 +gdt64_size:
210 + .long gdt64_end - gdt64
211 +pgt_size:
212 + .long 4096*6
213 bss_size:
214 - .long bss_size
215 + .long bss_sizex
216 ramdisk_flags:
217 .word 0
218 root_dev:
219 .word DEFAULT_ROOT_DEV
220 entry:
221 .long 0
222 +switch_64:
223 + .long 0
224 initrd_start:
225 .long 0
226 initrd_size:
227 diff -uNr mkelfImage-2.7/linux-i386/mkelf-linux-i386.c mkelfImage-2.7.new/linux-i386/mkelf-linux-i386.c
228 --- mkelfImage-2.7/linux-i386/mkelf-linux-i386.c 2006-03-17 06:08:22.000000000 -0800
229 +++ mkelfImage-2.7.new/linux-i386/mkelf-linux-i386.c 2006-11-08 09:54:58.000000000 -0800
230 @@ -19,13 +19,16 @@
231 static void (*parse_kernel_type)(struct kernel_info *info, char *kernel_buf, size_t kernel_size);
232 static void parse_bzImage_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size);
233 static void parse_elf32_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size);
234 +static void parse_elf64_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size);
235 +
236 +char *vmlinux_x86_64_probe(char *kernel_buf, off_t kernel_size);
238 char *vmlinux_i386_probe(char *kernel_buf, off_t kernel_size)
239 {
240 Elf32_Ehdr *ehdr;
241 Elf32_Phdr *phdr;
242 int i;
243 - int hdr1, hdr2;
244 + int phdrs;
245 ehdr = (Elf32_Ehdr *)kernel_buf;
246 if (
247 (ehdr->e_ident[EI_MAG0] != ELFMAG0) ||
248 @@ -35,7 +38,8 @@
249 return "No ELF signature found on kernel\n";
250 }
251 if (ehdr->e_ident[EI_CLASS] != ELFCLASS32) {
252 - return "Not a 32bit ELF kernel\n";
253 + return vmlinux_x86_64_probe(kernel_buf, kernel_size);
254 +// return "Not a 32bit ELF kernel\n";
255 }
256 if (ehdr->e_ident[EI_DATA] != ELFDATA2LSB) {
257 return "Not a little endian ELF kernel\n";
258 @@ -54,27 +58,64 @@
259 return "Kernel uses bad program header size.\n";
260 }
261 phdr = (Elf32_Phdr *)(kernel_buf + le32_to_cpu(ehdr->e_phoff));
262 - hdr1 = hdr2 = -1;
263 - for(i = 0; i < le32_to_cpu(ehdr->e_phnum); i++) {
264 + phdrs = 0;
265 + for(i = 0; i < le16_to_cpu(ehdr->e_phnum); i++) {
266 if (le32_to_cpu(phdr[i].p_type) != PT_LOAD)
267 continue;
268 - if (((hdr1 != -1) &&
269 - ((le32_to_cpu(phdr[hdr1].p_paddr) & 0xfffffff) != 0x100000)) ||
270 - (hdr2 != -1)) {
271 - return "Too many PT_LOAD segments to be a linux kernel\n";
272 - }
273 - if (hdr1 == -1) {
274 - hdr1 = i;
275 - } else {
276 - hdr2 = i;
277 - }
278 + phdrs++;
279 }
280 - if (hdr1 == -1) {
281 + if (phdrs == 0) {
282 return "No PT_LOAD segments!\n";
283 }
284 parse_kernel_type = parse_elf32_kernel;
285 return 0;
286 }
287 +char *vmlinux_x86_64_probe(char *kernel_buf, off_t kernel_size)
288 +{
289 + Elf64_Ehdr *ehdr;
290 + Elf64_Phdr *phdr;
291 + int i;
292 + int phdrs = 0;
293 + ehdr = (Elf64_Ehdr *)kernel_buf;
294 + if (
295 + (ehdr->e_ident[EI_MAG0] != ELFMAG0) ||
296 + (ehdr->e_ident[EI_MAG1] != ELFMAG1) ||
297 + (ehdr->e_ident[EI_MAG2] != ELFMAG2) ||
298 + (ehdr->e_ident[EI_MAG3] != ELFMAG3)) {
299 + return "No ELF signature found on kernel\n";
300 + }
301 + if (ehdr->e_ident[EI_CLASS] != ELFCLASS64) {
302 + return "Not a 64bit ELF kernel\n";
303 + }
304 + if (ehdr->e_ident[EI_DATA] != ELFDATA2LSB) {
305 + return "Not a little endian ELF kernel\n";
306 + }
307 + if (le16_to_cpu(ehdr->e_type) != ET_EXEC) {
308 + return "Not an executable kernel\n";
309 + }
310 + if (le16_to_cpu(ehdr->e_machine) != EM_X86_64) {
311 + return "Not an x86_64 kernel\n";
312 + }
313 + if ( (ehdr->e_ident[EI_VERSION] != EV_CURRENT) ||
314 + (le32_to_cpu(ehdr->e_version) != EV_CURRENT)) {
315 + return "Kernel not using ELF version 1.\n";
316 + }
317 + if (le16_to_cpu(ehdr->e_phentsize) != sizeof(*phdr)) {
318 + return "Kernel uses bad program header size.\n";
319 + }
320 + phdr = (Elf64_Phdr *)(kernel_buf + le64_to_cpu(ehdr->e_phoff));
321 + phdrs = 0;
322 + for(i = 0; i < le16_to_cpu(ehdr->e_phnum); i++) {
323 + if (le32_to_cpu(phdr[i].p_type) != PT_LOAD)
324 + continue;
325 + phdrs++;
326 + }
327 + if (phdrs == 0) {
328 + return "No PT_LOAD segments!\n";
329 + }
330 + parse_kernel_type = parse_elf64_kernel;
331 + return 0;
332 +}
334 char *bzImage_i386_probe(char *kernel_buf, off_t kernel_size)
335 {
336 @@ -118,17 +159,14 @@
338 struct kernel_info
339 {
340 - void *kernel;
341 - size_t filesz;
342 - size_t memsz;
343 - size_t paddr;
344 - size_t vaddr;
345 - void *kernel2;
346 - size_t filesz2;
347 - size_t memsz2;
348 - size_t paddr2;
349 - size_t vaddr2;
350 + int phdrs;
351 + void *kernel[4];
352 + size_t filesz[4];
353 + size_t memsz[4];
354 + size_t paddr[4];
355 + size_t vaddr[4];
356 size_t entry;
357 + size_t switch_64;
358 char *version;
359 };
361 @@ -137,43 +175,68 @@
362 Elf32_Ehdr *ehdr;
363 Elf32_Phdr *phdr;
364 int i;
365 - int hdr1, hdr2;
366 + int phdrs;
367 ehdr = (Elf32_Ehdr *)kernel_buf;
368 phdr = (Elf32_Phdr *)(kernel_buf + ehdr->e_phoff);
369 - hdr1 = hdr2 = -1;
370 + phdrs = 0;
371 for(i = 0; i < le16_to_cpu(ehdr->e_phnum); i++) {
372 if (le32_to_cpu(phdr[i].p_type) != PT_LOAD)
373 continue;
374 - if (hdr2 != -1) {
375 - die("Too many PT_LOAD segments to be a linux kernel\n");
376 - }
377 - if (hdr1 == -1) {
378 - hdr1 = i;
379 - } else {
380 - hdr2 = i;
381 - }
382 - }
383 - if (hdr1 == -1) {
384 - die("No PT_LOAD segments!\n");
385 + info->kernel[phdrs] = kernel_buf + le32_to_cpu(phdr[i].p_offset);
386 + info->filesz[phdrs] = le32_to_cpu(phdr[i].p_filesz);
387 + info->memsz[phdrs] = le32_to_cpu(phdr[i].p_memsz);
388 + info->paddr[phdrs] = le32_to_cpu(phdr[i].p_paddr) & 0xfffffff;
389 + info->vaddr[phdrs] = le32_to_cpu(phdr[i].p_vaddr);
390 + phdrs++;
391 }
392 - info->kernel = kernel_buf + le32_to_cpu(phdr[hdr1].p_offset);
393 - info->filesz = le32_to_cpu(phdr[hdr1].p_filesz);
394 - info->memsz = le32_to_cpu(phdr[hdr1].p_memsz);
395 - info->paddr = le32_to_cpu(phdr[hdr1].p_paddr) & 0xfffffff;
396 - info->vaddr = le32_to_cpu(phdr[hdr1].p_vaddr);
397 -
398 - if (hdr2 != -1) {
399 - info->kernel2 = kernel_buf + le32_to_cpu(phdr[hdr2].p_offset);
400 - info->filesz2 = le32_to_cpu(phdr[hdr2].p_filesz);
401 - info->memsz2 = le32_to_cpu(phdr[hdr2].p_memsz);
402 - info->paddr2 = le32_to_cpu(phdr[hdr2].p_paddr) & 0xfffffff;
403 - info->vaddr2 = le32_to_cpu(phdr[hdr2].p_vaddr);
404 +
405 + if(!phdrs)
406 + die("We need at least one phdr\n");
407 +
408 + info->phdrs = phdrs;
409 + info->entry = le32_to_cpu(ehdr->e_entry);
410 + info->switch_64 = 0; //not convert from elf64
411 + info->version = "unknown";
412 +}
413 +
414 +static void parse_elf64_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size)
415 +{
416 + Elf64_Ehdr *ehdr;
417 + Elf64_Phdr *phdr;
418 + int i;
419 + int phdrs;
420 + ehdr = (Elf64_Ehdr *)kernel_buf;
421 + phdr = (Elf64_Phdr *)(kernel_buf + le64_to_cpu(ehdr->e_phoff));
422 +
423 + phdrs = 0;
424 + for(i = 0; i < le16_to_cpu(ehdr->e_phnum); i++) {
425 + if (le32_to_cpu(phdr[i].p_type) != PT_LOAD)
426 + continue;
427 + info->kernel[phdrs] = kernel_buf + le64_to_cpu(phdr[i].p_offset);
428 + info->filesz[phdrs] = le64_to_cpu(phdr[i].p_filesz);
429 + info->memsz[phdrs] = le64_to_cpu(phdr[i].p_memsz);
430 + info->paddr[phdrs] = le64_to_cpu(phdr[i].p_paddr) & 0xffffff;
431 + info->vaddr[phdrs] = le64_to_cpu(phdr[i].p_vaddr);
432 + phdrs++;
433 }
434 +
435 + if(!phdrs)
436 + die("We need at least one phdr\n");
438 - info->entry = 0x100000;
439 - info->version = "unknown";
440 + info->phdrs = phdrs;
441 + info->entry = le64_to_cpu(ehdr->e_entry);
442 +#if 0
443 + if (info->entry != info->paddr[0]) {
444 + info->entry = info->paddr[0]; // we still have startup_32 there
445 + info->switch_64 = 0; //not convert from elf64
446 + } else
447 +#endif
448 + info->switch_64 = 1; //convert from elf64
449 +
450 + info->version = "unknown";
451 }
453 +
454 static void parse_bzImage_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size)
455 {
456 struct x86_linux_header *hdr;
457 @@ -186,12 +249,14 @@
458 }
459 offset = 512 + (512 *setup_sects);
461 - info->kernel = kernel_buf + offset;
462 - info->filesz = kernel_size - offset;
463 - info->memsz = 0x700000;
464 - info->paddr = 0x100000;
465 - info->vaddr = 0x100000;
466 - info->entry = info->paddr;
467 + info->kernel[0] = kernel_buf + offset;
468 + info->filesz[0] = kernel_size - offset;
469 + info->memsz[0] = 0x700000;
470 + info->paddr[0] = 0x100000;
471 + info->vaddr[0] = 0x100000;
472 + info->phdrs = 1;
473 + info->entry = info->paddr[0];
474 + info->switch_64 = 0; //not convert from elf64, even later bzImage become elf64, it still includes startup_32
475 info->version = kernel_buf + 512 + le16_to_cpu(hdr->kver_addr);
476 }
478 @@ -237,6 +302,7 @@
479 struct kernel_info kinfo;
480 struct image_parameters *params;
481 int index;
482 + int i;
484 int opt;
485 static const struct option options[] = {
486 @@ -310,7 +376,7 @@
488 /* Add a program header for the note section */
489 index = 4;
490 - index += kinfo.kernel2 ? 1:0;
491 + index += (kinfo.phdrs - 1);
492 index += ramdisk_size ? 1:0;
493 phdr = add_program_headers(ehdr, index);
495 @@ -328,23 +394,24 @@
496 phdr[2].p_paddr = REAL_MODE_DATA_LOC;
497 phdr[2].p_vaddr = REAL_MODE_DATA_LOC;
498 phdr[2].p_filesz = 0;
499 - phdr[2].p_memsz = (GDTLOC - REAL_MODE_DATA_LOC) + params->gdt_size;
500 + if(!kinfo.switch_64)
501 + phdr[2].p_memsz = (GDTLOC - REAL_MODE_DATA_LOC) + params->gdt_size;
502 + else
503 + phdr[2].p_memsz = (PGTLOC - REAL_MODE_DATA_LOC) + params->pgt_size;
504 phdr[2].p_data = 0;
506 - phdr[3].p_paddr = kinfo.paddr;
507 - phdr[3].p_vaddr = kinfo.vaddr;
508 - phdr[3].p_filesz = kinfo.filesz;
509 - phdr[3].p_memsz = kinfo.memsz;
510 - phdr[3].p_data = kinfo.kernel;
511 + if( (phdr[1].p_paddr + phdr[1].p_memsz) > phdr[2].p_paddr) {
512 + die("Internal error: need to increase REAL_MODE_DATA_LOC !\n");
513 + }
515 - index = 4;
516 + index = 3;
517 /* Put the second kernel frament if present */
518 - if (kinfo.kernel2) {
519 - phdr[index].p_paddr = kinfo.paddr2;
520 - phdr[index].p_vaddr = kinfo.vaddr2;
521 - phdr[index].p_filesz = kinfo.filesz2;
522 - phdr[index].p_memsz = kinfo.memsz2;
523 - phdr[index].p_data = kinfo.kernel2;
524 + for(i=0;i<kinfo.phdrs;i++) {
525 + phdr[index].p_paddr = kinfo.paddr[i];
526 + phdr[index].p_vaddr = kinfo.vaddr[i];
527 + phdr[index].p_filesz = kinfo.filesz[i];
528 + phdr[index].p_memsz = kinfo.memsz[i];
529 + phdr[index].p_data = kinfo.kernel[i];
530 index++;
531 }
533 @@ -352,6 +419,10 @@
534 */
535 params->initrd_start = params->initrd_size = 0;
536 if (ramdisk_size) {
537 + if( (phdr[index-1].p_paddr + phdr[index-1].p_memsz) > ramdisk_base) {
538 + die("need to increase increase ramdisk_base !\n");
539 + }
540 +
541 phdr[index].p_paddr = ramdisk_base;
542 phdr[index].p_vaddr = ramdisk_base;
543 phdr[index].p_filesz = ramdisk_size;
544 @@ -364,6 +435,7 @@
546 /* Set the start location */
547 params->entry = kinfo.entry;
548 + params->switch_64 = kinfo.switch_64;
549 ehdr->e_entry = phdr[1].p_paddr;
551 /* Setup the elf notes */
552 diff -uNr mkelfImage-2.7/linux-ia64/mkelf-linux-ia64.c mkelfImage-2.7.new/linux-ia64/mkelf-linux-ia64.c
553 --- mkelfImage-2.7/linux-ia64/mkelf-linux-ia64.c 2006-03-17 10:09:16.000000000 -0800
554 +++ mkelfImage-2.7.new/linux-ia64/mkelf-linux-ia64.c 2006-11-07 18:14:27.000000000 -0800
555 @@ -81,7 +81,7 @@
556 phdr = (Elf64_Phdr *)(kernel_buf + le64_to_cpu(ehdr->e_phoff));
557 phdrs = 0;
558 for(i = 0; i < le16_to_cpu(ehdr->e_phnum); i++) {
559 - if (le16_to_cpu(phdr[i].p_type) != PT_LOAD)
560 + if (le32_to_cpu(phdr[i].p_type) != PT_LOAD)
561 continue;
562 phdrs++;
563 }