Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 1 | #include <stdio.h> |
| 2 | #include <errno.h> |
| 3 | #include <stdlib.h> |
| 4 | #include <stdint.h> |
| 5 | #include <string.h> |
| 6 | #define _GNU_SOURCE |
| 7 | #include <getopt.h> |
| 8 | #include "elf.h" |
| 9 | #include "elf_boot.h" |
| 10 | #include "convert.h" |
| 11 | #include "x86-linux.h" |
| 12 | #include "mkelfImage.h" |
| 13 | |
| 14 | static unsigned char payload[] = { |
| 15 | #include "convert.bin.c" |
| 16 | }; |
| 17 | |
| 18 | struct kernel_info; |
| 19 | static void (*parse_kernel_type)(struct kernel_info *info, char *kernel_buf, size_t kernel_size); |
| 20 | static void parse_bzImage_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size); |
| 21 | static void parse_elf32_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size); |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 22 | static void parse_elf64_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size); |
| 23 | |
| 24 | char *vmlinux_x86_64_probe(char *kernel_buf, off_t kernel_size); |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 25 | |
| 26 | char *vmlinux_i386_probe(char *kernel_buf, off_t kernel_size) |
| 27 | { |
| 28 | Elf32_Ehdr *ehdr; |
| 29 | Elf32_Phdr *phdr; |
| 30 | int i; |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 31 | int phdrs; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 32 | ehdr = (Elf32_Ehdr *)kernel_buf; |
| 33 | if ( |
| 34 | (ehdr->e_ident[EI_MAG0] != ELFMAG0) || |
| 35 | (ehdr->e_ident[EI_MAG1] != ELFMAG1) || |
| 36 | (ehdr->e_ident[EI_MAG2] != ELFMAG2) || |
| 37 | (ehdr->e_ident[EI_MAG3] != ELFMAG3)) { |
| 38 | return "No ELF signature found on kernel\n"; |
| 39 | } |
| 40 | if (ehdr->e_ident[EI_CLASS] != ELFCLASS32) { |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 41 | return vmlinux_x86_64_probe(kernel_buf, kernel_size); |
| 42 | // return "Not a 32bit ELF kernel\n"; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 43 | } |
| 44 | if (ehdr->e_ident[EI_DATA] != ELFDATA2LSB) { |
| 45 | return "Not a little endian ELF kernel\n"; |
| 46 | } |
| 47 | if (le16_to_cpu(ehdr->e_type) != ET_EXEC) { |
| 48 | return "Not an executable kernel\n"; |
| 49 | } |
| 50 | if (le16_to_cpu(ehdr->e_machine) != EM_386) { |
| 51 | return "Not an i386 kernel\n"; |
| 52 | } |
| 53 | if ( (ehdr->e_ident[EI_VERSION] != EV_CURRENT) || |
| 54 | (le32_to_cpu(ehdr->e_version) != EV_CURRENT)) { |
| 55 | return "Kernel not using ELF version 1.\n"; |
| 56 | } |
| 57 | if (le16_to_cpu(ehdr->e_phentsize) != sizeof(*phdr)) { |
| 58 | return "Kernel uses bad program header size.\n"; |
| 59 | } |
| 60 | phdr = (Elf32_Phdr *)(kernel_buf + le32_to_cpu(ehdr->e_phoff)); |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 61 | phdrs = 0; |
| 62 | for(i = 0; i < le16_to_cpu(ehdr->e_phnum); i++) { |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 63 | if (le32_to_cpu(phdr[i].p_type) != PT_LOAD) |
| 64 | continue; |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 65 | phdrs++; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 66 | } |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 67 | if (phdrs == 0) { |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 68 | return "No PT_LOAD segments!\n"; |
| 69 | } |
| 70 | parse_kernel_type = parse_elf32_kernel; |
| 71 | return 0; |
| 72 | } |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 73 | char *vmlinux_x86_64_probe(char *kernel_buf, off_t kernel_size) |
| 74 | { |
| 75 | Elf64_Ehdr *ehdr; |
| 76 | Elf64_Phdr *phdr; |
| 77 | int i; |
| 78 | int phdrs = 0; |
| 79 | ehdr = (Elf64_Ehdr *)kernel_buf; |
| 80 | if ( |
| 81 | (ehdr->e_ident[EI_MAG0] != ELFMAG0) || |
| 82 | (ehdr->e_ident[EI_MAG1] != ELFMAG1) || |
| 83 | (ehdr->e_ident[EI_MAG2] != ELFMAG2) || |
| 84 | (ehdr->e_ident[EI_MAG3] != ELFMAG3)) { |
| 85 | return "No ELF signature found on kernel\n"; |
| 86 | } |
| 87 | if (ehdr->e_ident[EI_CLASS] != ELFCLASS64) { |
| 88 | return "Not a 64bit ELF kernel\n"; |
| 89 | } |
| 90 | if (ehdr->e_ident[EI_DATA] != ELFDATA2LSB) { |
| 91 | return "Not a little endian ELF kernel\n"; |
| 92 | } |
| 93 | if (le16_to_cpu(ehdr->e_type) != ET_EXEC) { |
| 94 | return "Not an executable kernel\n"; |
| 95 | } |
| 96 | if (le16_to_cpu(ehdr->e_machine) != EM_X86_64) { |
| 97 | return "Not an x86_64 kernel\n"; |
| 98 | } |
| 99 | if ( (ehdr->e_ident[EI_VERSION] != EV_CURRENT) || |
| 100 | (le32_to_cpu(ehdr->e_version) != EV_CURRENT)) { |
| 101 | return "Kernel not using ELF version 1.\n"; |
| 102 | } |
| 103 | if (le16_to_cpu(ehdr->e_phentsize) != sizeof(*phdr)) { |
| 104 | return "Kernel uses bad program header size.\n"; |
| 105 | } |
| 106 | phdr = (Elf64_Phdr *)(kernel_buf + le64_to_cpu(ehdr->e_phoff)); |
| 107 | phdrs = 0; |
| 108 | for(i = 0; i < le16_to_cpu(ehdr->e_phnum); i++) { |
| 109 | if (le32_to_cpu(phdr[i].p_type) != PT_LOAD) |
| 110 | continue; |
| 111 | phdrs++; |
| 112 | } |
| 113 | if (phdrs == 0) { |
| 114 | return "No PT_LOAD segments!\n"; |
| 115 | } |
| 116 | parse_kernel_type = parse_elf64_kernel; |
| 117 | return 0; |
| 118 | } |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 119 | |
| 120 | char *bzImage_i386_probe(char *kernel_buf, off_t kernel_size) |
| 121 | { |
| 122 | struct x86_linux_header *hdr; |
| 123 | unsigned long offset; |
| 124 | int setup_sects; |
| 125 | hdr = (struct x86_linux_header *)kernel_buf; |
| 126 | |
| 127 | if (le16_to_cpu(hdr->boot_sector_magic) != 0xaa55) { |
| 128 | return "No bootsector magic"; |
| 129 | } |
| 130 | if (memcmp(hdr->header_magic, "HdrS", 4) != 0) { |
| 131 | return "Not a linux kernel"; |
| 132 | } |
| 133 | |
| 134 | if (le16_to_cpu(hdr->protocol_version) < 0x202) { |
| 135 | return "Kernel protcols version before 2.02 not supported"; |
| 136 | } |
| 137 | |
| 138 | setup_sects = hdr->setup_sects; |
| 139 | if (setup_sects == 0) { |
| 140 | setup_sects = 4; |
| 141 | } |
| 142 | offset = 512 + (512 *setup_sects); |
| 143 | if (offset > kernel_size) { |
| 144 | return "Not enough bytes"; |
| 145 | } |
| 146 | parse_kernel_type = parse_bzImage_kernel; |
| 147 | return 0; |
| 148 | } |
| 149 | |
| 150 | char *linux_i386_probe(char *kernel_buf, off_t kernel_size) |
| 151 | { |
| 152 | char *result; |
| 153 | result = ""; |
| 154 | if (result) result = bzImage_i386_probe(kernel_buf, kernel_size); |
| 155 | if (result) result = vmlinux_i386_probe(kernel_buf, kernel_size); |
| 156 | if (result) result = bzImage_i386_probe(kernel_buf, kernel_size); |
| 157 | return result; |
| 158 | } |
| 159 | |
| 160 | struct kernel_info |
| 161 | { |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 162 | int phdrs; |
| 163 | void *kernel[4]; |
| 164 | size_t filesz[4]; |
| 165 | size_t memsz[4]; |
| 166 | size_t paddr[4]; |
| 167 | size_t vaddr[4]; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 168 | size_t entry; |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 169 | size_t switch_64; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 170 | char *version; |
| 171 | }; |
| 172 | |
| 173 | static void parse_elf32_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size) |
| 174 | { |
| 175 | Elf32_Ehdr *ehdr; |
| 176 | Elf32_Phdr *phdr; |
| 177 | int i; |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 178 | int phdrs; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 179 | ehdr = (Elf32_Ehdr *)kernel_buf; |
| 180 | phdr = (Elf32_Phdr *)(kernel_buf + ehdr->e_phoff); |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 181 | phdrs = 0; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 182 | for(i = 0; i < le16_to_cpu(ehdr->e_phnum); i++) { |
| 183 | if (le32_to_cpu(phdr[i].p_type) != PT_LOAD) |
| 184 | continue; |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 185 | info->kernel[phdrs] = kernel_buf + le32_to_cpu(phdr[i].p_offset); |
| 186 | info->filesz[phdrs] = le32_to_cpu(phdr[i].p_filesz); |
| 187 | info->memsz[phdrs] = le32_to_cpu(phdr[i].p_memsz); |
| 188 | info->paddr[phdrs] = le32_to_cpu(phdr[i].p_paddr) & 0xfffffff; |
| 189 | info->vaddr[phdrs] = le32_to_cpu(phdr[i].p_vaddr); |
| 190 | phdrs++; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 191 | } |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 192 | |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 193 | if(!phdrs) |
| 194 | die("We need at least one phdr\n"); |
| 195 | |
| 196 | info->phdrs = phdrs; |
| 197 | info->entry = le32_to_cpu(ehdr->e_entry); |
| 198 | info->switch_64 = 0; //not convert from elf64 |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 199 | info->version = "unknown"; |
| 200 | } |
| 201 | |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 202 | static void parse_elf64_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size) |
| 203 | { |
| 204 | Elf64_Ehdr *ehdr; |
| 205 | Elf64_Phdr *phdr; |
| 206 | int i; |
| 207 | int phdrs; |
| 208 | ehdr = (Elf64_Ehdr *)kernel_buf; |
| 209 | phdr = (Elf64_Phdr *)(kernel_buf + le64_to_cpu(ehdr->e_phoff)); |
| 210 | |
| 211 | phdrs = 0; |
| 212 | for(i = 0; i < le16_to_cpu(ehdr->e_phnum); i++) { |
| 213 | if (le32_to_cpu(phdr[i].p_type) != PT_LOAD) |
| 214 | continue; |
| 215 | info->kernel[phdrs] = kernel_buf + le64_to_cpu(phdr[i].p_offset); |
| 216 | info->filesz[phdrs] = le64_to_cpu(phdr[i].p_filesz); |
| 217 | info->memsz[phdrs] = le64_to_cpu(phdr[i].p_memsz); |
| 218 | info->paddr[phdrs] = le64_to_cpu(phdr[i].p_paddr) & 0xffffff; |
| 219 | info->vaddr[phdrs] = le64_to_cpu(phdr[i].p_vaddr); |
| 220 | phdrs++; |
| 221 | } |
| 222 | |
| 223 | if(!phdrs) |
| 224 | die("We need at least one phdr\n"); |
| 225 | |
| 226 | info->phdrs = phdrs; |
| 227 | info->entry = le64_to_cpu(ehdr->e_entry); |
| 228 | #if 0 |
| 229 | if (info->entry != info->paddr[0]) { |
| 230 | info->entry = info->paddr[0]; // we still have startup_32 there |
| 231 | info->switch_64 = 0; //not convert from elf64 |
| 232 | } else |
| 233 | #endif |
| 234 | info->switch_64 = 1; //convert from elf64 |
| 235 | |
| 236 | info->version = "unknown"; |
| 237 | } |
| 238 | |
| 239 | |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 240 | static void parse_bzImage_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size) |
| 241 | { |
| 242 | struct x86_linux_header *hdr; |
| 243 | unsigned long offset; |
| 244 | int setup_sects; |
| 245 | hdr = (struct x86_linux_header *)kernel_buf; |
| 246 | setup_sects = hdr->setup_sects; |
| 247 | if (setup_sects == 0) { |
| 248 | setup_sects = 4; |
| 249 | } |
| 250 | offset = 512 + (512 *setup_sects); |
| 251 | |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 252 | info->kernel[0] = kernel_buf + offset; |
| 253 | info->filesz[0] = kernel_size - offset; |
| 254 | info->memsz[0] = 0x700000; |
| 255 | info->paddr[0] = 0x100000; |
| 256 | info->vaddr[0] = 0x100000; |
| 257 | info->phdrs = 1; |
| 258 | info->entry = info->paddr[0]; |
| 259 | info->switch_64 = 0; //not convert from elf64, even later bzImage become elf64, it still includes startup_32 |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 260 | info->version = kernel_buf + 512 + le16_to_cpu(hdr->kver_addr); |
| 261 | } |
| 262 | |
| 263 | static void parse_kernel(struct kernel_info *info, char *kernel_buf, size_t kernel_size) |
| 264 | { |
| 265 | memset(info, 0, sizeof(*info)); |
| 266 | if (parse_kernel_type) { |
| 267 | parse_kernel_type(info, kernel_buf, kernel_size); |
| 268 | } |
| 269 | else { |
| 270 | die("Unknown kernel format"); |
| 271 | } |
| 272 | } |
| 273 | |
| 274 | void linux_i386_usage(void) |
| 275 | { |
| 276 | printf( |
| 277 | " --command-line=<string> Set the command line to <string>\n" |
| 278 | " --append=<string> Set the command line to <string>\n" |
| 279 | " --initrd=<filename> Set the initrd to <filename>\n" |
| 280 | " --ramdisk=<filename> Set the initrd to <filename>\n" |
| 281 | " --ramdisk-base=<addr> Set the initrd load address to <addr>\n" |
| 282 | ); |
| 283 | return; |
| 284 | } |
| 285 | |
| 286 | |
| 287 | #define OPT_CMDLINE OPT_MAX+0 |
| 288 | #define OPT_RAMDISK OPT_MAX+1 |
| 289 | #define OPT_RAMDISK_BASE OPT_MAX+2 |
| 290 | |
| 291 | #define DEFAULT_RAMDISK_BASE (8*1024*1024) |
| 292 | |
| 293 | int linux_i386_mkelf(int argc, char **argv, |
| 294 | struct memelfheader *ehdr, char *kernel_buf, off_t kernel_size) |
| 295 | { |
| 296 | const char *ramdisk, *cmdline; |
| 297 | unsigned long ramdisk_base; |
| 298 | char *payload_buf, *ramdisk_buf; |
| 299 | off_t payload_size, ramdisk_size; |
| 300 | struct memelfphdr *phdr; |
| 301 | struct memelfnote *note; |
| 302 | struct kernel_info kinfo; |
| 303 | struct image_parameters *params; |
| 304 | int index; |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 305 | int i; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 306 | |
| 307 | int opt; |
| 308 | static const struct option options[] = { |
| 309 | MKELF_OPTIONS |
| 310 | { "command-line", 1, 0, OPT_CMDLINE }, |
| 311 | { "append", 1, 0, OPT_CMDLINE }, |
| 312 | { "initrd", 1, 0, OPT_RAMDISK }, |
| 313 | { "ramdisk", 1, 0, OPT_RAMDISK }, |
| 314 | { "ramdisk-base", 1, 0, OPT_RAMDISK_BASE }, |
| 315 | { 0 , 0, 0, 0 }, |
| 316 | }; |
| 317 | static const char short_options[] = MKELF_OPT_STR; |
| 318 | |
| 319 | ramdisk_base = DEFAULT_RAMDISK_BASE; |
| 320 | ramdisk = 0; |
| 321 | cmdline=""; |
| 322 | |
| 323 | while((opt = getopt_long(argc, argv, short_options, options, 0)) != -1) { |
| 324 | switch(opt) { |
| 325 | case '?': |
| 326 | error("Unknown option %s\n", argv[optind]); |
| 327 | break; |
| 328 | case OPT_RAMDISK_BASE: |
| 329 | { |
| 330 | char *end; |
| 331 | unsigned long base; |
| 332 | base = strtoul(optarg, &end, 0); |
| 333 | if ((end == optarg) || (*end != '\0')) { |
| 334 | error("Invalid ramdisk base\n"); |
| 335 | } |
| 336 | ramdisk_base = base; |
| 337 | } |
| 338 | case OPT_RAMDISK: |
| 339 | ramdisk = optarg; |
| 340 | break; |
| 341 | case OPT_CMDLINE: |
| 342 | cmdline = optarg; |
| 343 | break; |
| 344 | default: |
| 345 | break; |
| 346 | } |
| 347 | } |
| 348 | ehdr->ei_class = ELFCLASS32; |
| 349 | ehdr->ei_data = ELFDATA2LSB; |
| 350 | ehdr->e_type = ET_EXEC; |
| 351 | ehdr->e_machine = EM_386; |
| 352 | |
| 353 | /* locate the payload buffer */ |
| 354 | payload_buf = payload; |
| 355 | payload_size = sizeof(payload); |
| 356 | |
| 357 | /* slurp the input files */ |
| 358 | ramdisk_buf = slurp_file(ramdisk, &ramdisk_size); |
| 359 | |
| 360 | /* parse the kernel */ |
| 361 | parse_kernel(&kinfo, kernel_buf, kernel_size); |
| 362 | |
| 363 | /* Find the parameters */ |
| 364 | params = (void *)(payload_buf + (payload_size - sizeof(*params))); |
| 365 | |
| 366 | /* A sanity check against bad versions of binutils */ |
| 367 | if (params->convert_magic != CONVERT_MAGIC) { |
| 368 | die("Internal error convert_magic %08x != %08x\n", |
| 369 | params->convert_magic, CONVERT_MAGIC); |
| 370 | } |
| 371 | |
| 372 | /* Copy the command line */ |
| 373 | strncpy(params->cmdline, cmdline, sizeof(params->cmdline)); |
| 374 | params->cmdline[sizeof(params->cmdline)-1]= '\0'; |
| 375 | |
| 376 | |
| 377 | /* Add a program header for the note section */ |
| 378 | index = 4; |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 379 | index += (kinfo.phdrs - 1); |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 380 | index += ramdisk_size ? 1:0; |
| 381 | phdr = add_program_headers(ehdr, index); |
| 382 | |
| 383 | /* Fill in the program headers*/ |
| 384 | phdr[0].p_type = PT_NOTE; |
| 385 | |
| 386 | /* Fill in the converter program headers */ |
| 387 | phdr[1].p_paddr = CONVERTLOC; |
| 388 | phdr[1].p_vaddr = CONVERTLOC; |
| 389 | phdr[1].p_filesz = payload_size; |
| 390 | phdr[1].p_memsz = payload_size + params->bss_size; |
| 391 | phdr[1].p_data = payload; |
| 392 | |
| 393 | /* Reserve space for the REAL MODE DATA segment AND the GDT segment */ |
| 394 | phdr[2].p_paddr = REAL_MODE_DATA_LOC; |
| 395 | phdr[2].p_vaddr = REAL_MODE_DATA_LOC; |
| 396 | phdr[2].p_filesz = 0; |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 397 | if(!kinfo.switch_64) |
| 398 | phdr[2].p_memsz = (GDTLOC - REAL_MODE_DATA_LOC) + params->gdt_size; |
| 399 | else |
| 400 | phdr[2].p_memsz = (PGTLOC - REAL_MODE_DATA_LOC) + params->pgt_size; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 401 | phdr[2].p_data = 0; |
| 402 | |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 403 | if( (phdr[1].p_paddr + phdr[1].p_memsz) > phdr[2].p_paddr) { |
| 404 | die("Internal error: need to increase REAL_MODE_DATA_LOC !\n"); |
| 405 | } |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 406 | |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 407 | index = 3; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 408 | /* Put the second kernel frament if present */ |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 409 | for(i=0;i<kinfo.phdrs;i++) { |
| 410 | phdr[index].p_paddr = kinfo.paddr[i]; |
| 411 | phdr[index].p_vaddr = kinfo.vaddr[i]; |
| 412 | phdr[index].p_filesz = kinfo.filesz[i]; |
| 413 | phdr[index].p_memsz = kinfo.memsz[i]; |
| 414 | phdr[index].p_data = kinfo.kernel[i]; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 415 | index++; |
| 416 | } |
| 417 | |
| 418 | /* Put the ramdisk at ramdisk base. |
| 419 | */ |
| 420 | params->initrd_start = params->initrd_size = 0; |
| 421 | if (ramdisk_size) { |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 422 | if( (phdr[index-1].p_paddr + phdr[index-1].p_memsz) > ramdisk_base) { |
| 423 | die("need to increase increase ramdisk_base !\n"); |
| 424 | } |
| 425 | |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 426 | phdr[index].p_paddr = ramdisk_base; |
| 427 | phdr[index].p_vaddr = ramdisk_base; |
| 428 | phdr[index].p_filesz = ramdisk_size; |
| 429 | phdr[index].p_memsz = ramdisk_size; |
| 430 | phdr[index].p_data = ramdisk_buf; |
| 431 | params->initrd_start = phdr[index].p_paddr; |
| 432 | params->initrd_size = phdr[index].p_filesz; |
| 433 | index++; |
| 434 | } |
| 435 | |
| 436 | /* Set the start location */ |
| 437 | params->entry = kinfo.entry; |
Ward Vandewege | ebc9218 | 2008-08-06 20:37:38 +0000 | [diff] [blame] | 438 | params->switch_64 = kinfo.switch_64; |
Stefan Reinauer | b34eea3 | 2008-02-15 18:16:06 +0000 | [diff] [blame] | 439 | ehdr->e_entry = phdr[1].p_paddr; |
| 440 | |
| 441 | /* Setup the elf notes */ |
| 442 | note = add_notes(ehdr, 3); |
| 443 | note[0].n_type = EIN_PROGRAM_NAME; |
| 444 | note[0].n_name = "ELFBoot"; |
| 445 | note[0].n_desc = "Linux"; |
| 446 | note[0].n_descsz = strlen(note[0].n_desc)+1; |
| 447 | |
| 448 | note[1].n_type = EIN_PROGRAM_VERSION; |
| 449 | note[1].n_name = "ELFBoot"; |
| 450 | note[1].n_desc = kinfo.version; |
| 451 | note[1].n_descsz = strlen(note[1].n_desc); |
| 452 | |
| 453 | note[2].n_type = EIN_PROGRAM_CHECKSUM; |
| 454 | note[2].n_name = "ELFBoot"; |
| 455 | note[2].n_desc = 0; |
| 456 | note[2].n_descsz = 2; |
| 457 | |
| 458 | return 0; |
| 459 | } |
| 460 | |