Subversion Repositories QNX 8.QNX8 IFS tool

#include "standard-types.hsl"

#pragma displayname("QNX Neutrino IFS in-kernel filesystem structures")

#pragma byteorder(little_endian)

// startup header (256 bytes)

typedef struct startup_header_s

{

                           // I - used by the QNX IPL

                           // S - used by the startup program

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

#pragma verify match_var_int("signature[0]", "0xeb")

#pragma verify match_var_int("signature[1]", "0x7e")

#pragma verify match_var_int("signature[2]", "0xff")

#pragma verify match_var_int("signature[3]", "0x00")

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

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

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

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

#pragma verify match_var_int("header_size", "256")

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

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

   unsigned __int32 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)

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

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

   unsigned __int32 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

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

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

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

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

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

   unsigned __int16 zero0;         // [  ] Zeros

   unsigned __int32 zero[1];       // [  ] Zeros

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

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

} startup_header;

// image header (92 bytes)

typedef struct image_header_s

{

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

#pragma verify match_var_int("signature[0]", "0x69")

#pragma verify match_var_int("signature[1]", "0x6d")

#pragma verify match_var_int("signature[2]", "0x61")

#pragma verify match_var_int("signature[3]", "0x67")

#pragma verify match_var_int("signature[4]", "0x65")

#pragma verify match_var_int("signature[5]", "0x66")

#pragma verify match_var_int("signature[6]", "0x73")

   unsigned __int8 flags; // endian neutral flags, 0x1c

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

   unsigned __int32 hdr_dir_size; // size from header to last dirent (here 0x12b8 or 4792)

   unsigned __int32 dir_offset; // offset from header to first dirent (here 0x5c or 92)

#pragma verify match_var_int("dir_offset", "92")

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

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

   unsigned __int32 chain_paddr; // offset to next filesystem signature (0)

   unsigned __int32 spare[10]; // zerofill

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

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

} image_header_t;

#pragma hide()

typedef struct fsentry_header_s

{

   unsigned __int16 size; // size of dirent

   unsigned __int16 extattr_offset; // if zero, no extattr data

   unsigned __int32 ino; // if zero, skip entry

   unsigned __int32 mode; // mode and perms of entry

   unsigned __int32 gid;

   unsigned __int32 uid;

   unsigned __int32 mtime;

} fsentry_header_t;

#pragma show()

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

{

   fsentry_header_t header;

__verify(((header.mode & 0x4000) == 0x4000) && ((header.mode & 0xa000) != 0xa000));

   char path[header.size - 24]; // null terminated path (no leading slash)

} fsentry_dir_t;

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

{

   fsentry_header_t header;

__verify(((header.mode & 0x8000) == 0x8000) && ((header.mode & 0xa000) != 0xa000));

   unsigned __int32 offset; // offset from header

   unsigned __int32 size;

   char path[header.size - 24 - 8]; // null terminated path (no leading slash)

} fsentry_file_t;

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

{

   fsentry_header_t header;

__verify((header.mode & 0xa000) == 0xa000);

   unsigned __int16 sym_offset;

   unsigned __int16 sym_size;

   char path_and_symlink[header.size - 24 - 4]; // null terminated path (no leading slash)

} fsentry_symlink_t;

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

{

   fsentry_header_t header;

__verify(((header.mode & 0x4000) != 0x4000) && ((header.mode & 0x8000) != 0x8000) && ((header.mode & 0xa000) != 0xa000));

   unsigned __int32 dev;

   unsigned __int32 rdev;

   char path[header.size - 24 - 8]; // null terminated path (no leading slash)

} fsentry_device_t;

typedef struct image_trailer_s

{

   unsigned __int32 cksum; // checksum from start of header to start of trailer

} image_trailer_t;

// Executable and Linkable Format master header structure type definition

typedef struct elf32_header_s

{

   unsigned char magic[4];                     // offset 0: "\x07" + "ELF"

   unsigned char platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit

   unsigned char endianness;                   // offset 5: 1 = little endian, 2 = big endian

   unsigned char header_version;               // offset 6: typically 1

   unsigned char os_abi;                       // offset 7: 0 = SysV, 1 = HP/UX, 2 = NetBSD, 3 = Linux, 4 = GNU/Hurd, 6 = Solaris, 7 = AIX, 8 = IRIX, 9 = FreeBSD, 10 = Tru64, 11 = Novell, 12 = OpenBSD, 13 = OpenVMS, 14 = NonStop kernel, 15 = AROS, 16 = FenixOS, 17 = Nuxi CloudABI, 18 = OpenVOS

   unsigned char spare[8];                     // offset 8: zeroes

   unsigned __int16 type;                        // offset 16: 1 = relocatable, 2 = executable, 3 = shared, 4 = core dump

   unsigned __int16 instruction_set;             // offset 18: 2 = Sparc, 3 = i386, 8 = MIPS, 20 = PowerPC, 40 = ARM, 42 = SuperH, 50 = IA-64, 62 = x86_64, 183 = AArch64, 243 = RISC-V

   unsigned __int32 elf_version;                 // offset 20: typically 1

   unsigned __int32 entrypoint_offset;           // offset 24: offset to program entrypoint

   unsigned __int32 program_header_table_offset; // offset 28: offset to program header table

   unsigned __int32 section_header_table_offset; // offset 32: offset to section header table

   unsigned __int32 flags;                       // offset 36: flags (architecture-dependent, none for x86)

   unsigned __int16 header_size;                 // offset 40: size of ELF header, 52 for 32-bit ELF and 64 for 64-bit ELF -- DO NOT USE sizeof() ON THE elf_header_s STRUCT BECAUSE OF THE UNION! WRITE THE CORRECT SIZE YOURSELF!

   unsigned __int16 program_header_item_size;    // offset 42: size of an entry in the program header table

   unsigned __int16 program_header_table_len;    // offset 44: number of entries in the program header table

   unsigned __int16 section_header_item_size;    // offset 46: size of an entry in the section header table

   unsigned __int16 section_header_table_len;    // offset 48: number of entries in the section header table

   unsigned __int16 section_header_names_idx;    // offset 50: index of the entry in the section header table that contains the section names

} elf32_header_t;

typedef struct elf64_header_s

      {

         unsigned char magic[4];                     // offset 0: "\x07" + "ELF"

         unsigned char platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit

         unsigned char endianness;                   // offset 5: 1 = little endian, 2 = big endian

         unsigned char header_version;               // offset 6: typically 1

         unsigned char os_abi;                       // offset 7: 0 = SysV, 1 = HP/UX, 2 = NetBSD, 3 = Linux, 4 = GNU/Hurd, 6 = Solaris, 7 = AIX, 8 = IRIX, 9 = FreeBSD, 10 = Tru64, 11 = Novell, 12 = OpenBSD, 13 = OpenVMS, 14 = NonStop kernel, 15 = AROS, 16 = FenixOS, 17 = Nuxi CloudABI, 18 = OpenVOS

         unsigned char spare[8];                     // offset 8: zeroes

         unsigned __int16 type;                        // offset 16: 1 = relocatable, 2 = executable, 3 = shared, 4 = core dump

         unsigned __int16 instruction_set;             // offset 18: 2 = Sparc, 3 = i386, 8 = MIPS, 20 = PowerPC, 40 = ARM, 42 = SuperH, 50 = IA-64, 62 = x86_64, 183 = AArch64, 243 = RISC-V

         unsigned __int32 elf_version;                 // offset 20: typically 1

         unsigned __int64 entrypoint_offset;           // offset 24: program entry offset

         unsigned __int64 program_header_table_offset; // offset 32: offset to program header table

         unsigned __int64 section_header_table_offset; // offset 40: offset to section header table

         unsigned __int32 flags;                       // offset 48: flags (architecture-dependent, none for x86)

         unsigned __int16 header_size;                 // offset 52: size of ELF header, 52 for 32-bit ELF and 64 for 64-bit ELF

         unsigned __int16 program_header_item_size;    // offset 54: size of an entry in the program header table

         unsigned __int16 program_header_table_len;    // offset 56: number of entries in the program header table

         unsigned __int16 section_header_item_size;    // offset 58: size of an entry in the section header table

         unsigned __int16 section_header_table_len;    // offset 60: number of entries in the section header table

         unsigned __int16 section_header_names_idx;    // offset 62: index of the entry in the section header table that contains the section names

} elf64_header_t;

// Executable and Linkable Format program header structure type definition

typedef struct elf32_program_header_s

{

         unsigned __int32 segment_type;   // offset 0: type of segment (0: unused table entry, 1: loadable, 2: dynamic linking information, 3: interpreter information, 4: auxiliary information, 5: reserved, 6: this very segment, 7: TLS template)

         unsigned __int32 file_offset;    // offset 4: file offset of this segment

         unsigned __int32 virtual_addr;   // offset 8: virtual address where this segment should be mapped in memory

         unsigned __int32 physical_addr;  // offset 12: on systems where this is relevant, PHYSICAL address where this segment should be mapped in memory

         unsigned __int32 size_in_file;   // offset 16: size of this segment in the ELF file (may be zero)

         unsigned __int32 size_in_memory; // offset 20: size of this segment in memory (may be zero)

         unsigned __int32 segment_flags;  // offset 24: bitmap of segment flags (1: executable, 2: writable, 4: readable)

         unsigned __int32 alignment;      // offset 28: memory alignment (0 or 1 mean non alignment, else must be a power of 2 where virtual_addr == file_offset % alignment)

      } elf32_program_header_t;

typedef struct elf64_program_header_s

{

         unsigned __int32 segment_type;   // offset 0: type of segment (0: unused table entry, 1: loadable, 2: dynamic linking information, 3: interpreter information, 4: auxiliary information, 5: reserved, 6: this very segment, 7: TLS template)

         unsigned __int32 segment_flags;  // offset 4: bitmap of segment flags (1: executable, 2: writable, 4: readable)

         unsigned __int64 file_offset;    // offset 8: file offset of this segment

         unsigned __int64 virtual_addr;   // offset 16: virtual address where this segment should be mapped in memory

         unsigned __int64 physical_addr;  // offset 24: on systems where this is relevant, PHYSICAL address where this segment should be mapped in memory

         unsigned __int64 size_in_file;   // offset 32: size of this segment in the ELF file (may be zero)

         unsigned __int64 size_in_memory; // offset 40: size of this segment in memory (may be zero)

         unsigned __int64 alignment;      // offset 48: memory alignment (0 or 1 mean non alignment, else must be a power of 2 where virtual_addr == file_offset % alignment)

      } elf64_program_header_t;

// Executable and Linkable Format section header structure type definition

typedef struct elf32_section_header_s

{

         unsigned __int32 name_offset;  // offset 0: offset in the string table of the name of this section

         unsigned __int32 type;         // offset 4:

         unsigned __int32 flags;        // offset 8:

         unsigned __int32 virtual_addr; // offset 12: address in virtual memory where this section may be loaded

         unsigned __int32 file_offset;  // offset 16: offset of this section in the ELF file

         unsigned __int32 size;         // offset 20: size of this section

         unsigned __int32 linked_index; // offset 24: optional section index of an associated section

         unsigned __int32 info;         // offset 28: optional extra information

         unsigned __int32 alignment;    // offset 32: required memory alignment (must be a power of 2)

         unsigned __int32 entry_size;   // offset 36: for table-like sections, size of an element in the table

      } elf32_section_header_t;

typedef struct elf64_section_header_s

      {

         unsigned __int32 name_offset;  // offset 0: offset in the string table of the name of this section

         unsigned __int32 type;         // offset 4:

         unsigned __int64 flags;        // offset 8:

         unsigned __int64 virtual_addr; // offset 16: address in virtual memory where this section may be loaded

         unsigned __int64 file_offset;  // offset 24: offset of this section in the ELF file

         unsigned __int64 size;         // offset 32: size of this section

         unsigned __int32 linked_index; // offset 40: optional section index of an associated section

         unsigned __int32 info;         // offset 44: optional extra information

         unsigned __int64 alignment;    // offset 48: required memory alignment (must be a power of 2)

         unsigned __int64 entry_size;   // offset 56: for table-like sections, size of an element in the table

      } elf64_section_header_t;

// Executable and Linkable Format dynamic section entry structure type definition

typedef struct elf32_dynamic_section_entry_s

{

         __int32 tag; // dynamic entry type (one of ELF_DT_xxx #defines)

         unsigned __int32 integer_or_pointer; // value as integer

      } elf32_dynamic_section_entry_t;

typedef struct elf32_dynamic_section_entry_s

{

         __int64 tag; // dynamic entry type (one of ELF_DT_xxx #defines)

         unsigned __int64 integer_or_pointer; // value as intege

      } elf64_dynamic_section_entry_t;