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

 static size_t saved_ELF_section_count = 0; // number of elements in the saved_ELF_sections array
 static char *sym_suffix = ""; // .sym files extra suffix, settable with the -a command-line argument
 // bootable IFS support
 static int boot_type = BOOTTYPE_NONE;
-static char *bootfile_pathname = NULL;           // FIXME: HACK: pathname to bootcode binary blob file to put at the start of a bootable IFS in BIOS mode
-static size_t bootfile_size = 0;                 // FIXME: HACK: size of the bootcode binary blob file to put at the start of a bootable IFS in BIOS mode
+static buffer_t boot_code    = { NULL, 0 };      // boot code (boot prefix) 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 buffer_t startup_code = { NULL, 0 };      // startup code to embed in the IFS between the boot prefix and the image header
 static size_t kernelfile_offset = 0;             // kernel file offset in the IFS (first offset rounded at pagesize after the dirents table)
+static size_t startup_bootargs_offset = 0;       // offset in the startup file to the boot args structure, so that it can be patched late
 static size_t procnto_bootargs_offset = 0;       // offset in the procnto file to the boot args structure, so that it can be patched late
+static parms_t startup_entry_parms; // copied from entry parms, so as to preserve the search path and whether to preserve linker output files
+static stringarray_t global_envp  = { NULL, 0 }; // global environment table from the startup block that applies to all executables (esp. startup and procnto)
+static stringarray_t startup_argv = { NULL, 0 }; // arguments table of the startup program
+static stringarray_t startup_envp = { NULL, 0 }; // environment table specific to the startup program
+static stringarray_t procnto_argv = { NULL, 0 }; // arguments table of the procnto kernel
+static stringarray_t procnto_envp = { NULL, 0 }; // environment table specific to the procnto kernel
 // 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
 static char *resolve_pathname (const char *pathname, const char *search_paths_or_NULL_for_MKIFS_PATH_envvar); // locates pathname among the known search paths and returns a pointer to the resolved pathname (static string)
 static elf_section_header_t *elf_get_section_header_by_name (const elf_header_t *elf, const char *section_name); // get a pointer to a named section header in an ELF file
 static size_t Buffer_WriteIFSDirectoryEntryAt (buffer_t *ifs_data, const size_t write_offset, const fsentry_t *fsentry); // writes the given filesystem entry (without its contents) to the IFS buffer
 static size_t Buffer_AppendIFSFileData (buffer_t *ifs_data, const fsentry_t *fsentry); // writes the given filesystem entry's file data (i.e. its contents) to the IFS buffer
 static int Buffer_StripELFFile (buffer_t *file, const char **saved_sections, const size_t saved_section_count, const bool should_align_segsize_with_ramsize, const char *indicative_pathname); // strips an ELF file buffer the way mkifs does it and returns whether it succeeded
+static void prelink (const char *search, const char *section_start_arg, const stringarray_t *exe_cmdline, const stringarray_t *exe_env, const bool should_keep_ld_output, buffer_t *out_buffer, size_t *bootargs_offset); // produces a prelinked version of a given executable mapped at the given address and stamped with the given arguments
 static void add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname); // stack up a new filesystem entry in the the fsentries array
 static void add_directory_contents_recursively (fsentry_t **fsentries, size_t *fsentry_count, const char *dir_pathname, const size_t start_pathname_len, parms_t *default_parms); // adds the contents of the directory pointed to by dir_pathname to the fsentries array, recursively
 static int fsentry_compare_pathnames_cb (const void *a, const void *b); // qsort() comparison callback that sorts filesystem entries by pathnames
 static void parse_line (FILE *buildfile_fp, char *line_buffer, fsentry_t **fsentries, size_t *fsentry_count, parms_t *default_parms); // parses a line in the build file and make the relevant changes to the fsentries array
    for (table_index = 0; table_index < elf_section_count; table_index++)
       Buffer_Forget (&elf_sections[table_index].data); // free all sections' backing buffers
    #undef ELFHDR // undefine the macro that used to always point to the ELF header at the beginning of the file
    return (1); // success
+}
+static void prelink (const char *search, const char *section_start_arg, const stringarray_t *exe_cmdline, const stringarray_t *exe_env, const bool should_keep_ld_output, buffer_t *out_buffer, size_t *bootargs_offset)
+{
+   static thread_local struct linker_s
+   {
+      char pathname[MAXPATHLEN];
+      char sysroot_arg[MAXPATHLEN];
+      char script_pathname_arg[MAXPATHLEN];
+   } linker = { "", "", "" };
+   static thread_local char buildhost_pathname[MAXPATHLEN] = "";
+   static thread_local char sym_filename[MAXPATHLEN] = "";
+   stringarray_t linker_argv = { NULL, 0 };
+   buffer_t bootargs_buffer = { 0 };
+   char *resolved_pathname;
+   char *exeargs_location;
+   void *reallocated_ptr;
+   size_t array_index;
+   // construct the arguments that are based on environment variables (infer QNX_HOST from QNX_TARGET)
+   if (linker.pathname[0] == 0)
+   {
+#if defined(_WIN32)
+      sprintf_s (linker.pathname, sizeof (linker.pathname), "%s/../../host/win64/x86_64/usr/bin/%s-ld" /*"-2.41.0"*/ ".exe", QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0")); // Win32: note the .exe extension
+#elif defined(__linux__)
+      sprintf_s (linker.pathname, sizeof (linker.pathname), "%s/../../host/linux/x86_64/usr/bin/%s-ld" /*"-2.41.0"*/, QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));
+#elif defined(__QNXNTO__)
+      sprintf_s (linker.pathname, sizeof (linker.pathname), "%s/../../host/qnx8/x86_64/usr/bin/%s-ld" /*"-2.41.0"*/, QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));
+#elif defined(__APPLE__) // why not!?
+      sprintf_s (linker.pathname, sizeof (linker.pathname), "%s/../../host/darwin/x86_64/usr/bin/%s-ld" /*"-2.41.0"*/, QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));
+#else // wtf are you building this on?
+#error Please port the GNU linker x86_64-pc-nto-qnx8.0.0-ld and aarch64-unknown-nto-qnx8.0.0-ld to your host architecture first before compiling ifstool.
+#endif
+      ASSERT (access (linker.pathname, 0) == 0, "host cross-linker for QNX8 \"%s\" not found", linker.pathname);
+      sprintf_s (linker.sysroot_arg, sizeof (linker.sysroot_arg), "--sysroot=%s/%s/", QNX_TARGET, image_processor);
+      sprintf_s (linker.script_pathname_arg, sizeof (linker.script_pathname_arg), "-T%s/%s/lib/nto.link", QNX_TARGET, image_processor);
+   }
+   resolved_pathname = resolve_pathname (exe_cmdline->args[0], search); // locate the executable location
+   ASSERT (resolved_pathname, "QNX startup \"%s\" not found in search path", exe_cmdline->args[0]);
+   strcpy_s (buildhost_pathname, sizeof (buildhost_pathname), resolved_pathname);
+   sprintf_s (sym_filename, sizeof (sym_filename), "%s.sym%s", exe_cmdline->args[0], sym_suffix);
+   // construct the linker invokation command-line arguments array (argv)
+   STRINGARRAY_INIT (&linker_argv);
+   STRINGARRAY_PUSH (&linker_argv, strrchr (linker.pathname, '/') + 1); // "${TARGET_TRIPLE}-ld"
+   STRINGARRAY_PUSH (&linker_argv, linker.sysroot_arg); // "--sysroot=${QNX_TARGET}/${TARGET_CPU}/"
+   STRINGARRAY_PUSH (&linker_argv, linker.script_pathname_arg); // "-T${QNX_TARGET}/${TARGET_CPU}/lib/nto.link"
+   STRINGARRAY_PUSH (&linker_argv, "--section-start");
+   STRINGARRAY_PUSH (&linker_argv, section_start_arg);
+   STRINGARRAY_PUSH (&linker_argv, "--no-relax");
+   STRINGARRAY_PUSH (&linker_argv, buildhost_pathname); // "${QNX_TARGET}/${TARGET_CPU}/boot/sys/startup-x86"
+   STRINGARRAY_PUSH (&linker_argv, "-o");
+   STRINGARRAY_PUSH (&linker_argv, sym_filename); // "startup-x86.sym"
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnonnull" // the GCC linter is wrong here: I *do* check for NULL before calling strdup()
+#endif // __GNUC__
+   STRINGARRAY_PUSH (&linker_argv, NULL); // don't forget to terminate the argv array with a NULL pointer
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif // __GNUC__
+   if (verbose_level > 2)
+   {
+      fprintf (stderr, "ifstool: calling:");
+      for (array_index = 0; array_index < linker_argv.count - 1; array_index++)
+         fprintf (stderr, " '%s'", linker_argv.args[array_index]);
+      fputc ('\n', stderr);
+   }
+#ifdef _WIN32
+   _spawnv (_P_WAIT, linker.pathname, linker_argv.args); // spawn the linker and produce a relinked startup (wait for completion)
+#else // !_WIN32, thus POSIX
+   do { // QNX does have spawnv(), but Linux does not. So let's stick to common POSIX ground, i.e. fork/exec/wait.
+      int status;
+      pid_t pid = fork (); // duplicate ourselves so as to create a new process
+      ASSERT_WITH_ERRNO (pid != -1);
+      if (pid == 0) // we are the child
+      {
+         execv (linker.pathname, linker_argv.args); // execute the linker and produce a relinked startup (wait for completion)
+         DIE_WITH_EXITCODE (1, "execve() failed"); // exec never returns
+      }
+      else // we are the parent
+         waitpid (pid, &status, 0); // wait for the child to finish
+   } while (0);
+#endif // _WIN32
+   STRINGARRAY_FREE (&linker_argv);
+   if (!Buffer_ReadFromFile (out_buffer, sym_filename)) // load the output file
+      DIE_WITH_EXITCODE (1, "the host cross-linker failed to produce a readable relinked \"%s\" startup: %s", sym_filename, strerror (errno));
+   if (!should_keep_ld_output)
+      unlink (sym_filename); // remove the linker output file if we want to
+   // save the boot arguments. The magic to look for is "ddpvbskr" -- whatever that means
+   if ((exeargs_location = Buffer_FindFirstByteArray (out_buffer, "ddpvbskr")) == NULL)
+      DIE_WITH_EXITCODE (1, "unable to find boot args location in the stripped \"%s\" startup", exe_cmdline->args[0]);
+   Buffer_InitWithSize (&bootargs_buffer, sizeof (bootargs_entry_t)); // prepare a boot args entry
+   ((bootargs_entry_t *) bootargs_buffer.bytes)->argc = (uint8_t) exe_cmdline->count;
+   ((bootargs_entry_t *) bootargs_buffer.bytes)->envc = (uint8_t) exe_env->count;
+   ((bootargs_entry_t *) bootargs_buffer.bytes)->shdr_addr = WILL_BE_FILLED_LATER; // same value as startup_header.image_paddr (which is not set yet) (TODO: support 64-bit shdr_addr offsets -- see comment in bootargs_entry_t struct)
+   for (array_index = 0; array_index < exe_cmdline->count; array_index++)
+      ASSERT_WITH_ERRNO (Buffer_Append (&bootargs_buffer, exe_cmdline->args[array_index], strlen (exe_cmdline->args[array_index]) + 1)); // append string including NUL terminator
+   for (array_index = 0; array_index < exe_env->count; array_index++)
+      ASSERT_WITH_ERRNO (Buffer_Append (&bootargs_buffer, exe_env->args[array_index], strlen (exe_env->args[array_index]) + 1)); // append string including NUL terminator
+   ((bootargs_entry_t *) bootargs_buffer.bytes)->size_hi = (uint8_t) ((bootargs_buffer.size >> 8) & 0xff);
+   ((bootargs_entry_t *) bootargs_buffer.bytes)->size_lo = (uint8_t) ((bootargs_buffer.size >> 0) & 0xff);
+   *bootargs_offset = (size_t) exeargs_location - (size_t) out_buffer->bytes; // compute the boot args offset
+   ASSERT_WITH_ERRNO (Buffer_WriteBufferAt (out_buffer, *bootargs_offset, &bootargs_buffer));
+   Buffer_Forget (&bootargs_buffer); // release the boot args buffer once it's written
+   return; // either we made it through, or we're dead
+}
 static void add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname)
+{
    static thread_local char *candidate_pathname = NULL;
    static thread_local parms_t default_parms = { 0 };
-   static thread_local stringarray_t global_envp = { NULL, 0 };
    static thread_local stringarray_t aps_partnames = { NULL, 0 };
    static int inode_count = 0; // will be preincremented each time this function is called
    typedef struct scriptcmd_s
+   {
    scriptcmd_t default_scriptcmd_params = { NULL, -1, false, -1, -1, -1, false, false, false };
    scriptcmd_t current_scriptcmd_params = { 0 };
    stringarray_t global_argv = { NULL, 0 };
    stringarray_t line_argv = { NULL, 0 };
    stringarray_t line_envp = { NULL, 0 };
-   stringarray_t startup_argv = { NULL, 0 };
-   stringarray_t startup_envp = { NULL, 0 };
-   stringarray_t procnto_argv = { NULL, 0 };
-   stringarray_t procnto_envp = { NULL, 0 };
-   stringarray_t linker_argv = { NULL, 0 };
+//   stringarray_t linker_argv = { NULL, 0 };
    const char *stored_pathname_without_leading_slash;
    const char *original_stored_pathname = NULL;
    const char *filename_bit;
    buffer_t current_line;
    buffer_t compiled_script;
+               {
                   startup_argv.args = line_argv.args; // relocate these pointers to the right place
                   startup_argv.count = line_argv.count;
                   startup_envp.args = line_envp.args; // relocate these pointers to the right place
                   startup_envp.count = line_envp.count;
+                  for (array_index = 0; array_index < global_envp.count; array_index++)
+                     STRINGARRAY_PUSH (&startup_envp, global_envp.args[array_index]); // concatenate the global environment to the executable environment
+               }
                else
+               {
                   STRINGARRAY_FREE (&procnto_argv); // if procnto's argv was already assigned, free the previous array as we'll be replacing it with a new one
                   procnto_argv.args = line_argv.args; // relocate these pointers to the right place
                   procnto_argv.count = line_argv.count;
                   STRINGARRAY_FREE (&procnto_envp); // if procnto's envp was already assigned, free the previous array as we'll be replacing it with a new one
                   procnto_envp.args = line_envp.args; // relocate these pointers to the right place
                   procnto_envp.count = line_envp.count;
+                  for (array_index = 0; array_index < global_envp.count; array_index++)
+                     STRINGARRAY_PUSH (&procnto_envp, global_envp.args[array_index]); // concatenate the global environment to the executable environment
+               }
                line_argv.args = NULL; // void the line_argv array so as to not free it as we stole its args pointers
                line_argv.count = 0;
                line_envp.args = NULL; // void the line_envp array so as to not free it as we stole its args pointers
                line_envp.count = 0;
          // now we know which startup and procnto executables to use
          LOG_DEBUG ("Startup: %s", startup_argv.args[0]);
          LOG_DEBUG ("Kernel: %s",  procnto_argv.args[0]);
-         static thread_local char linker_pathname[MAXPATHLEN] = "";
+         // prelink procnto, map its .text segment at the right virtual address for the IFS and stamp in its executable arguments
-         static thread_local char linker_sysroot_arg[MAXPATHLEN] = "";
+         // then store the result in this entry's data blob
-         static thread_local char linker_script_pathname_arg[MAXPATHLEN] = "";
+         prelink (entry_parms->search, // binary executable search path
+                  (boot_type == BOOTTYPE_UEFI ? ".text=0xffff800000002000" : ".text=0xffff800000001000"), // FIXME: wild assumption!
-         static thread_local char procnto_buildhost_pathname[MAXPATHLEN] = "";
+                  &procnto_argv, &procnto_envp, // executable arguments (including its name) and environment to stamp in it
-         static thread_local char procnto_sym_filename[MAXPATHLEN] = "";
+                  entry_parms->should_keep_ld_output, // whether to keep the linker-produced output file
-         buffer_t bootargs_buffer = { 0 };
+                  &entry_parms->data, // buffer where to save the output
-         void *bootargs_location;
+                  &procnto_bootargs_offset); // where to save the offset of the boot arguments
-         // construct the arguments that are based on environment variables (infer QNX_HOST from QNX_TARGET)
-#if defined(_WIN32)
-         sprintf_s (linker_pathname, sizeof (linker_pathname), "%s/../../host/win64/x86_64/usr/bin/%s-ld" /*"-2.41.0"*/ ".exe", QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0")); // Win32: note the .exe extension
-#elif defined(__linux__)
-         sprintf_s (linker_pathname, sizeof (linker_pathname), "%s/../../host/linux/x86_64/usr/bin/%s-ld" /*"-2.41.0"*/, QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));
-#elif defined(__QNXNTO__)
-         sprintf_s (linker_pathname, sizeof (linker_pathname), "%s/../../host/qnx8/x86_64/usr/bin/%s-ld" /*"-2.41.0"*/, QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));
-#elif defined(__APPLE__) // why not!?
-         sprintf_s (linker_pathname, sizeof (linker_pathname), "%s/../../host/darwin/x86_64/usr/bin/%s-ld" /*"-2.41.0"*/, QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));
-#else // wtf are you building this on?
-#error Please port the GNU linker x86_64-pc-nto-qnx8.0.0-ld and aarch64-unknown-nto-qnx8.0.0-ld to your host architecture first before compiling ifstool.
-#endif
-         ASSERT (access (linker_pathname, 0) == 0, "host cross-linker for QNX8 \"%s\" not found", linker_pathname);
-         sprintf_s (linker_sysroot_arg, sizeof (linker_sysroot_arg), "--sysroot=%s/%s/", QNX_TARGET, image_processor);
-         sprintf_s (linker_script_pathname_arg, sizeof (linker_script_pathname_arg), "-T%s/%s/lib/nto.link", QNX_TARGET, image_processor);
-         resolved_pathname = resolve_pathname (procnto_argv.args[0], entry_parms->search); // locate the procnto kernel location
-         ASSERT (resolved_pathname, "QNX kernel \"%s\" not found in search path", procnto_argv.args[0]);
-         strcpy_s (procnto_buildhost_pathname, sizeof (procnto_buildhost_pathname), resolved_pathname);
-         sprintf_s (procnto_sym_filename, sizeof (procnto_sym_filename), "%s.sym%s", procnto_argv.args[0], sym_suffix);
-         // construct the linker invokation command-line arguments array (argv)
-         STRINGARRAY_INIT (&linker_argv);
-         STRINGARRAY_PUSH (&linker_argv, strrchr (linker_pathname, '/') + 1); // "${TARGET_TRIPLE}-ld"
-         STRINGARRAY_PUSH (&linker_argv, linker_sysroot_arg); // "--sysroot=${QNX_TARGET}/${TARGET_CPU}/"
-         STRINGARRAY_PUSH (&linker_argv, linker_script_pathname_arg); // "-T${QNX_TARGET}/${TARGET_CPU}/lib/nto.link"
-         STRINGARRAY_PUSH (&linker_argv, "--section-start");
-         STRINGARRAY_PUSH (&linker_argv, (boot_type == BOOTTYPE_UEFI ? ".text=0xffff800000002000" : ".text=0xffff800000001000")); // FIXME: wild assumption!
-         STRINGARRAY_PUSH (&linker_argv, "--no-relax");
-         STRINGARRAY_PUSH (&linker_argv, procnto_buildhost_pathname); // "${QNX_TARGET}/${TARGET_CPU}/boot/sys/procnto-smp-instr"
-         STRINGARRAY_PUSH (&linker_argv, "-o");
-         STRINGARRAY_PUSH (&linker_argv, procnto_sym_filename); // "procnto-smp-instr.sym"
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wnonnull" // the GCC linter is wrong here: I *do* check for NULL before calling strdup()
-#endif // __GNUC__
-         STRINGARRAY_PUSH (&linker_argv, NULL); // don't forget to terminate the argv array with a NULL pointer
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif // __GNUC__
-         if (verbose_level > 2)
-         {
-            fprintf (stderr, "ifstool: calling:");
-            for (array_index = 0; array_index < linker_argv.count - 1; array_index++)
-               fprintf (stderr, " '%s'", linker_argv.args[array_index]);
-            fputc ('\n', stderr);
-         }
-#ifdef _WIN32
-         _spawnv (_P_WAIT, linker_pathname, linker_argv.args); // spawn the linker and produce a stripped procnto (wait for completion)
-#else // !_WIN32, thus POSIX
-         do { // QNX does have spawnv(), but Linux does not. So let's stick to common POSIX ground, i.e. fork/exec/wait.
-            int status;
-            pid_t pid = fork (); // duplicate ourselves so as to create a new process
-            ASSERT_WITH_ERRNO (pid != -1);
-            if (pid == 0) // we are the child
-            {
-               execv (linker_pathname, linker_argv.args); // execute the linker and produce a stripped procnto (wait for completion)
-               DIE_WITH_EXITCODE (1, "execve() failed"); // exec never returns
-            }
-            else // we are the parent
-               waitpid (pid, &status, 0); // wait for the child to finish
-         } while (0);
-#endif // _WIN32
-         STRINGARRAY_FREE (&linker_argv);
-         if (!Buffer_ReadFromFile (&entry_parms->data, procnto_sym_filename)) // load the output file
-            DIE_WITH_EXITCODE (1, "the host cross-linker failed to produce a readable stripped \"%s\" kernel: %s", procnto_sym_filename, strerror (errno));
-         if (!entry_parms->should_keep_ld_output)
-            unlink (procnto_sym_filename); // remove the linker output file if we want to
-         // strip this prelinked ELF kernel file from all the sections we don't need
+         // strip this prelinked ELF file from all the sections we don't need
-         ASSERT_WITH_ERRNO (Buffer_StripELFFile (&entry_parms->data, (const char **) saved_ELF_sections, 1, true, stored_pathname)); // strip the ELF file as per QNX docs (only keep ONE section, which is "QNX_info", and align the segment size in file with the size it occupies in memory)
+         ASSERT_WITH_ERRNO (Buffer_StripELFFile (&entry_parms->data, NULL, 0, true, procnto_argv.args[0])); // strip procnto as per QNX docs (align the segment size in file with the size it occupies in memory)
-         // save the boot arguments. The magic to look for is "ddpvbskr" -- whatever that means
-         if ((bootargs_location = Buffer_FindFirstByteArray (&entry_parms->data, "ddpvbskr")) == NULL)
-            DIE_WITH_EXITCODE (1, "unable to find boot args location in the stripped \"%s\" kernel", stored_pathname);
-         Buffer_InitWithSize (&bootargs_buffer, sizeof (bootargs_entry_t)); // prepare a boot args entry
-         ((bootargs_entry_t *) bootargs_buffer.bytes)->argc = (uint8_t) procnto_argv.count;
-         ((bootargs_entry_t *) bootargs_buffer.bytes)->envc = (uint8_t) (global_envp.count + procnto_envp.count);
-         ((bootargs_entry_t *) bootargs_buffer.bytes)->shdr_addr = WILL_BE_FILLED_LATER; // same value as startup_header.image_paddr (which is not set yet) (TODO: support 64-bit shdr_addr offsets -- see comment in bootargs_entry_t struct)
-         for (array_index = 0; array_index < procnto_argv.count; array_index++)
-            ASSERT_WITH_ERRNO (Buffer_Append (&bootargs_buffer, procnto_argv.args[array_index], strlen (procnto_argv.args[array_index]) + 1)); // append string including NUL terminator
-         for (array_index = 0; array_index < global_envp.count; array_index++)
-            ASSERT_WITH_ERRNO (Buffer_Append (&bootargs_buffer, global_envp.args[array_index], strlen (global_envp.args[array_index]) + 1)); // append string including NUL terminator
-         for (array_index = 0; array_index < procnto_envp.count; array_index++)
-            ASSERT_WITH_ERRNO (Buffer_Append (&bootargs_buffer, procnto_envp.args[array_index], strlen (procnto_envp.args[array_index]) + 1)); // append string including NUL terminator
-         ((bootargs_entry_t *) bootargs_buffer.bytes)->size_hi = (uint8_t) ((bootargs_buffer.size >> 8) & 0xff);
-         ((bootargs_entry_t *) bootargs_buffer.bytes)->size_lo = (uint8_t) ((bootargs_buffer.size >> 0) & 0xff);
-         procnto_bootargs_offset = (size_t) bootargs_location - (size_t) entry_parms->data.bytes; // save the boot args offset so that the section header address in it can be patched late
-         ASSERT_WITH_ERRNO (Buffer_WriteBufferAt (&entry_parms->data, procnto_bootargs_offset, &bootargs_buffer));
-         Buffer_Forget (&bootargs_buffer); // release the boot args buffer once it's written
          sprintf_s (candidate_pathname, MAXPATHLEN, "%s/%s", (entry_parms->prefix != NULL ? entry_parms->prefix : ""), procnto_argv.args[0]); // fix the entry name
          stored_pathname = candidate_pathname;
          entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE; // mark this inode as a preprocessed *bootstrap* ELF file
          entry_parms->st_mode = S_IFREG | entry_parms->perms; // procnto is a regular file
          image_kernel_ino = entry_parms->extra_ino_flags | (inode_count + 1);
+         memcpy (&startup_entry_parms, entry_parms, sizeof (parms_t)); // backup the startup entry parameters
          STRINGARRAY_FREE (&procnto_argv); // release procnto's argv array
          STRINGARRAY_FREE (&procnto_envp); // release procnto's envp array
          //STRINGARRAY_FREE (&global_envp); // DO NOT release the global envp array. It is inherited by the boot scripts.
       } // end of "is bootstrap file"
       else if (entry_parms->is_compiled_bootscript) // [+script]
+      {
          image_bootscript_ino = inode_count + 1; // save boot script inode number for image header
          Buffer_Initialize (&compiled_script);
    thread_local static parms_t entry_parms = { 0 }; // current parameters for a filesystem entry (will be initialized to default_parms each time a new entry is parsed in the build file)
    bool should_discard_inline_contents;
    bool is_quoted_context;
    bool is_escaped_char;
-   struct stat stat_buf;
    struct tm utc_time;
    void *reallocated_ptr;
    size_t allocated_size;
    size_t string_len;
    char *attrblock_start;
                   DIE_WITH_EXITCODE (1, "unrecognized processor type in 'virtual' attribute in \"%s\" line %d: '%s'", buildfile_pathname, lineno, value);
                value = sep + 1;
+            }
             boot_type = (strstr (value, "uefi") != NULL ? BOOTTYPE_UEFI : BOOTTYPE_BIOS); // FIXME: this should be a boot FILE, not a hardcoded tag
             if (boot_type == BOOTTYPE_UEFI)
-            {
-               if (startupfile_pathname == NULL) // FIXME: HACK until I figure out how to re-create it
-                  DIE_WITH_EXITCODE (1, "creating bootable UEFI images requires the --startupfile command-line option in \"%s\" line %d", buildfile_pathname, lineno);
-               bootfile_size = ROUND_TO_UPPER_MULTIPLE (sizeof (uefi64_header_t), 512); // round to upper filesystem block (PE header constraint)
                LOG_INFO ("processor \"%s\" bootfile <generated, UEFI>\n", image_processor);
-            }
             else
-            {
-               if ((bootfile_pathname == NULL) || (startupfile_pathname == NULL)) // FIXME: HACK until I figure out how to re-create them
-                  DIE_WITH_EXITCODE (1, "creating bootable BIOS images requires the --bootfile and --startupfile command-line options in \"%s\" line %d", buildfile_pathname, lineno);
-               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
-               LOG_INFO ("processor \"%s\" bootfile \"%s\"\n", image_processor, bootfile_pathname);
+               LOG_INFO ("processor \"%s\" bootfile <boot.bios, BIOS>\n", image_processor);
-            }
             entry_parms.is_bootstrap_file = true;
+         }
          else if (strncmp (token, "mtime=", 6) == 0) { REACH_TOKEN_VALUE (); if (strcmp (value, "*") == 0) entry_parms.mtime = UINT32_MAX; else {
                // value *must* be "YYYY-MM-DD-HH:MM:SS" by specification
                memset (&utc_time, 0, sizeof (utc_time));
       .should_follow_symlinks = true, // [+|-followlink]
       .should_autosymlink_dylib = true, // [+|-autolink]
    };
    parms_t entry_parms = { 0 }; // current parameters for a filesystem entry (will be initialized to default_parms each time a new entry is parsed in the build file)
+   char textbase_mapaddr_string[64];
+   elf_program_header_t *phdr = NULL;
    uefi64_header_t *uefi_header = NULL;
    char path_on_buildhost[MAXPATHLEN] = "";
    char path_in_ifs[MAXPATHLEN] = "";
    const char *ifs_pathname = NULL;
    const char *rootdir_pathname = NULL;
    const fsentry_t *fsentry;
    void *reallocated_ptr;
    buffer_t compressed_imagefs;
-   buffer_t opaqueblob_file;
    uint8_t *compressor_out;
    uint8_t *compressor_in;
+   uint8_t *bootcode_start;
+   size_t program_header_table_count;
+   size_t cumulated_segment_length;
+   size_t minimal_padded_length;
+   size_t first_segment_offset;
    size_t compressor_outlen;
    size_t compressor_inlen;
    size_t reallocated_size;
    size_t available_space;
    size_t fsentry_index;
    size_t largest_index;
    size_t largest_size;
    size_t imgdir_size;
    size_t curr_offset;
+   size_t table_index;
    size_t remaining_len;
    ifs_t ifs = { 0 };
    int32_t checksum;
+   char *resolved_pathname;
    char *first_pathname = NULL;
    char *second_pathname = NULL;
    char *third_pathname = NULL;
-   char *sep;
    int arg_index;
    bool is_quoted_context = false;
    bool is_escaped_char = false;
    bool should_discard_inline_contents = false;
    bool want_info = false;
    ASSERT_WITH_ERRNO (default_parms.prefix);
    // parse arguments
    for (arg_index = 1; arg_index < argc; arg_index++)
+   {
-      if ((strcmp (argv[arg_index], "--bootfile") == 0) && (arg_index + 1 < argc)) // --bootfile path/to/blob.bin
-         bootfile_pathname = argv[++arg_index];
-      else if ((strcmp (argv[arg_index], "--startupfile") == 0) && (arg_index + 1 < argc)) // --startupfile path/to/blob.bin@0x1030
-      {
-         sep = strchr (argv[++arg_index], '@');
-         if ((sep == NULL) || (sep[1] == 0))
-            DIE_WITH_EXITCODE (1, "the --startupfile arguments expects <pathname>@<entrypoint_from_image_base>");
-         *sep = 0;
-         startupfile_pathname = argv[arg_index];
-         startupfile_ep_from_imagebase = (size_t) read_integer (sep + 1, 0);
-      }
-      else if ((strcmp (argv[arg_index], "-a") == 0) && (arg_index + 1 < argc)) // -a suffix
+      if ((strcmp (argv[arg_index], "-a") == 0) && (arg_index + 1 < argc)) // -a suffix
          sym_suffix = argv[++arg_index];
       else if (strcmp (argv[arg_index], "-n") == 0)
          default_parms.mtime_for_inline_files = 0; // inline files should have a mtime set to zero
       else if (strcmp (argv[arg_index], "-nn") == 0)
+      {
       fprintf (out, "    ifstool --info [--everything] [--hide-filename] <ifs file>\n");
       fprintf (out, "    ifstool --dump [--outdir <path>] <ifs file>\n");
       fprintf (out, "    ifstool --strip [--outfile <pathname>] <ELF file>\n");
       fprintf (out, "    ifstool [-?|--help]\n");
       // mkifs [-?] [-l inputline] [-n[n]] [-o directory] [-p patchfile] [-r rootdir] [-s section] [-v] [buildfile] [directory] [outputfile]
-      fprintf (out, "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kerneloffs <fileoffs>] [-a suffix] [-l inputline] [-n[n]] [-r rootdir] [-s section] [-v[...]] [buildfile] [directory] [outputfile]\n");
+      fprintf (out, "    ifstool [-a suffix] [-l inputline] [-n[n]] [-r rootdir] [-s section] [-v[...]] [buildfile] [directory] [outputfile]\n");
       fprintf (out, "NOTE: the compiler mode requires predigested boot and startup files produced by mkifs.\n");
       fprintf (out, "options:\n");
       fprintf (out, "    -?       Display some help information.\n");
       fprintf (out, "    -a .ext  Append a suffix to symbol files generated via [+keeplinked].\n");
       fprintf (out, "    -l line  Process line before interpreting the buildfile. Input lines given\n");
    // start constructing the IFS file
    Buffer_Initialize (&ifs.data);
    // do we have a startup file ? if so, this is a bootable image
-   if (startupfile_pathname != NULL)
+   if (startup_argv.count > 0)
+   {
       // write boot prefix
       if (boot_type == BOOTTYPE_UEFI) // UEFI boot
+      {
+         boot_code.size = ROUND_TO_UPPER_MULTIPLE (sizeof (uefi64_header_t), 512); // round to upper filesystem block (PE header constraint)
          ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, sizeof (uefi64_header_t))); // start by writing an empty UEFI header
          uefi_header = (uefi64_header_t *) ifs.data.bytes; // have a convenience pointer
          memcpy (&uefi_header->dos_header.signature, "MZ", 2); // store the MZ magic
          uefi_header->dos_header.bytes_in_last_page = 144; // fixed value
          uefi_header->dos_header.number_of_pages = 3; // fixed value
          uefi_header->pe_header.epoch_timestamp = (uint32_t) time (NULL); // store timestamp (NOTE: mkifs doesn't obey its -nn arguments here, so neither shall we)
          uefi_header->pe_header.size_of_optional_header = sizeof (uefi_header->optional_header64); // 240 bytes
          uefi_header->pe_header.characteristics_bitmap = 0x0223; // store characteristics bitmap (executable, uses large addresses, relocs stripped, debug info stripped)
          memcpy (uefi_header->optional_header64.signature, "\x0b\x02", 2); // store the 64-bit optional header magic
          uefi_header->optional_header64.code_size = WILL_BE_FILLED_LATER; // total size of IFS minus 512 bytes for the UEFI boot header, i.e. size of startup blob plus size of image
-         uefi_header->optional_header64.entrypoint_address = (uint32_t) startupfile_ep_from_imagebase;
+         uefi_header->optional_header64.entrypoint_address = WILL_BE_FILLED_LATER;
          uefi_header->optional_header64.image_base = image_base;
          uefi_header->optional_header64.section_alignment = (uint32_t) image_pagesize;
          uefi_header->optional_header64.file_alignment = 512; // i.e. one filesystem block
          uefi_header->optional_header64.image_size = WILL_BE_FILLED_LATER; // total IFS file size
-         uefi_header->optional_header64.size_of_headers = (uint32_t) bootfile_size;
+         uefi_header->optional_header64.size_of_headers = (uint32_t) boot_code.size;
          uefi_header->optional_header64.subsystem_type = 10; // IMAGE_SUBSYSTEM_EFI_APPLICATION
          uefi_header->optional_header64.stack_reserve_size = image_pagesize;
          uefi_header->optional_header64.stack_commit_size = image_pagesize;
          uefi_header->optional_header64.number_of_data_directories = 16; // mkifs reserves 16 data directories, filled with zeroes (FIXME: why?)
          memcpy (uefi_header->unique_section.section_name, "image\0\0\0", 8); // store the unique section name
          uefi_header->unique_section.characteristics_bitmap = 0x60; // image contains code + image contains initialized data
          ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, uefi_header->optional_header64.size_of_headers)); // pad as necessary
+      }
       else // BIOS boot
+      {
+         // resolve the "bios.boot" file
-         // ######################################################################################################################################################################################################################################
+         resolved_pathname = resolve_pathname ("bios.boot", startup_entry_parms.search); // locate the executable location
-         // # FIXME: figure out how mkifs produces the boot prefix out of the BIOS "boot file" here
+         ASSERT (resolved_pathname, "QNX BIOS boot \"bios.boot\" not found in search path");
+         ASSERT_WITH_ERRNO (Buffer_ReadFromFile (&boot_code, resolved_pathname)); // load it
+         // isolate its first segment
+         #define ELFHDR ((elf_header_t *) boot_code.bytes) // this convenient definition will make sure the ELF header points at the right location
-         // ######################################################################################################################################################################################################################################
+         phdr = (elf_program_header_t *) &boot_code.bytes[ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_offset)]; // quick access to first program header
+         first_segment_offset = ELF_GET_NUMERIC (ELFHDR, phdr, file_offset); // get the first segment's start offset in the ELF file
+         cumulated_segment_length = ELF_GET_NUMERIC (ELFHDR, phdr, size_in_file); // get this ELF segment's length in the ELF file
+         #undef ELFHDR
+         ASSERT_WITH_ERRNO (Buffer_SubsetWithLength (&boot_code, first_segment_offset, cumulated_segment_length)); // isolate it
+         // locate the "            boot" string (16 bytes) and chop it off along with everything preceding it
-         if (!Buffer_ReadFromFile (&opaqueblob_file, bootfile_pathname))
+         bootcode_start = Buffer_FindFirstByteArray (&boot_code, "            boot");
-            DIE_WITH_EXITCODE (1, "failed to open \"%s\" for reading: %s", bootfile_pathname, strerror (errno));
+         ASSERT (bootcode_start != NULL, "bios.boot does not contain the expected '            boot' marker");
+         bootcode_start += 16; // skip the marker
+         ASSERT_WITH_ERRNO (Buffer_SubsetFromTo (&boot_code, (size_t) bootcode_start - (size_t) boot_code.bytes, boot_code.size)); // isolate what's after
+         // pad it to 3888 bytes (FIXME: why this value? Can it be less?)
-         ASSERT_WITH_ERRNO (Buffer_AppendBuffer (&ifs.data, &opaqueblob_file)); // write boot blob
+         ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&boot_code, 3888)); // pad as necessary
-         Buffer_Forget (&opaqueblob_file);
+         ASSERT_WITH_ERRNO (Buffer_AppendBuffer (&ifs.data, &boot_code)); // write boot blob
          ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
+      }
       ifs.offsets.startupheader = ifs.data.size; // save startup header offset for future use
       memset (&startup_header, 0, sizeof (startup_header)); // prepare startup header
          startup_header.machine = ELF_MACHINE_X86_64; // EM_X86_64
       else if (strcmp (image_processor, "aarch64le") == 0)
          startup_header.machine = ELF_MACHINE_AARCH64; // EM_AARCH64
       else
          DIE_WITH_EXITCODE (1, "unsupported processor type '%s' found in build file \"%s\"", image_processor, buildfile_pathname); // should not happen
-      startup_header.startup_vaddr = image_base + (uint32_t) startupfile_ep_from_imagebase; // [I ] Virtual Address to transfer to after IPL is done, here 0x01403008 (appears in "Entry" column for "startup.*")
+      startup_header.startup_vaddr = WILL_BE_FILLED_LATER;                   // [I ] Virtual Address to transfer to after IPL is done, here 0x01403008 (appears in "Entry" column for "startup.*")
-      startup_header.image_paddr   = image_base + (uint32_t) bootfile_size;                 // F[IS] Physical address of image, here 0x01400f30 (appears in "Offset" column for "startup-header" which is the first entry/start of file)
+      startup_header.image_paddr   = image_base + (uint32_t) boot_code.size; // F[IS] Physical address of image, here 0x01400f30 (appears in "Offset" column for "startup-header" which is the first entry/start of file)
-      startup_header.ram_paddr     = startup_header.image_paddr;                            // [IS] Physical address of RAM to copy image to (startup_size bytes copied), here 0x01400f30 (same as above)
+      startup_header.ram_paddr     = startup_header.image_paddr;             // [IS] Physical address of RAM to copy image to (startup_size bytes copied), here 0x01400f30 (same as above)
-      startup_header.ram_size      = WILL_BE_FILLED_LATER;                                  // [ 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 (40686)
+      startup_header.ram_size      = WILL_BE_FILLED_LATER;                   // [ 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 (40686)
-      startup_header.startup_size  = WILL_BE_FILLED_LATER;                                  // [I ] Size of startup (never compressed), here 0x02f148 or 192 840 bytes
+      startup_header.startup_size  = WILL_BE_FILLED_LATER;                   // [I ] Size of startup (never compressed), here 0x02f148 or 192 840 bytes
-      startup_header.stored_size   = WILL_BE_FILLED_LATER;                                  // [I ] Size of entire image file (startup + *optionally compressed* imagefs) without optional boot prefix, here 0x00cd6128
+      startup_header.stored_size   = WILL_BE_FILLED_LATER;                   // [I ] Size of entire image file (startup + *optionally compressed* imagefs) without optional boot prefix, here 0x00cd6128
-      startup_header.imagefs_size  = WILL_BE_FILLED_LATER;                                  // [ S] Size of uncompressed imagefs, here 0x00ca6fe0 or 13 266 912 bytes
+      startup_header.imagefs_size  = WILL_BE_FILLED_LATER;                   // [ S] Size of uncompressed imagefs, here 0x00ca6fe0 or 13 266 912 bytes
-      startup_header.preboot_size  = (uint16_t) bootfile_size;                              // [I ] Size of loaded before header, here 0xf30 or 3888 bytes (size of "bios.boot" file))
+      startup_header.preboot_size  = (uint16_t) boot_code.size;              // [I ] Size of loaded before header, here 0xf30 or 3888 bytes (size of "bios.boot" file))
       ASSERT_WITH_ERRNO (Buffer_Append (&ifs.data, &startup_header, sizeof (startup_header))); // write startup header
       ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
-      // ######################################################################################################################################################################################################################################
+      // prelink the startup executable, map its .text segment at the right virtual address for the IFS and stamp in its executable arguments
-      // # FIXME: figure out how to re-create it:
+      // then store the result in this entry's data blob
+      sprintf_s (textbase_mapaddr_string, sizeof (textbase_mapaddr_string), ".text=0x%zx", image_base + ifs.data.size); // image base + sizeof (boot prefix + startup header)
-      // first: open "startup-x86" ELF file,
+      prelink (startup_entry_parms.search, // binary executable search path
+               textbase_mapaddr_string, // "--section-start" linker argument (e.g. ".text=0xXXXXXXXX")
-      //        lookup section headers table (there is no program headers table in this one)
+               &startup_argv, &startup_envp, // executable arguments (including its name) and environment to stamp in it
+               startup_entry_parms.should_keep_ld_output, // whether to keep the linker-produced output file
+               &startup_code, // buffer where to save the output
-      //        FIXME: figure out something in there where the result is 0x1401030 !!!
+               &startup_bootargs_offset); // where to save the offset of the boot arguments
-      // then: call the linker: ld --sysroot=${QNX_TARGET}/x86_64/ -T${QNX_TARGET}/x86_64/lib/nto.link --section-start .text=0x1401030 --no-relax ${QNX_TARGET}/x86_64/boot/sys/startup-x86 -o startup.bin.UNSTRIPPED
+      // fix shdr_addr in procnto's arguments structure, same value as startup_header.image_paddr (which is not set yet) (TODO: support 64-bit shdr_addr offsets -- see comment in bootargs_entry_t struct)
+      ((bootargs_entry_t *) &startup_code.bytes[startup_bootargs_offset])->shdr_addr = (uint32_t) (image_base + boot_code.size);
-      // then: parse resulting ELF file, take all program segments and concatenate them --> this is the blob (FIXME: wrong?)
+      // backup two interesting values and chop off the ELF header until the start of the first segment
+      #define ELFHDR ((elf_header_t *) startup_code.bytes) // this convenient definition will make sure the ELF header points at the right location
-      // ######################################################################################################################################################################################################################################
+      startup_header.startup_vaddr = (uint32_t) ELF_GET_NUMERIC (ELFHDR, ELFHDR, entrypoint_offset); // read ELF entrypoint and store it in the startup header (it will be rewritten at the end of the process)
-#if 0 // nonworking
+      if (boot_type == BOOTTYPE_UEFI)
-      // <deleted>
+      {
+         uefi_header = (uefi64_header_t *) ifs.data.bytes; // restore UEFI header pointer
+         uefi_header->optional_header64.entrypoint_address = (uint32_t) (startup_header.startup_vaddr - image_base); // save UEFI startup address by substracting image base from ELF entrypoint
-#else // working
+      }
+      first_segment_offset = 0;
+      minimal_padded_length = 0;
-      if (!Buffer_ReadFromFile (&opaqueblob_file, startupfile_pathname))
+      cumulated_segment_length = 0;
-         DIE_WITH_EXITCODE (1, "failed to open \"%s\" for reading: %s", startupfile_pathname, strerror (errno));
+      program_header_table_count = ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_len); // get the number of program headers
-      ASSERT_WITH_ERRNO (Buffer_AppendBuffer (&ifs.data, &opaqueblob_file)); // write startup blob
+      for (table_index = 0; table_index < program_header_table_count; table_index++)
+      {
+         phdr = (elf_program_header_t *) &startup_code.bytes[ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_item_size) * table_index]; // quick access to program header
-      Buffer_Forget (&opaqueblob_file);
+         if (first_segment_offset == 0)
+            first_segment_offset = ELF_GET_NUMERIC (ELFHDR, phdr, file_offset); // get the first segment's start offset in the ELF file
+         minimal_padded_length += ELF_GET_NUMERIC (ELFHDR, phdr, size_in_memory); // get this ELF segment's required memory in the ELF file
+         cumulated_segment_length += ELF_GET_NUMERIC (ELFHDR, phdr, size_in_file); // get this ELF segment's length in the ELF file
+      }
-#endif // working
+      #undef ELFHDR
+      // FIXME: more bytes are read from the file past the last segment. Either a mkifs bug, or I'm wrong somewhere?
+      ASSERT_WITH_ERRNO (Buffer_SubsetWithLength (&startup_code, first_segment_offset, cumulated_segment_length + (boot_type == BOOTTYPE_UEFI ? 0x400 : 0x820)));
+      // pad with zeroes up to the required memory length and align with page size plus 4 (FIXME: understand why +4)
+      ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&startup_code, ROUND_TO_UPPER_MULTIPLE (minimal_padded_length, image_pagesize) + 4)); // pad as necessary
+      // write the startup blob and pad as necessary
+      ASSERT_WITH_ERRNO (Buffer_AppendBuffer (&ifs.data, &startup_code)); // write startup blob
       ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
       ifs.offsets.startuptrailer = ifs.data.size; // save startup trailer offset for future use
       ASSERT_WITH_ERRNO (Buffer_Append (&ifs.data, &startup_trailer, sizeof (startup_trailer))); // write startup trailer
       ASSERT_WITH_ERRNO (Buffer_PadWithZeroesTo (&ifs.data, ROUND_TO_UPPER_MULTIPLE (ifs.data.size, image_align))); // pad as necessary
+   }
    ASSERT_WITH_ERRNO (Buffer_AppendByteArray (&ifs.data, "\0\0\0\0")); // there seems to be 4 bytes of padding after the image directory
    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)
+   if (startup_argv.count > 0)
+   {
       // 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 (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
          if (fsentries[fsentry_index].header.ino == image_kernel_ino)
             break; // locate the kernel directory entry (can't fail)
       fsentries[fsentry_index].u.file.offset = (uint32_t) (ifs.data.size - ifs.offsets.imageheader); // save file data blob offset in file structure
       ASSERT (procnto_bootargs_offset + sizeof (bootargs_entry_t) < fsentries[fsentry_index].u.file.size, "can't fix boot args in procnto, would write beyond the end of file! This is a bug in the program. Please contact the author.");
-      ((bootargs_entry_t *) &fsentries[fsentry_index].UNSAVED_databuf[procnto_bootargs_offset])->shdr_addr = (uint32_t) (image_base + bootfile_size); // fix shdr_addr in procnto's arguments structure, same value as startup_header.image_paddr (which is not set yet) (TODO: support 64-bit shdr_addr offsets -- see comment in bootargs_entry_t struct)
+      ((bootargs_entry_t *) &fsentries[fsentry_index].UNSAVED_databuf[procnto_bootargs_offset])->shdr_addr = (uint32_t) (image_base + boot_code.size); // fix shdr_addr in procnto's arguments structure, same value as startup_header.image_paddr (which is not set yet) (TODO: support 64-bit shdr_addr offsets -- see comment in bootargs_entry_t struct)
       Buffer_AppendIFSFileData (&ifs.data, &fsentries[fsentry_index]); // write kernel file data
       fsentries[fsentry_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+   }
    // then write all the other files by increasing inode number: ELF files first
    // see if we are past the image max size, in which case it's an error
    if (ifs.final_size > image_maxsize)
       DIE_WITH_EXITCODE (1, "image file size %zd exceeds max size (%zd)", ifs.final_size, (size_t) image_maxsize);
    // do we have a startup file ? if so, this is a bootable image
-   if (startupfile_pathname != NULL)
+   if (startup_argv.count > 0)
+   {
       // patch the startup header with its final values
       startup_header.startup_size = (uint32_t) (ifs.offsets.imageheader - ifs.offsets.startupheader); // size of startup header up to image header
       startup_header.imagefs_size = (uint32_t) (ifs.final_size - ifs.offsets.imageheader); // size of uncompressed imagefs
       startup_header.ram_size     = (uint32_t) (ifs.final_size - ifs.offsets.startupheader);
       if (startup_header_compression_flag == STARTUP_HDR_FLAGS1_COMPRESS_UCL)
          ASSERT (ucl_init () == UCL_E_OK, "UCL library initialization failed -- please recompile this tool with less aggressive optimizations");
       else if (startup_header_compression_flag == STARTUP_HDR_FLAGS1_COMPRESS_LZO)
          ASSERT (ucl_init () == UCL_E_OK, "LZO library initialization failed -- please recompile this tool with less aggressive optimizations");
       else if (startup_header_compression_flag == STARTUP_HDR_FLAGS1_COMPRESS_ZLIB)
-         DIE_WITH_EXITCODE (1, "unimplemented compression scheme: zlib (FIXME)");
+         DIE_WITH_EXITCODE (1, "unimplemented compression scheme: zlib"); // deprecated by QNX: won't fix
       else
          DIE_WITH_EXITCODE (1, "unsupported compression flags: 0x%2x", startup_header_compression_flag);
       // run the compressible payload (the imagefs) through the right compression algorithm
       while (remaining_len > 0)
       startup_header.stored_size = (uint32_t) (ifs.data.size - ifs.offsets.startupheader);
       ASSERT_WITH_ERRNO (Buffer_WriteAt (&ifs.data, ifs.offsets.startupheader, &startup_header, sizeof (startup_header))); // write the final startup header at its right offset
+   }
    // do we have a startup file ? if so, this is a bootable image
-   if (startupfile_pathname != NULL)
+   if (startup_argv.count > 0)
+   {
       if (boot_type == BOOTTYPE_UEFI) // UEFI boot: fix the final offsets and sizes in the EFI executable's PE header
+      {
          uefi_header = (uefi64_header_t *) ifs.data.bytes; // have a convenience pointer
          uefi_header->optional_header64.code_size = (uint32_t) (ifs.data.size - ifs.offsets.startupheader); // total size of IFS minus 512 bytes for the UEFI boot header, i.e. size of startup blob plus size of image

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool//ifstool.c – Rev 38 → 41