Subversion Repositories QNX 8.QNX8 IFS tool

START_OF_PACKED_STRUCT () // we need byte-alignment for this struct

typedef PACKED (struct) uefi64_header_s // size 512 bytes

{

   PACKED (struct) dos_header_s // size 64 bytes

   {

      uint8_t signature[2]; // magic number, "MZ"

      uint16_t bytes_in_last_page; // number of bytes on last 512-byte page of file (144 in our case)

      uint16_t number_of_pages; // 512-byte pages in file (3 in our case, which is a minimum)

      uint16_t number_of_relocations; // relocations (zero in our case)

      uint16_t header_size_in_paragraphs; // Size of this header in 16-byte paragraphs (4, i.e. 64 / 16)

      uint16_t required_paragraphs; // minimum extra paragraphs needed (0)

      uint16_t requested_paragraphs; // maximum extra paragraphs needed (0xffff)

      uint16_t initial_relative_relocatable_segment_address_for_ss; // Initial (relative) SS value (zero)

      uint16_t initial_stack_pointer_value; // Initial SP value (0xb8 or 184 for use with our DOS stub program code)

      uint16_t unused_checksum; // checksum (zero). Normally, value to add to the sum of all other words in the file except this one to reach zero.

      uint16_t initial_instruction_pointer_value; // initial IP value (zero in our case)

      uint16_t initial_relative_relocatable_segment_address_for_cs; // initial (relative) CS value (zero)

      uint16_t absolute_offset_to_relocation_table; // file address of relocation table (typically just after this header, i.e. 0x40 or 64 decimal)

      uint16_t overlay_number; // overlay number (zero, i.e. this is the main executable)

      uint16_t reserved_words1[4]; // reserved words (zerofilled)

      uint16_t oem_identifier; // OEM identifier for e_oeminfo (zero)

      uint16_t oem_info; // OEM information, oem_identifier specific (zero)

      uint16_t reserved_words2[10]; // reserved words (zerofilled)

      uint32_t absolute_offset_to_pe_header; // file address of PE header (typically just after the DOS stub program bytes, i.e. 0x80 or 128 decimal)

   } dos_header;

   uint8_t dos_stub_bytes[64]; // DOS stub program bytes: "\x0E\x1F\xBA\x0E\x00\xB4\x09\xCD\x21\xB8\x01\x4C\xCD\x21" "This program cannot be run in DOS mode.\r\r\n" "\x24\x00\x00\x00\x00\x00\x00\x00"

   PACKED (struct) pe_header_s

   {

      uint8_t signature[4]; // magic value, "PE\0\0"

      uint16_t machine_type; // machine type (0x8664 for AMD64)

      uint16_t number_of_sections; // number of sections (1 in our case)

      uint32_t epoch_timestamp; // number of seconds since UNIX Epoch

      uint32_t offset_to_symbols_table; // offset to symbols table (zero)

      uint32_t number_of_symbols; // number of symbols in symbols table (zero)

      uint16_t size_of_optional_header; // size of optional header (typically 240)

      uint16_t characteristics_bitmap; // bitmapped PE characteristics (0x223, or 547 decimal = executable, uses large addresses, relocs stripped, debug info stripped)

   } pe_header;

   PACKED (struct) pe_image_optional_header64_s

   {

      uint8_t signature[2]; // magic value, "\x0b\x02"

      uint8_t linker_version_major; // major version of the Microsoft linker used to produce this file (zero in our case)

      uint8_t linker_version_minor; // minor version of the Microsoft linker used to produce this file (zero in our case)

      uint32_t code_size; // size of the code section, in bytes, or the sum of all such sections if there are multiple code sections (total size of IFS minus 512 bytes for the UEFI boot header, i.e. size of startup blob plus size of image)

      uint32_t size_of_initialized_data; // size of the initialized data section, in bytes, or the sum of all such sections if there are multiple initialized data sections (zero in our case)

      uint32_t size_of_uninitialized_data; // size of the uninitialized data section, in bytes, or the sum of all such sections if there are multiple uninitialized data sections (zero in our case)

      uint32_t entrypoint_address; // offset to the entry point function, relative to the image base address 

      uint32_t code_base; // offset to the beginning of the code section, relative to the image base (zero in our case)

      uint64_t image_base; // preferred address of the first byte of the image when it is loaded in memory, multiple of 64K bytes (512 * 65536, i.e. 0x2000000 in our case (FIXME: UNDERSTAND)

      uint32_t section_alignment; // alignment of sections loaded in memory in bytes ; must be greater than or equal to file_alignment, defaults to system page size (4096 for AMD64)

      uint32_t file_alignment; // alignment of the raw data of sections in the image file, in bytes ; should be a power of 2 between 512 and 64K (inclusive) corresponding I suppose to to the minimal supported underlying filesystem block size (mkifs sets 512 here)

      uint16_t os_version_major; // major version number of the required operating system (zero for UEFI)

      uint16_t os_version_minor; // minor version number of the required operating system (zero for UEFI)

      uint16_t image_version_major; // major version number of this image (mkifs sets zero here)

      uint16_t image_version_minor; // minor version number of this image (mkifs sets zero here)

      uint16_t subsystem_version_major; // major version number of the required subsystem (zero for UEFI)

      uint16_t subsystem_version_minor; // minor version number of the required subsystem (zero for UEFI)

      uint32_t win32_version_value; // Microsoft says: "reserved, must be zero" -- so be it

      uint32_t image_size; // total IFS file size

      uint32_t size_of_headers; // size of the UEFI boot header, must be a multiple of file_alignment (mkifs sets 512 here)

      uint32_t unused_checksum; // zero

      uint16_t subsystem_type; // image subsystem type (0x0a or 10 decimal i.e. IMAGE_SUBSYSTEM_EFI_APPLICATION)

      uint16_t dll_characteristics_bitmap; // bitmapped DLL characteristics (0 in our case)

      uint64_t stack_reserve_size; // maximal number of bytes to reserve (i.e. allocate on demand, one page at a time) for the stack (mkifs sets one system page here, i.e. 4096 for AMD64)

      uint64_t stack_commit_size; // number of bytes to commit (i.e. allocate at startup) for the stack (mkifs sets one system page here, i.e. 4096 for AMD64)

      uint64_t heap_reserve_size; // maximal number of bytes to reserve (i.e. allocate on demand, one page at a time) for the local heap (mkifs sets zero here)

      uint64_t heap_commit_size; // number of bytes to commit (i.e. allocate at startup) for the local heap (mkifs sets zero here)

      uint32_t unused_loader_flags; // zero

      uint32_t number_of_data_directories; // number of directory entries in the remainder of the optional header, each entry made of a location and a size (mkifs sets 16 directory entries)

      PACKED (struct) pe_image_data_directory_s

      {

         uint32_t virtual_address; // relative virtual address of the table

         uint32_t size; // size of the table, in bytes

      } data_directories[16]; // 16 directory entries (zerofilled)

   } optional_header64;

   PACKED (struct) pe_image_section_header_s

   {

      uint8_t section_name[8]; // section name, here "image\0\0\0"

      uint32_t virtual_size; // total size of the section when loaded into memory, in bytes ; same as pe_image_optional_header64.code_size

      uint32_t virtual_address; // address of the first byte of the section when loaded into memory, relative to the image base (first file_alignment multiple after pe_image_optional_header64.size_of_headers, i.e. 512 in our case)

      uint32_t rawdata_size; // size of the initialized data on disk in bytes, multiple of file_alignment (same as virtual_size in our case)

      uint32_t rawdata_offset; // offset to the first page within the COFF file (same as virtual_address in our case)

      uint32_t offset_to_relocations; // offset to the beginning of the relocation entries in this section (zero in our case)

      uint32_t offset_to_linenos; // offset to the beginning of the line-number entries in this section (zero in our case)

      uint16_t relocation_count; // number of relocation entries in this section (zero in our case)

      uint16_t lineno_count; // number of line number entries in this section (zero in our case)

      uint32_t characteristics_bitmap; // bitmapped PE section characteristics (0x60, or 96 decimal, for: image contains code, image contains initialized data)

   } unique_section;

   uint8_t trailing_padding[80]; // zerofill

} uefi64_header_t; // size 512 bytes

END_OF_PACKED_STRUCT () // restore default alignment

#define UEFI_DOS_STUB_PROGRAM_BYTES "\x0E\x1F\xBA\x0E\x00\xB4\x09\xCD\x21\xB8\x01\x4C\xCD\x21" "This program cannot be run in DOS mode.\r\r\n" "\x24\x00\x00\x00\x00\x00\x00\x00" // 64 bytes