Subversion Repositories QNX 8.QNX8 IFS tool

#ifndef IFSFILE_H

#define IFSFILE_H

#ifdef __cplusplus

extern "C" {

#endif

// standard C includes

#include <stdint.h>

#include <stdlib.h>

// compiler-specific glue

#ifdef _WIN32

#ifndef __BYTE_ORDER__

#define __ORDER_BIG_ENDIAN__    4321

#define __ORDER_LITTLE_ENDIAN__ 1234

#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__ // all Windows machines are little endian

#endif // !__BYTE_ORDER__

#ifndef __builtin_bswap64

#ifdef _MSC_VER

#define __builtin_bswap64(x) _byteswap_uint64 ((unsigned long long) (x))

#endif // _MSC_VER

#endif // !__builtin_bswap64

#ifndef __builtin_bswap32

#ifdef _MSC_VER

#define __builtin_bswap32(x) _byteswap_ulong ((unsigned long) (x))

#endif // _MSC_VER

#endif // !__builtin_bswap32

#ifndef __builtin_bswap16

#ifdef _MSC_VER

#define __builtin_bswap16(x) _byteswap_ushort ((unsigned short) (x))

#endif // _MSC_VER

#endif // !__builtin_bswap32

#endif // _WIN32

#ifdef _MSC_VER

#define START_OF_PACKED_STRUCT() __pragma(pack(push)) __pragma(pack(1))

#define END_OF_PACKED_STRUCT() __pragma(pack(pop))

#define PACKED(thing) thing

#else // !_MSC_VER

#define START_OF_PACKED_STRUCT()

#define END_OF_PACKED_STRUCT()

#define PACKED(thing) thing __attribute__((packed))

#endif // _MSC_VER

// bitmapped flags used in the flags1 member of the startup header

#define STARTUP_HDR_FLAGS1_VIRTUAL        (1 << 0)

#define STARTUP_HDR_FLAGS1_BIGENDIAN      (1 << 1)

#define STARTUP_HDR_FLAGS1_COMPRESS_NONE  ((0 << 4) | (0 << 3) | (0 << 2))

#define STARTUP_HDR_FLAGS1_COMPRESS_ZLIB  ((0 << 4) | (0 << 3) | (1 << 2)) // deprecated in mkifs

#define STARTUP_HDR_FLAGS1_COMPRESS_LZO   ((0 << 4) | (1 << 3) | (0 << 2)) // TODO: add this compression scheme with liblzo

#define STARTUP_HDR_FLAGS1_COMPRESS_UCL   ((0 << 4) | (1 << 3) | (1 << 2))

#define STARTUP_HDR_FLAGS1_COMPRESS_MASK  ((1 << 4) | (1 << 3) | (1 << 2))

#define STARTUP_HDR_FLAGS1_TRAILER_V2     (1 << 5) // if set, then a struct startup_trailer_v2 follows the startup. If the image is compressed, then the compressed imagefs is followed by a struct image_trailer_v2

// bitmapped flags used in the flags member of the image header

#define IMAGE_FLAGS_BIGENDIAN  (1 << 0) // header, trailer, dirents in big-endian format

#define IMAGE_FLAGS_READONLY   (1 << 1) // do not try to write to image (rom/flash)

#define IMAGE_FLAGS_INO_BITS   (1 << 2) // inode bits valid

#define IMAGE_FLAGS_SORTED     (1 << 3) // dirent section is sorted (by pathname)

#define IMAGE_FLAGS_TRAILER_V2 (1 << 4) // image uses struct image_trailer_v2

// bitmapped flags superposed to a filesystem entry's inode number

#define IFS_INO_PROCESSED_ELF (1 << 31)

#define IFS_INO_RUNONCE_ELF   (1 << 30)

#define IFS_INO_BOOTSTRAP_EXE (1 << 29)

// compiled boot script command types

#define SCRIPTCMD_TYPE_EXTERNAL        "\x00"

#define SCRIPTCMD_TYPE_WAITFOR         "\x01"

#define SCRIPTCMD_TYPE_REOPEN          "\x02"

#define SCRIPTCMD_TYPE_DISPLAY_MSG     "\x03"

#define SCRIPTCMD_TYPE_PROCMGR_SYMLINK "\x04"

#define SCRIPTCMD_TYPE_EXTSCHED_APS    "\x05"

// compiled boot script external command flags

#define SCRIPTCMD_FLAG_EXTSCHED   (1 << 0)

#define SCRIPTCMD_FLAG_SESSION    (1 << 1)

#define SCRIPTCMD_FLAG_SCHED_SET  (1 << 2)

#define SCRIPTCMD_FLAG_CPU_SET    (1 << 3)

#define SCRIPTCMD_FLAG_UNKNOWN1   (1 << 4) // ???

#define SCRIPTCMD_FLAG_BACKGROUND (1 << 5)

#define SCRIPTCMD_FLAG_KDEBUG     (1 << 6)

#define SCRIPTCMD_FLAG_UNKNOWN2   (1 << 7) // ???

// compiled boot script external command scheduling policies

#define SCRIPTCMD_SCHEDULERPOLICY_FIFO 1

#define SCRIPTCMD_SCHEDULERPOLICY_RR   2

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

typedef PACKED (struct) fsentry_s

{

   PACKED (struct) fsentry_header_s

   {

      uint16_t size; // size of dirent

      uint16_t extattr_offset; // if zero, no extattr data

      uint32_t ino; // if zero, skip entry

      uint32_t mode; // mode and perms of entry

      uint32_t gid;

      uint32_t uid;

      uint32_t mtime;

   } header;

   PACKED (union) fsentry_specific_u

   {

      PACKED (struct) fsentry_file_s // when (mode & S_IFMT) == S_IFREG

      {

         uint32_t offset; // offset from header

         uint32_t size;

         char *path; // null terminated path (no leading slash)

         uint8_t *UNSAVED_databuf; // file data blob buffer (convenience pointer, NOT SAVED IN THE IFS)

      } file;

      PACKED (struct) fsentry_dir_s // when (mode & S_IFMT) == S_IFDIR

      {

         char *path; // null terminated path (no leading slash)

      } dir;

      PACKED (struct) fsentry_symlink_s // when (mode & S_IFMT) == S_IFLNK

      {

         uint16_t sym_offset; // offset to 'contents' from 'path'

         uint16_t sym_size; // strlen (contents)

         char *path; // null terminated path (no leading slash)

         char *contents; // null terminated symlink contents

      } symlink;

      PACKED (struct) fsentry_device_s // when (mode & S_IFMT) == S_IF<CHR|BLK|FIFO|NAM|SOCK>

      {

         uint32_t dev;

         uint32_t rdev;

         char *path; // null terminated path (no leading slash)

      } device;

   } u;

   bool UNSAVED_was_data_written; // whether this entry's data was written to the image (convenience member, NOT SAVED IN THE IFS)

} fsentry_t;

END_OF_PACKED_STRUCT () // restore default alignment

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

typedef PACKED (struct) startup_header_s // size 256 bytes

{

   // I - used by the QNX IPL

   // S - used by the startup program

   uint8_t signature[4];   // [I ] Header signature, "\xeb\x7e\xff\x00"

   uint16_t version;       // [I ] Header version, i.e. 1

   uint8_t flags1;         // [IS] Misc flags, 0x21 (= 0x20 | STARTUP_HDR_FLAGS1_VIRTUAL)

   uint8_t flags2;         // [  ] No flags defined yet (0)

   uint16_t header_size;   // [ S] sizeof(struct startup_header), i.e. 256

   uint16_t machine;       // [IS] Machine type from elfdefinitions.h, i.e. 0x003E --> _ELF_DEFINE_EM(EM_X86_64, 62, "AMD x86-64 architecture")

   uint32_t startup_vaddr; // [I ] Virtual Address to transfer to after IPL is done, here 0x01403008 (appears in "Entry" column for "startup.*")

   uint32_t paddr_bias;    // [ S] Value to add to physical address to get a value to put into a pointer and indirected through, here 0 (no indirections)

   uint32_t image_paddr;   // [IS] Physical address of image, here 0x01400f30 (appears in "Offset" column for "startup-header" which is the first entry/start of file)

   uint32_t ram_paddr;     // [IS] Physical address of RAM to copy image to (startup_size bytes copied), here 0x01400f30 (same as above)

   uint32_t ram_size;      // [ S] Amount of RAM used by the startup program and executables contained in the file system, here 0x00cd6128 i.e. 13 459 752 dec. which is 13 Mb. i.e. IFS file size minus 0x9eee

   uint32_t startup_size;  // [I ] Size of startup (never compressed), here 0x02f148 or 192 840 bytes

   uint32_t stored_size;   // [I ] Size of entire image, here 0x00cd6128 (same as ram_size)

   uint32_t imagefs_paddr; // [IS] Set by IPL to where the imagefs is when startup runs (0)

   uint32_t imagefs_size;  // [ S] Size of uncompressed imagefs, here 0x00ca6fe0 or 13 266 912 bytes

   uint16_t preboot_size;  // [I ] Size of loaded before header, here 0xf30 or 3888 bytes (size of "bios.boot" file))

   uint16_t zero0;         // [  ] Zeros

   uint32_t zero[1];       // [  ] Zeros

   uint64_t addr_off;      // [ S] Offset to add to startup_vaddr, image_paddr, ram_paddr, and imagefs_paddr members, here zero (0)

   uint32_t info[48];      // [IS] Array of startup_info* structures (zero filled)

} startup_header_t;

END_OF_PACKED_STRUCT () // restore default alignment

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

typedef PACKED (struct) startup_trailer_s

{

   uint32_t cksum; // checksum from start of header to start of trailer

} startup_trailer_v1_t;

END_OF_PACKED_STRUCT () // restore default alignment

// NOTE: The checksums in this trailer will only be valid prior to entering startup.

// Because the startup binary is executed in-place, its data segment will change once the program is running.

// Hence, any checksum validation would need to be done by the boot loader / IFS.

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

typedef PACKED (struct) startup_trailer_v2_s

{

   uint8_t sha512[64]; // SHA512 from start of header to start of trailer

   uint32_t cksum; // checksum from start of header to start of this member

} startup_trailer_v2_t;

END_OF_PACKED_STRUCT () // restore default alignment

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

typedef PACKED (struct) image_header_s

{

   uint8_t signature[7]; // image filesystem signature, i.e. "imagefs"

   uint8_t flags; // endian neutral flags, 0x1c

   uint32_t image_size; // size from start of header to end of trailer (here 0xca6fe0 or 13 266 912)

   uint32_t hdr_dir_size; // size from start of header to last dirent (here 0x12b8 or 4792)

   uint32_t dir_offset; // offset from start of header to start of first dirent (here 0x5c or 92)

   uint32_t boot_ino[4]; // inode of files for bootstrap pgms (here 0xa0000002, 0, 0, 0)

   uint32_t script_ino; // inode of file for script (here 3)

   uint32_t chain_paddr; // offset to next filesystem signature (0)

   uint32_t spare[10]; // zerofill

   uint32_t mountflags; // default _MOUNT_* from sys/iomsg.h (0)

   char mountpoint[4]; // default mountpoint for image ("/" + "\0\0\0")

} image_header_t;

END_OF_PACKED_STRUCT () // restore default alignment

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

typedef PACKED (struct) image_trailer_v1_s

{

   uint32_t cksum; // checksum from start of header to start of trailer

} image_trailer_v1_t; // NOTE: this is the same structure as startup_trailer_v1_t

END_OF_PACKED_STRUCT () // restore default alignment

// NOTE: the checksums in this trailer will only be valid until the first non-startup bootstrap binary (e.g., startup-verifier, procnto, ...) is invoked.

// Because bootstrap binaries execute in-place, their data segments will change once the programs are running.

// Hence, any checksum validation would need to be done either by the boot loader / IFS or by the startup.

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

typedef PACKED (struct) image_trailer_v2_s

{

   uint8_t sha512[64]; // SHA512 from start of image header to start of trailer

   uint32_t cksum; // checksum from start of header to start of this member

} image_trailer_v2_t; // NOTE: this is the same structure as startup_trailer_v2_t

END_OF_PACKED_STRUCT () // restore default alignment

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

typedef PACKED (struct) bootargs_entry_s

{

   uint8_t size_lo; // includes entire structure

   uint8_t size_hi;

   uint8_t argc; // number of C-style strings that make up argv[] in args

   uint8_t envc; // number of C-style strings that make up envp[] in args after argv[]

   // if the actual startup header address cannot be represented in 32 bits, then shdr_addr is set to 0xFFFFFFFF and a uint64_t with the REAL shdr_address

   // immediately follows the last byte of the variable-length <args>. It will be included in the advertised <size_*> and is located at <bootargs_addr>+<size>-8

   uint32_t shdr_addr;

   //char *args; // variable length

} bootargs_entry_t;

END_OF_PACKED_STRUCT () // restore default alignment

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

// undefine the helpers we no longer need

#undef START_OF_PACKED_STRUCT

#undef END_OF_PACKED_STRUCT

#undef PACKED

#ifdef __cplusplus

}

#endif

#endif // IFSFILE_H