WebSVN – QNX 8.QNX8 IFS tool – Diff – //ifstool.c

 static uint32_t image_align = 4; // default image alignment, as per QNX docs
 static uint32_t image_kernel_ino = 0;
 static uint32_t image_bootscript_ino = 0;
 static int startup_header_compression_flag = STARTUP_HDR_FLAGS1_COMPRESS_NONE;
 #if defined(__x86_64__)
-static char image_processor[16] = "x86_64"; // default CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)
+static char *image_processor = "x86_64"; // default CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)
-static char image_processor_base[16] = "x86_64"; // default base CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)
+static char *image_processor_base = "x86_64"; // default base CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)
+static size_t image_pagesize = 4 * 1024; // default page size for the image, depends on the CPU type. Intel has 4kb pages, ARM has 16kb ones.
 #elif defined(__aarch64__)
-static char image_processor[16] = "aarch64le"; // default CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)
+static char *image_processor = "aarch64le"; // default CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)
-static char image_processor_base[16] = "aarch64"; // default base CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)
+static char *image_processor_base = "aarch64"; // default base CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)
+static size_t image_pagesize = 16 * 1024; // default page size for the image, depends on the CPU type. Intel has 4kb pages, ARM has 16kb ones.
 #else // unknown platform
 #error Please port ifstool to this platform
 #endif
 static char *buildfile_pathname = NULL; // pathname of IFS build file
 static char *current_line = NULL; // copy of current line in IFS build file
 // bootable IFS support
 static char *bootfile_pathname = NULL;           // FIXME: HACK: pathname to bootcode binary blob file to put at the start of a bootable IFS
 static size_t bootfile_size = 0;                 // FIXME: HACK: size of the bootcode binary blob file to put at the start of a bootable IFS
 static char *startupfile_pathname = NULL;        // FIXME: HACK: pathname to precompiled startup file blob to put in the startup header of a bootable IFS
 static size_t startupfile_ep_from_imagebase = 0; // FIXME: HACK: startup code entrypoint offset from image base for a bootable IFS
-static size_t kernelfile_offset = 0x32000;       // kernel file offset in the IFS (is it ever supposed to change?)
+static size_t kernelfile_offset = 0;             // kernel file offset in the IFS (first offset rounded at pagesize after the dirents table)
 // exported function prototypes
 int32_t update_checksum (const void *data, const size_t data_len, const bool is_foreign_endianness); // compute an IFS image or startup checksum to store in the trailer
    size_t size_in_file;
    size_t file_offset;
    size_t array_index;
    size_t table_index;
    size_t table_count;
-   size_t page_size;
-   // find out the platform page size
-   if (ELF_GET_NUMERIC (ELFHDR, ELFHDR, instruction_set) == ELF_MACHINE_X86_64)
-      page_size = 4 * 1024; // 4 kb pages on Intel processors
-   else if (ELF_GET_NUMERIC (ELFHDR, ELFHDR, instruction_set) == ELF_MACHINE_AARCH64)
-      page_size = 16 * 1024; // 16 kb pages on ARM64
-   else
-   {
-      errno = ENOTSUP; // unsupported architecture: set errno to something meaningful
-      return (0); // and return an error value
-   }
    // if we should align the segment sizes in the ELF file with their occupied memory size (such is the case for e.g. procnto), do that first
    table_count = ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_len); // get the number of program headers
    for (table_index = 0; table_index < table_count; table_index++)
+   {
       if (ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_memory) > new_shdrtable_offset_method2)
          new_shdrtable_offset_method2 = ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_memory);
+   }
    if (new_shdrtable_offset_method2 > new_shdrtable_offset)
       LOG_DEBUG ("METHOD2: %llx > %llx", new_shdrtable_offset_method2, new_shdrtable_offset);*/
-   //new_shdrtable_offset = ROUND_TO_UPPER_MULTIPLE (new_shdrtable_offset, page_size); // round to page size
+   //new_shdrtable_offset = ROUND_TO_UPPER_MULTIPLE (new_shdrtable_offset, image_pagesize); // round to page size
    // re-create the section header table
    ADD_SECTION (".shstrtab", &elf_section); // the first section will be the section names strings table
    ASSERT_WITH_ERRNO (Buffer_InitWithByteArray (&elf_section->data, "\0")); // initialize an empty section headers strings table
    ASSERT_WITH_ERRNO (Buffer_AppendByteArray (&elf_section->data, ".shstrtab\0")); // append ".shstrtab" *INCLUDING* its null terminator
    ELF_SET_NUMERIC (ELFHDR, ELFHDR, section_header_table_offset, new_shdrtable_offset);
    ELF_SET_NUMERIC (ELFHDR, ELFHDR, section_header_table_len, new_shdrtable_len);
    ELF_SET_NUMERIC (ELFHDR, ELFHDR, section_header_names_idx, elf_section_count); // the section headers strings table is the last section
    // align size with page size (4096 on x86, 16k on ARM), zerofilling the extra space
-   ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (file, ROUND_TO_UPPER_MULTIPLE (file->size, page_size)));
+   ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (file, ROUND_TO_UPPER_MULTIPLE (file->size, image_pagesize)));
    // cleanup
    for (table_index = 0; table_index < elf_section_count; table_index++)
       Buffer_Forget (&elf_sections[table_index].data); // free all sections' backing buffers
             if ((bootfile_pathname == NULL) || (startupfile_pathname == NULL)) // FIXME: HACK until I figure out how to re-create them
                DIE_WITH_EXITCODE (1, "creating bootable images require the --bootfile and --startupfile command-line options in \"%s\" line %d", buildfile_pathname, lineno);
             if ((sep = strchr (value, ',')) != NULL) // do we have a comma separating (optional) processor and boot file name ?
+            {
                *sep = 0;
+               if (strcmp (value, "x86_64") == 0)
+               {
+                  image_processor = "x86_64"; // save processor
+                  image_processor_base = "x86_64"; // save processor base
+                  image_pagesize = 4 * 1024; // Intel processors use 4 Kb pages
+               }
+               else if (strcmp (value, "aarch64le") == 0)
+               {
-               strcpy_s (image_processor, sizeof (image_processor), value); // save processor
+                  image_processor = "aarch64le"; // save processor
+                  image_processor_base = "aarch64"; // save processor base
+                  image_pagesize = 16 * 1024; // ARM processors use 16 Kb pages
+               }
+               else
+                  DIE_WITH_EXITCODE (1, "unrecognized processor type in 'virtual' attribute in \"%s\" line %d: '%s'", buildfile_pathname, lineno, value);
                value = sep + 1;
+            }
             if (stat (bootfile_pathname, &stat_buf) != 0)
                DIE_WITH_EXITCODE (1, "unable to stat the boot file \"%s\" specified in \"%s\" line %d: %s", bootfile_pathname, buildfile_pathname, lineno, strerror (errno));
             bootfile_size = stat_buf.st_size; // save preboot file size
             else
+            {
                is_escaped_char = false; // any other char, meaning the next one will not be escaped
                if (!should_discard_inline_contents) // only store the contents if we do NOT know the data yet
+               {
-                  if (entry_parms.data.size == allocated_size) // reallocate in 4 kb blocks
+                  if (entry_parms.data.size == allocated_size) // reallocate in 16k blocks
+                  {
-                     reallocated_ptr = realloc (entry_parms.data.bytes, allocated_size + 4096);
+                     reallocated_ptr = realloc (entry_parms.data.bytes, allocated_size + 16384);
                      ASSERT_WITH_ERRNO (reallocated_ptr);
                      entry_parms.data.bytes = reallocated_ptr;
-                     allocated_size += 4096;
+                     allocated_size += 16384;
+                  }
                   entry_parms.data.bytes[entry_parms.data.size++] = read_char;
+               }
                if (read_char == '\n')
                   lineno++; // update line counter as we parse the inline content
    imgdir_size = ifs.data.size - ifs.offsets.imagedir; // measure image dir size and save it for future use
    // is it a bootable image with a startup file ?
    if (startupfile_pathname != NULL)
+   {
+      // compute the kernel offset: address of the first page that comes after the directory entries
+      kernelfile_offset = ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_pagesize);
       // write the filesystem entries that may fit before the kernel
       for (;;)
+      {
          available_space = kernelfile_offset - ifs.data.size; // measure the available space until the kernel
          if (startup_header_compression_flag == STARTUP_HDR_FLAGS1_COMPRESS_UCL)
+         {
             // UCL compression. NOTE: the decompressor function used in startup-x86 is "ucl_nrv2b_decompress_8". Also compression level is hardcoded at 9 in mkifs, but can range from 1 to 10
             static ucl_uint ucl_outlen; // have a different variable because of pointer size mismatch
             while (((compressor_ret = ucl_nrv2b_99_compress (compressor_in, (ucl_uint) compressor_inlen, compressor_out, &ucl_outlen, NULL, 9, NULL, NULL)) == UCL_E_OK) && (ucl_outlen > 0xFFFF))
-               compressor_inlen -= 4096; // as long as we can't produce compressed blocks whose size can fit in 2 bytes, try again with 4kb input less
+               compressor_inlen -= image_pagesize; // as long as we can't produce compressed blocks whose size can fit in 2 bytes, try again with one page input less
             ASSERT (compressor_ret == UCL_E_OK, "UCL compression error: ucl_nrv2b_99_compress() returned %d", compressor_ret); // make sure it's not a compression error
             compressor_outlen = ucl_outlen; // cast back to size_t
+         }
          else if (startup_header_compression_flag == STARTUP_HDR_FLAGS1_COMPRESS_LZO)
+         {
             // LZO compression. NOTE: the compressor function used in mkifs is "lzo1x_999_compress" which is from the full LZO package... I use use minilzo, but I have to admit the compression ratio of the full LZO is *much* better.
             static lzo_align_t lzo_workmem[(LZO1X_1_MEM_COMPRESS + (sizeof (lzo_align_t) - 1)) / sizeof(lzo_align_t)]; // heap-allocated aligned buffer
             static lzo_uint lzo_outlen; // have a different variable because of pointer size mismatch
             while (((compressor_ret = lzo1x_1_compress (compressor_in, compressor_inlen, compressor_out, &lzo_outlen, lzo_workmem)) == UCL_E_OK) && (lzo_outlen > 0xFFFF))
-               compressor_inlen -= 4096; // as long as we can't produce compressed blocks whose size can fit in 2 bytes, try again with 4kb input less
+               compressor_inlen -= image_pagesize; // as long as we can't produce compressed blocks whose size can fit in 2 bytes, try again with one page input less
             ASSERT (compressor_ret == LZO_E_OK, "LZO compression error: lzo1x_1_compress() returned %d", compressor_ret); // make sure it's not a compression error
             compressor_outlen = lzo_outlen; // cast back to size_t
+         }
          else if (startup_header_compression_flag == STARTUP_HDR_FLAGS1_COMPRESS_ZLIB)
+         {
             // Zlib (TODO)
+         }
          // the compression produced a block smaller than 65536 bytes
-         LOG_DEBUG ("compressed block size %zd", compressor_outlen);
+         //LOG_DEBUG ("compressed block size %zd", compressor_outlen);
          compressed_imagefs.bytes[compressed_imagefs.size + 0] = (uint8_t) (compressor_outlen >> 8); // write compressed block size word (in big endian)
          compressed_imagefs.bytes[compressed_imagefs.size + 1] = (uint8_t) (compressor_outlen >> 0);
          compressed_imagefs.size += 2 + (size_t) compressor_outlen; // advance in compression buffer by the compressed block size word plus the compressed block size
          remaining_len -= compressor_inlen; // see how many bytes remain to compress

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool//ifstool.c – Rev 26 → 30