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

 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 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 = 0;             // kernel file offset in the IFS (first offset rounded at pagesize after the dirents table)
+static size_t procnto_bootargs_offset = 0;       // offset in the procnto file to the boot args structure, so that it can be patched late
 // 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
       LOG_INFO ("fifo: ino 0x%x uid %d gid %d mode 0%o path \"%s\" dev:rdev %s)", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data.bytes);
+   }
    else // necessarily a regular file (either S_IFREG is specified, or st_mode is zero)
+   {
       entry_parms->st_mode |= S_IFREG; // make this explicit
+      entry_parms->mtime = entry_parms->mtime_for_inline_files; // set a default mtime equal to the mtime to use for inline files until told otherwise
+      ASSERT ((entry_parms->data.bytes != NULL) || (buildhost_pathname != NULL), "unexpected code path: can't store a file without neither explicit contents nor a host pathname. This is a bug in the program. Please contact the author.");
+      // do we NOT know the file data yet AND was a build host pathname specified ? which means we need to resolve the file on the build host's filesystem
+      if ((entry_parms->data.bytes == NULL) && (buildhost_pathname != NULL))
+      {
+         resolved_pathname = resolve_pathname (buildhost_pathname, entry_parms->search); // locate the file
+         if (resolved_pathname == NULL)
+         {
+            if (entry_parms->should_allow_nonexistent_files)
+            {
+               LOG_WARNING ("filesystem entry \"%s\" specified in \"%s\" line %d not found on build host: ignoring", buildhost_pathname, buildfile_pathname, lineno);
+               return; // if we're allowed to continue when a file to add doesn't exist, do so, else die with an error message
+            }
+            DIE_WITH_EXITCODE (1, "filesystem entry \"%s\" specified in \"%s\" line %d not found on build host: %s", buildhost_pathname, buildfile_pathname, lineno, strerror (errno));
+         }
+         if (!Buffer_ReadFromFile (&entry_parms->data, resolved_pathname))
+            DIE_WITH_EXITCODE (1, "filesystem entry \"%s\" specified in \"%s\" line %d can't be read from \"%s\": %s", buildhost_pathname, buildfile_pathname, lineno, resolved_pathname, strerror (errno));
+         stat (resolved_pathname, &stat_buf); // can't fail, since we could read it
+         if (entry_parms->mtime == UINT32_MAX)
+            entry_parms->mtime = (uint32_t) stat_buf.st_mtime; // now we know which mtime to set this file
+      }
+      // is it the bootstrap file [startup=], or a "compiled" bootscript [+script] ?
-      if (entry_parms->is_bootstrap_file) // is it the bootstrap file ?
+      if (entry_parms->is_bootstrap_file) // [startup=...]
+      {
          // parse each line of contents
          ASSERT (entry_parms->data.size > 0, "kernel specification without inline contents");
          // parse buffer (non-destructively) line after line
             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 {
+         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
+            {
          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
+         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)
          // 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 = (uint32_t) (image_base + bootfile_size); // 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 *) 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, (size_t) bootargs_location - (size_t) entry_parms->data.bytes, &bootargs_buffer));
+         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
-         // now strip this prelinked ELF kernel file
-         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)
          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
          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) // else is it a startup script that we need to compile ?
+      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);
          // parse buffer (non-destructively) line after line
          ASSERT_WITH_ERRNO (Buffer_AppendByteArray (&compiled_script, "\x00\x00\x00\x00")); // terminate the compiled boot script with a 4-byte trailer
          entry_parms->data.bytes = compiled_script.bytes; // and steal the compiled boot script buffer
          entry_parms->data.size = compiled_script.size;
       } // end of "is compiled bootscript"
-      // do we already know the data for this data blob ?
-      if (entry_parms->data.bytes != NULL)
-      {
-         entry_parms->mtime = entry_parms->mtime_for_inline_files; // if so, set it a mtime equal to the mtime to use for inline files
-         LOG_INFO ("file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" blob (len %zd)", entry_parms->extra_ino_flags | (inode_count + 1), entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data.size);
-      }
-      else if (buildhost_pathname != NULL) // else was a source file pathname supplied ?
-      {
-         resolved_pathname = resolve_pathname (buildhost_pathname, entry_parms->search); // locate the file
-         if (resolved_pathname == NULL)
-         {
-            if (entry_parms->should_allow_nonexistent_files)
-            {
-               LOG_WARNING ("filesystem entry \"%s\" specified in \"%s\" line %d not found on build host: ignoring", buildhost_pathname, buildfile_pathname, lineno);
-               return; // if we're allowed to continue when a file to add doesn't exist, do so, else die with an error message
-            }
-            DIE_WITH_EXITCODE (1, "filesystem entry \"%s\" specified in \"%s\" line %d not found on build host: %s", buildhost_pathname, buildfile_pathname, lineno, strerror (errno));
-         }
-         if (!Buffer_ReadFromFile (&entry_parms->data, resolved_pathname))
-            DIE_WITH_EXITCODE (1, "filesystem entry \"%s\" specified in \"%s\" line %d can't be read from \"%s\": %s", buildhost_pathname, buildfile_pathname, lineno, resolved_pathname, strerror (errno));
-         stat (resolved_pathname, &stat_buf); // can't fail, since we could read it
-         if (entry_parms->mtime == UINT32_MAX)
-            entry_parms->mtime = (uint32_t) stat_buf.st_mtime;
-         if ((entry_parms->data.size > 52) && (memcmp (entry_parms->data.bytes, ELF_MAGIC_STR, 4) == 0))
-            entry_parms->st_mode |= 0111; // add +x permissions to ELF entries (undocumented mkifs behaviour)
-         LOG_INFO ("file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" buildhost_file \"%s\" (len %zd)", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, buildhost_pathname, entry_parms->data.size);
+      LOG_INFO ("file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" buildhost_file \"%s\" (len %zd)", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, (buildhost_pathname != NULL ? buildhost_pathname : "<explicit blob>"), entry_parms->data.size);
-      }
-      else
-         DIE_WITH_EXITCODE (1, "unexpected code path: can't store a file without neither explicit contents nor a host pathname. This is a bug in the program. Please contact the author.");
       // is the file we're storing an ELF file ?
       #define ELFHDR ((elf_header_t *) entry_parms->data.bytes) // this convenient definition will make sure the ELF header points at the right location, even after entry_parms.data->byte is reallocated
       if ((entry_parms->data.size > 52) // file is big enough to contain an ELF header
           && (memcmp (ELF_GET_STRING (ELFHDR, ELFHDR, magic), ELF_MAGIC_STR, 4) == 0)) // file starts with the ELF magic
+      {
+         if ((entry_parms->st_mode & 0111) == 0)
+            entry_parms->st_mode |= 0111; // add +x permissions to ELF entries if they have none (undocumented mkifs behaviour)
          // is the file we're storing a relocatable executable (i.e. a dynamic library) and should we check for its canonical name ?
          if ((ELF_GET_NUMERIC (ELFHDR, ELFHDR, type) == ELF_TYPE_DYNAMICLIB) && entry_parms->should_autosymlink_dylib)
+         {
             // locate the sections we need (the dynamic section and its strings table)
             const elf_section_header_t *shdr_dynamic = elf_get_section_header_by_name (ELFHDR, ".dynamic");
       // now write the QNX 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)
       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

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool//ifstool.c – Rev 34 → 35