src/boot/elfboot.c

   1 #include <console/console.h>
   2 #include <part/fallback_boot.h>
   3 #include <boot/elf.h>
   4 #include <boot/elf_boot.h>
   5 #include <boot/linuxbios_tables.h>
   6 #include <ip_checksum.h>
   7 #include <stream/read_bytes.h>
   8 #include <stdint.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11
  12 /* Maximum physical address we can use for the linuxBIOS bounce buffer.
  13  */
  14 #ifndef MAX_ADDR
  15 #define MAX_ADDR -1UL
  16 #endif
  17
  18 extern unsigned char _ram_seg;
  19 extern unsigned char _eram_seg;
  20
  21 struct segment {
  22         struct segment *next;
  23         struct segment *prev;
  24         struct segment *phdr_next;
  25         struct segment *phdr_prev;
  26         unsigned long s_addr;
  27         unsigned long s_memsz;
  28         unsigned long s_offset;
  29         unsigned long s_filesz;
  30 };
  31
  32 struct verify_callback {
  33         struct verify_callback *next;
  34         int (*callback)(struct verify_callback *vcb,
  35                 Elf_ehdr *ehdr, Elf_phdr *phdr, struct segment *head);
  36         unsigned long desc_offset;
  37         unsigned long desc_addr;
  38 };
  39
  40 struct ip_checksum_vcb {
  41         struct verify_callback data;
  42         unsigned short ip_checksum;
  43 };
  44
  45 int verify_ip_checksum(
  46         struct verify_callback *vcb,
  47         Elf_ehdr *ehdr, Elf_phdr *phdr, struct segment *head)
  48 {
  49         struct ip_checksum_vcb *cb;
  50         struct segment *ptr;
  51         unsigned long bytes;
  52         unsigned long checksum;
  53         unsigned char buff[2], *n_desc;
  54         cb = (struct ip_checksum_vcb *)vcb;
  55         /* zero the checksum so it's value won't
  56          * get in the way of verifying the checksum.
  57          */
  58         n_desc = 0;
  59         if (vcb->desc_addr) {
  60                 n_desc = (unsigned char *)(vcb->desc_addr);
  61                 memcpy(buff, n_desc, 2);
  62                 memset(n_desc, 0, 2);
  63         }
  64         bytes = 0;
  65         checksum = compute_ip_checksum(ehdr, sizeof(*ehdr));
  66         bytes += sizeof(*ehdr);
  67         checksum = add_ip_checksums(bytes, checksum,
  68                 compute_ip_checksum(phdr, ehdr->e_phnum*sizeof(*phdr)));
  69         bytes += ehdr->e_phnum*sizeof(*phdr);
  70         for(ptr = head->phdr_next; ptr != head; ptr = ptr->phdr_next) {
  71                 checksum = add_ip_checksums(bytes, checksum,
  72                         compute_ip_checksum((void *)ptr->s_addr, ptr->s_memsz));
  73                 bytes += ptr->s_memsz;
  74         }
  75         if (n_desc != 0) {
  76                 memcpy(n_desc, buff, 2);
  77         }
  78         if (checksum != cb->ip_checksum) {
  79                 printk_err("Image checksum: %04x != computed checksum: %04x\n",
  80                         cb->ip_checksum, checksum);
  81         }
  82         return checksum == cb->ip_checksum;
  83 }
  84
  85 /* The problem:
  86  * Static executables all want to share the same addresses
  87  * in memory because only a few addresses are reliably present on
  88  * a machine, and implementing general relocation is hard.
  89  *
  90  * The solution:
  91  * - Allocate a buffer twice the size of the linuxBIOS image.
  92  * - Anything that would overwrite linuxBIOS copy into the lower half of
  93  *   the buffer.
  94  * - After loading an ELF image copy linuxBIOS to the upper half of the
  95  *   buffer.
  96  * - Then jump to the loaded image.
  97  *
  98  * Benefits:
  99  * - Nearly arbitrary standalone executables can be loaded.
 100  * - LinuxBIOS is preserved, so it can be returned to.
 101  * - The implementation is still relatively simple,
 102  *   and much simpler then the general case implemented in kexec.
 103  *
 104  */
 105
 106 static unsigned long get_bounce_buffer(struct lb_memory *mem)
 107 {
 108         unsigned long lb_size;
 109         unsigned long mem_entries;
 110         unsigned long buffer;
 111         int i;
 112         lb_size = (unsigned long)(&_eram_seg - &_ram_seg);
 113         /* Double linuxBIOS size so I have somewhere to place a copy to return to */
 114         lb_size = lb_size + lb_size;
 115         mem_entries = (mem->size - sizeof(*mem))/sizeof(mem->map[0]);
 116         buffer = 0;
 117         for(i = 0; i < mem_entries; i++) {
 118                 unsigned long mstart, mend;
 119                 unsigned long msize;
 120                 unsigned long tbuffer;
 121                 if (mem->map[i].type != LB_MEM_RAM)
 122                         continue;
 123                 if (mem->map[i].start > MAX_ADDR)
 124                         continue;
 125                 if (mem->map[i].size < lb_size)
 126                         continue;
 127                 mstart = mem->map[i].start;
 128                 msize = MAX_ADDR - mstart +1;
 129                 if (msize > mem->map[i].size)
 130                         msize = mem->map[i].size;
 131                 mend = mstart + msize;
 132                 tbuffer = mend - lb_size;
 133                 if (tbuffer < buffer)
 134                         continue;
 135                 buffer = tbuffer;
 136         }
 137         return buffer;
 138 }
 139
 140
 141 static struct verify_callback *process_elf_notes(
 142         unsigned char *header,
 143         unsigned long offset, unsigned long length)
 144 {
 145         struct verify_callback *cb_chain;
 146         unsigned char *note, *end;
 147         char *program, *version;
 148
 149         cb_chain = 0;
 150         note = header + offset;
 151         end = note + length;
 152         program = version = 0;
 153         while(note < end) {
 154                 Elf_Nhdr *hdr;
 155                 unsigned char *n_name, *n_desc, *next;
 156                 hdr = (Elf_Nhdr *)note;
 157                 n_name = note + sizeof(*hdr);
 158                 n_desc = n_name + ((hdr->n_namesz + 3) & ~3);
 159                 next = n_desc + ((hdr->n_descsz + 3) & ~3);
 160                 if (next > end) {
 161                         break;
 162                 }
 163                 if ((hdr->n_namesz == sizeof(ELF_NOTE_BOOT)) &&
 164                         (memcmp(n_name, ELF_NOTE_BOOT, sizeof(ELF_NOTE_BOOT)) == 0)) {
 165                         switch(hdr->n_type) {
 166                         case EIN_PROGRAM_NAME:
 167                                 if (n_desc[hdr->n_descsz -1] == 0) {
 168                                         program = n_desc;
 169                                 }
 170                                 break;
 171                         case EIN_PROGRAM_VERSION:
 172                                 if (n_desc[hdr->n_descsz -1] == 0) {
 173                                         version = n_desc;
 174                                 }
 175                                 break;
 176                         case EIN_PROGRAM_CHECKSUM:
 177                         {
 178                                 struct ip_checksum_vcb *cb;
 179                                 cb = malloc(sizeof(*cb));
 180                                 cb->ip_checksum = *((uint16_t *)n_desc);
 181                                 cb->data.callback = verify_ip_checksum;
 182                                 cb->data.next = cb_chain;
 183                                 cb->data.desc_offset = n_desc - header;
 184                                 cb_chain = &cb->data;
 185                                 break;
 186                         }
 187                         }
 188                 }
 189                 printk_spew("n_type: %08x n_name(%d): %-*.*s n_desc(%d): %-*.*s\n",
 190                         hdr->n_type,
 191                         hdr->n_namesz, hdr->n_namesz, hdr->n_namesz, n_name,
 192                         hdr->n_descsz,hdr->n_descsz, hdr->n_descsz, n_desc);
 193                 note = next;
 194         }
 195         if (program && version) {
 196                 printk_info("Loading %s version: %s\n",
 197                         program, version);
 198         }
 199         return cb_chain;
 200 }
 201
 202 static int valid_area(struct lb_memory *mem, unsigned long buffer,
 203         unsigned long start, unsigned long len)
 204 {
 205         /* Check through all of the memory segments and ensure
 206          * the segment that was passed in is completely contained
 207          * in RAM.
 208          */
 209         int i;
 210         unsigned long end = start + len;
 211         unsigned long mem_entries = (mem->size - sizeof(*mem))/sizeof(mem->map[0]);
 212
 213         /* See if I conflict with the bounce buffer */
 214         if (end >= buffer) {
 215                 return 0;
 216         }
 217
 218         /* Walk through the table of valid memory ranges and see if I
 219          * have a match.
 220          */
 221         for(i = 0; i < mem_entries; i++) {
 222                 uint64_t mstart, mend;
 223                 uint32_t mtype;
 224                 mtype = mem->map[i].type;
 225                 mstart = mem->map[i].start;
 226                 mend = mstart + mem->map[i].size;
 227                 if ((mtype == LB_MEM_RAM) && (start < mend) && (end > mstart)) {
 228                         break;
 229                 }
 230         }
 231         if (i == mem_entries) {
 232                 printk_err("No matching ram area found for range:\n");
 233                 printk_err("  [0x%016lx, 0x%016lx)\n", start, end);
 234                 printk_err("Ram areas\n");
 235                 for(i = 0; i < mem_entries; i++) {
 236                         uint64_t mstart, mend;
 237                         uint32_t mtype;
 238                         mtype = mem->map[i].type;
 239                         mstart = mem->map[i].start;
 240                         mend = mstart + mem->map[i].size;
 241                         printk_err("  [0x%016lx, 0x%016lx) %s\n",
 242                                 (unsigned long)mstart,
 243                                 (unsigned long)mend,
 244                                 (mtype == LB_MEM_RAM)?"RAM":"Reserved");
 245
 246                 }
 247                 return 0;
 248         }
 249         return 1;
 250 }
 251
 252 static void relocate_segment(unsigned long buffer, struct segment *seg)
 253 {
 254         /* Modify all segments that want to load onto linuxBIOS
 255          * to load onto the bounce buffer instead.
 256          */
 257         unsigned long lb_start = (unsigned long)&_ram_seg;
 258         unsigned long lb_end = (unsigned long)&_eram_seg;
 259         unsigned long start, middle, end;
 260
 261         printk_spew("lb: [0x%016lx, 0x%016lx)\n",
 262                 lb_start, lb_end);
 263
 264         start = seg->s_addr;
 265         middle = start + seg->s_filesz;
 266         end = start + seg->s_memsz;
 267         /* I don't conflict with linuxBIOS so get out of here */
 268         if ((end <= lb_start) || (start >= lb_end))
 269                 return;
 270
 271         printk_spew("segment: [0x%016lx, 0x%016lx, 0x%016lx)\n",
 272                 start, middle, end);
 273
 274         /* Slice off a piece at the beginning
 275          * that doesn't conflict with linuxBIOS.
 276          */
 277         if (start < lb_start) {
 278                 struct segment *new;
 279                 unsigned long len = lb_start - start;
 280                 new = malloc(sizeof(*new));
 281                 *new = *seg;
 282                 new->s_memsz = len;
 283                 seg->s_memsz -= len;
 284                 seg->s_addr += len;
 285                 seg->s_offset += len;
 286                 if (seg->s_filesz > len) {
 287                         new->s_filesz = len;
 288                         seg->s_filesz -= len;
 289                 } else {
 290                         seg->s_filesz = 0;
 291                 }
 292
 293                 /* Order by stream offset */
 294                 new->next = seg;
 295                 new->prev = seg->prev;
 296                 seg->prev->next = new;
 297                 seg->prev = new;
 298                 /* Order by original program header order */
 299                 new->phdr_next = seg;
 300                 new->phdr_prev = seg->phdr_prev;
 301                 seg->phdr_prev->phdr_next = new;
 302                 seg->phdr_prev = new;
 303
 304                 /* compute the new value of start */
 305                 start = seg->s_addr;
 306
 307                 printk_spew("   early: [0x%016lx, 0x%016lx, 0x%016lx)\n",
 308                         new->s_addr,
 309                         new->s_addr + new->s_filesz,
 310                         new->s_addr + new->s_memsz);
 311         }
 312
 313         /* Slice off a piece at the end
 314          * that doesn't conflict with linuxBIOS
 315          */
 316         if (end > lb_end) {
 317                 unsigned long len = lb_end - start;
 318                 struct segment *new;
 319                 new = malloc(sizeof(*new));
 320                 *new = *seg;
 321                 seg->s_memsz = len;
 322                 new->s_memsz -= len;
 323                 new->s_addr += len;
 324                 new->s_offset += len;
 325                 if (seg->s_filesz > len) {
 326                         seg->s_filesz = len;
 327                         new->s_filesz -= len;
 328                 } else {
 329                         new->s_filesz = 0;
 330                 }
 331                 /* Order by stream offset */
 332                 new->next = seg->next;
 333                 new->prev = seg;
 334                 seg->next->prev = new;
 335                 seg->next = new;
 336                 /* Order by original program header order */
 337                 new->phdr_next = seg->phdr_next;
 338                 new->phdr_prev = seg;
 339                 seg->phdr_next->phdr_prev = new;
 340                 seg->phdr_next = new;
 341
 342                 /* compute the new value of end */
 343                 end = start + len;
 344
 345                 printk_spew("   late: [0x%016lx, 0x%016lx, 0x%016lx)\n",
 346                         new->s_addr,
 347                         new->s_addr + new->s_filesz,
 348                         new->s_addr + new->s_memsz);
 349
 350         }
 351         /* Now retarget this segment onto the bounce buffer */
 352         seg->s_addr = buffer + (seg->s_addr - lb_start);
 353
 354         printk_spew(" bounce: [0x%016lx, 0x%016lx, 0x%016lx)\n",
 355                 seg->s_addr,
 356                 seg->s_addr + seg->s_filesz,
 357                 seg->s_addr + seg->s_memsz);
 358 }
 359
 360
 361 static int build_elf_segment_list(
 362         struct segment *head,
 363         unsigned long bounce_buffer, struct lb_memory *mem,
 364         Elf_phdr *phdr, int headers)
 365 {
 366         struct segment *ptr;
 367         int i;
 368         memset(head, 0, sizeof(*head));
 369         head->phdr_next = head->phdr_prev = head;
 370         head->next = head->prev = head;
 371         for(i = 0; i < headers; i++) {
 372                 struct segment *new;
 373                 /* Ignore data that I don't need to handle */
 374                 if (phdr[i].p_type != PT_LOAD) {
 375                         printk_debug("Dropping non PT_LOAD segment\n");
 376                         continue;
 377                 }
 378                 if (phdr[i].p_memsz == 0) {
 379                         printk_debug("Dropping empty segment\n");
 380                         continue;
 381                 }
 382                 new = malloc(sizeof(*new));
 383                 new->s_addr = phdr[i].p_paddr;
 384                 new->s_memsz = phdr[i].p_memsz;
 385                 new->s_offset = phdr[i].p_offset;
 386                 new->s_filesz = phdr[i].p_filesz;
 387                 printk_debug("New segment addr 0x%lx size 0x%lx offset 0x%lx filesize 0x%lx\n",
 388                         new->s_addr, new->s_memsz, new->s_offset, new->s_filesz);
 389                 /* Clean up the values */
 390                 if (new->s_filesz > new->s_memsz)  {
 391                         new->s_filesz = new->s_memsz;
 392                 }
 393                 printk_debug("(cleaned up) New segment addr 0x%lx size 0x%lx offset 0x%lx filesize 0x%lx\n",
 394                         new->s_addr, new->s_memsz, new->s_offset, new->s_filesz);
 395                 for(ptr = head->next; ptr != head; ptr = ptr->next) {
 396                         if (new->s_offset < ptr->s_offset)
 397                                 break;
 398                 }
 399                 /* Order by stream offset */
 400                 new->next = ptr;
 401                 new->prev = ptr->prev;
 402                 ptr->prev->next = new;
 403                 ptr->prev = new;
 404                 /* Order by original program header order */
 405                 new->phdr_next = head;
 406                 new->phdr_prev = head->phdr_prev;
 407                 head->phdr_prev->phdr_next  = new;
 408                 head->phdr_prev = new;
 409
 410                 /* Verify the memory addresses in the segment are valid */
 411                 if (!valid_area(mem, bounce_buffer, new->s_addr, new->s_memsz))
 412                         goto out;
 413
 414                 /* Modify the segment to load onto the bounce_buffer if necessary.
 415                  */
 416                 relocate_segment(bounce_buffer, new);
 417         }
 418         return 1;
 419  out:
 420         return 0;
 421 }
 422
 423 static int load_elf_segments(
 424         struct segment *head, unsigned char *header, unsigned long header_size)
 425 {
 426         unsigned long offset;
 427         struct segment *ptr;
 428
 429         offset = 0;
 430         for(ptr = head->next; ptr != head; ptr = ptr->next) {
 431                 unsigned long start_offset;
 432                 unsigned long skip_bytes, read_bytes;
 433                 unsigned char *dest, *middle, *end;
 434                 byte_offset_t result;
 435                 printk_debug("Loading Segment: addr: 0x%016lx memsz: 0x%016lx filesz: 0x%016lx\n",
 436                         ptr->s_addr, ptr->s_memsz, ptr->s_filesz);
 437
 438                 /* Compute the boundaries of the segment */
 439                 dest = (unsigned char *)(ptr->s_addr);
 440                 end = dest + ptr->s_memsz;
 441                 middle = dest + ptr->s_filesz;
 442                 start_offset = ptr->s_offset;
 443
 444                 printk_spew("[ 0x%016lx, %016lx, 0x%016lx) <- %016lx\n",
 445                         (unsigned long)dest,
 446                         (unsigned long)middle,
 447                         (unsigned long)end,
 448                         (unsigned long)start_offset);
 449
 450                 /* Skip intial buffer unused bytes */
 451                 if (offset < header_size) {
 452                         if (start_offset < header_size) {
 453                                 offset = start_offset;
 454                         } else {
 455                                 offset = header_size;
 456                         }
 457                 }
 458
 459                 /* Skip the unused bytes */
 460                 skip_bytes = start_offset - offset;
 461                 if (skip_bytes &&
 462                         ((result = stream_skip(skip_bytes)) != skip_bytes)) {
 463                         printk_err("ERROR: Skip of %ld bytes skiped %ld bytes\n",
 464                                 skip_bytes, result);
 465                         goto out;
 466                 }
 467                 offset = start_offset;
 468
 469                 /* Copy data from the initial buffer */
 470                 if (offset < header_size) {
 471                         size_t len;
 472                         if ((ptr->s_filesz + start_offset) > header_size) {
 473                                 len = header_size - start_offset;
 474                         }
 475                         else {
 476                                 len = ptr->s_filesz;
 477                         }
 478                         memcpy(dest, &header[start_offset], len);
 479                         dest += len;
 480                 }
 481
 482                 /* Read the segment into memory */
 483                 read_bytes = middle - dest;
 484                 if (read_bytes &&
 485                         ((result = stream_read(dest, read_bytes)) != read_bytes)) {
 486                         printk_err("ERROR: Read of %ld bytes read %ld bytes...\n",
 487                                 read_bytes, result);
 488                         goto out;
 489                 }
 490                 offset += ptr->s_filesz;
 491
 492                 /* Zero the extra bytes between middle & end */
 493                 if (middle < end) {
 494                         printk_debug("Clearing Segment: addr: 0x%016lx memsz: 0x%016lx\n",
 495                                 (unsigned long)middle, end - middle);
 496
 497                         /* Zero the extra bytes */
 498                         memset(middle, 0, end - middle);
 499                 }
 500         }
 501         return 1;
 502  out:
 503         return 0;
 504 }
 505
 506 static int verify_loaded_image(
 507         struct verify_callback *vcb,
 508         Elf_ehdr *ehdr, Elf_phdr *phdr,
 509         struct segment *head
 510         )
 511 {
 512         struct segment *ptr;
 513         int ok;
 514         ok = 1;
 515         for(; ok && vcb ; vcb = vcb->next) {
 516                 /* Find where the note is loaded */
 517                 /* The whole note must be loaded intact
 518                  * so an address of 0 for the descriptor is impossible
 519                  */
 520                 vcb->desc_addr = 0;
 521                 for(ptr = head->next; ptr != head; ptr = ptr->next) {
 522                         unsigned long desc_addr;
 523                         desc_addr = ptr->s_addr + vcb->desc_offset - ptr->s_offset;
 524                         if ((desc_addr >= ptr->s_addr) &&
 525                                 (desc_addr < (ptr->s_addr + ptr->s_filesz))) {
 526                                 vcb->desc_addr = desc_addr;
 527                         }
 528                 }
 529                 ok = vcb->callback(vcb, ehdr, phdr, head);
 530         }
 531         return ok;
 532 }
 533
 534 int elfload(struct lb_memory *mem,
 535         unsigned char *header, unsigned long header_size)
 536 {
 537         Elf_ehdr *ehdr;
 538         Elf_phdr *phdr;
 539         void *entry;
 540         struct segment head;
 541         struct verify_callback *cb_chain;
 542         unsigned long bounce_buffer;
 543
 544         /* Find a bounce buffer so I can load to linuxBIOS's current location */
 545         bounce_buffer = get_bounce_buffer(mem);
 546         if (!bounce_buffer) {
 547                 printk_err("Could not find a bounce buffer...\n");
 548                 goto out;
 549         }
 550
 551         ehdr = (Elf_ehdr *)header;
 552         entry = (void *)(ehdr->e_entry);
 553         phdr = (Elf_phdr *)(&header[ehdr->e_phoff]);
 554
 555         /* Digest elf note information... */
 556         cb_chain = 0;
 557         if ((phdr[0].p_type == PT_NOTE) &&
 558                 ((phdr[0].p_offset + phdr[0].p_filesz) < header_size)) {
 559                 cb_chain = process_elf_notes(header,
 560                         phdr[0].p_offset, phdr[0].p_filesz);
 561         }
 562
 563         /* Preprocess the elf segments */
 564         if (!build_elf_segment_list(&head,
 565                 bounce_buffer, mem, phdr, ehdr->e_phnum))
 566                 goto out;
 567
 568         /* Load the segments */
 569         if (!load_elf_segments(&head, header, header_size))
 570                 goto out;
 571
 572         printk_spew("Loaded segments\n");
 573         /* Verify the loaded image */
 574         if (!verify_loaded_image(cb_chain, ehdr, phdr, &head))
 575                 goto out;
 576
 577         printk_spew("verified segments\n");
 578         /* Shutdown the stream device */
 579         stream_fini();
 580
 581         printk_spew("closed down stream\n");
 582         /* Reset to booting from this image as late as possible */
 583         boot_successful();
 584
 585         printk_debug("Jumping to boot code at 0x%x\n", entry);
 586         post_code(0xfe);
 587
 588         /* Jump to kernel */
 589         jmp_to_elf_entry(entry, bounce_buffer);
 590         return 1;
 591
 592  out:
 593         return 0;
 594 }
 595
 596 int elfboot(struct lb_memory *mem)
 597 {
 598         Elf_ehdr *ehdr;
 599         static unsigned char header[ELF_HEAD_SIZE];
 600         int header_offset;
 601         int i, result;
 602
 603         result = 0;
 604         printk_info("\n");
 605         printk_info("Welcome to %s, the open sourced starter.\n", BOOTLOADER);
 606         printk_info("January 2002, Eric Biederman.\n");
 607         printk_info("Version %s\n", BOOTLOADER_VERSION);
 608         printk_info("\n");
 609         post_code(0xf8);
 610
 611         if (stream_init() < 0) {
 612                 printk_err("Could not initialize driver...\n");
 613                 goto out;
 614         }
 615
 616         /* Read in the initial ELF_HEAD_SIZE bytes */
 617         if (stream_read(header, ELF_HEAD_SIZE) != ELF_HEAD_SIZE) {
 618                 printk_err("Read failed...\n");
 619                 goto out;
 620         }
 621         /* Scan for an elf header */
 622         header_offset = -1;
 623         for(i = 0; i < ELF_HEAD_SIZE - (sizeof(Elf_ehdr) + sizeof(Elf_phdr)); i+=16) {
 624                 ehdr = (Elf_ehdr *)(&header[i]);
 625                 if (memcmp(ehdr->e_ident, ELFMAG, 4) != 0) {
 626                         printk_spew("NO header at %d\n", i);
 627                         continue;
 628                 }
 629                 printk_debug("Found ELF candiate at offset %d\n", i);
 630                 /* Sanity check the elf header */
 631                 if ((ehdr->e_type == ET_EXEC) &&
 632                         elf_check_arch(ehdr) &&
 633                         (ehdr->e_ident[EI_VERSION] == EV_CURRENT) &&
 634                         (ehdr->e_version == EV_CURRENT) &&
 635                         (ehdr->e_ehsize == sizeof(Elf_ehdr)) &&
 636                         (ehdr->e_phentsize = sizeof(Elf_phdr)) &&
 637                         (ehdr->e_phoff < (ELF_HEAD_SIZE - i)) &&
 638                         ((ehdr->e_phoff + (ehdr->e_phentsize * ehdr->e_phnum)) <=
 639                                 (ELF_HEAD_SIZE - i))) {
 640                         header_offset = i;
 641                         break;
 642                 }
 643                 ehdr = 0;
 644         }
 645         printk_spew("header_offset is %d\n", header_offset);
 646         if (header_offset == -1) {
 647                 goto out;
 648         }
 649
 650         printk_spew("Try to load at offset 0x%x\n", header_offset);
 651         result = elfload(mem,
 652                 header + header_offset , ELF_HEAD_SIZE - header_offset);
 653  out:
 654         if (!result) {
 655                 /* Shutdown the stream device */
 656                 stream_fini();
 657
 658                 printk_err("Cannot Load ELF Image\n");
 659
 660                 post_code(0xff);
 661         }
 662         return 0;
 663
 664 }