Subversion Repositories QNX 8.QNX8 IFS tool

 

 

 

 

 

 

 

 

const char *__asan_default_options () { return ("detect_leaks=0"); }

 

 

 

 

 

 

 

 

 

 

typedef struct stringarray_s

   char **args;

   size_t count;

} stringarray_t;

 

 

typedef struct parms_s

   int dperms; // directory permissions (e.g. 0755)

   int perms; // file permissions (e.g. 0644)

   int uid; // owner user ID (e.g. 0 = root)

   int gid; // owner group ID (e.g. 0 = root)

   int st_mode; // entry type (e.g. S_IFREG for files) and permissions

   uint32_t mtime; // entry's modification time POSIX timestamp - set to UINT32_MAX to use the concerned files' mtime on the build host

   uint32_t mtime_for_inline_files; // same as above but only for files that don't exist on the build host (i.e. files with an explicit content blob)

   char *prefix; // [prefix=path] install path (e.g. "proc/boot")

   bool should_follow_symlinks; // follow symlinks

   bool should_autosymlink_dylib; // dynamic libraries should be written under their official SONAME and a named symlink be created pointing at them

   bool should_keep_ld_output; // whether to keep .sym files produced by ld calls, togglable by the [+keeplinked] attribute

   bool should_ignore_duplicates; // [+|-dupignore] whether to ignore duplicates

   bool should_allow_nonexistent_files; // [+|-optional] whether to continue processing on unexistent files

   bool is_bootstrap_file; // entry has the [virtual] attribute

   bool is_compiled_bootscript; // entry has [+script] attribute

   int extra_ino_flags; // bitmap of extra inode flags (IFS_INO_xxx)

   char *search; // [search=path[:path]] binary search path (the default one will be constructed at startup)

 

   buffer_t data; // the resolved file's own data bytes

} parms_t;

 

 

int verbose_level = 1; // verbosity level, can be increased with multiple -v[...] flags

 

 

static char line_buffer[4096]; // scrap buffer for the IFS build file parser

static uint32_t image_base = 4 * 1024 * 1024; // default image base, as per QNX docs -- can be changed with the [image=XXXX] attribute in the IFS build file

static uint32_t image_end = UINT32_MAX; // default image end (no limit)

static uint32_t image_maxsize = UINT32_MAX; // default image max size (no limit)

static uint32_t image_totalsize = 0; // image total size, measured once all the blocks have been written to the output IFS file

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;

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 = "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.

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 = "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.

static char *buildfile_pathname = NULL; // pathname of IFS build file

static char *current_line = NULL; // copy of current line in IFS build file

static int lineno = 0; // current line number in IFS build file

static char *QNX_TARGET = NULL; // value of the $QNX_TARGET environment variable

static char *SEARCH_PATH = NULL; // mallocated string of search paths, populated by the -r command-line argument

static char **saved_ELF_sections = NULL; // mallocated array of const strings, populated by the -s command-line argument

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

 

static int boot_type = BOOTTYPE_NONE;

static buffer_t boot_code    = { NULL, 0 };      // boot code (boot prefix) to put at the start of 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

 

 

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 long long read_integer (const char *str, const int base_or_zero_for_auto); // reads an integer number for a string that may be specified in either hex, octal or decimal base, and may have an optional unit suffix (k, m, g, t)

static char *resolve_envvars (const char *str); // resolves environment variables in str and replaces them with their value, or an empty string if undefined. Returns a mallocated string (caller frees)

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

 

 

extern int dump_ifs_info (const char *ifs_pathname, bool want_everything, bool hide_filename); // [implemented in ifsdump.c] dumps detailed info about a particular IFS file on the standard output, returns 0 on success and >0 on error

extern int dump_ifs_contents (const char *ifs_pathname, const char *outdir); // [implemented in ifsdump.c] dumps the IFS filesystem contents in outdir, returns 0 on success and >0 on error

extern int dump_file_hex (const char *pathname); // [implemented in ifsdump.c] dumps the contents of pathname to stdout in mixed hexadecimal + ASCII (hex editor) format

 

 

int32_t update_checksum (const void *data, const size_t data_len, const bool is_foreign_endianness)

   // computes the checksum of an IFS image or startup section, i.e. from the start of the header to the end of the trailer minus the last 4 bytes where the checksum is stored

 

   uint8_t accumulator[4] = { 0, 0, 0, 0 };

   const char *current_char_ptr;

   int32_t image_cksum;

   size_t i;

 

   image_cksum = 0;

   current_char_ptr = data;

   for (i = 0; i < data_len; i++)

   {

      accumulator[i % 4] = *current_char_ptr;

      if (i % 4 == 3)

      {

         if (is_foreign_endianness)

            image_cksum += (accumulator[3] << 0) + (accumulator[2] << 8) + (accumulator[1] << 16) + (accumulator[0] << 24);

         else

            image_cksum += (accumulator[0] << 0) + (accumulator[1] << 8) + (accumulator[2] << 16) + (accumulator[3] << 24);

      }

      current_char_ptr++;

   }

 

   return (is_foreign_endianness ? __builtin_bswap32 (-image_cksum) : -image_cksum);

 

 

static long long read_integer (const char *str, const int base_or_zero_for_auto)

   // reads a number for a string that may be specified in either hex, octal or decimal base, and may have an optional unit suffix (k, m, g, t)

 

   char *endptr = NULL;

   long long ret = strtoll (str, &endptr, base_or_zero_for_auto); // use strtoll() to handle hexadecimal (0x...), octal (0...) and decimal (...) bases

   if (endptr != NULL)

   {

      if      ((*endptr == 'k') || (*endptr == 'K')) ret *= (size_t) 1024;

      else if ((*endptr == 'm') || (*endptr == 'M')) ret *= (size_t) 1024 * 1024;

      else if ((*endptr == 'g') || (*endptr == 'G')) ret *= (size_t) 1024 * 1024 * 1024;

      else if ((*endptr == 't') || (*endptr == 'T')) ret *= (size_t) 1024 * 1024 * 1024 * 1024; // future-proof enough, I suppose?

   }

   return (ret);

 

 

static char *resolve_envvars (const char *str)

   // resolves environment variables in str and replaces them with their value, or an empty string if undefined

   // returns a mallocated string (caller frees), or dies with errno

 

   signed int erase_index;

   void *reallocated_ptr;

   size_t replacement_len;

   size_t middlebit_len;

   size_t old_str_len;

   size_t new_str_len;

   size_t endbit_len;

   char erased_char;

   char *resolved_str;

   char *replacement;

   char *varname;

   char *endbit;

   char *token;

 

   resolved_str = strdup (str); // have a working copy of the input string

   ASSERT_WITH_ERRNO (resolved_str);

   while ((((token = strstr (resolved_str, "${")) != NULL) && ((endbit = strchr (token, '}')) != NULL)) // look for variables in the "${VARNAME}" format *AND* in "$VARNAME" format

          || (((token = strstr (resolved_str, "$")) != NULL) && ((middlebit_len = strspn (token, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_")) != strlen (token))))

   {

      if (token[1] == '{') // "${VARNAME}" format

      {

         endbit++; // locate where the end bit begins

         varname = token + 2; // skip the leading two characters: "${"

         erase_index = -1; // we shall split the string at the character that's *just before* where the end bit starts

      }

      else // "$VARNAME" format

      {

         endbit = &token[middlebit_len]; // locate where the end bit begins

         varname = token + 1; // skip the leading '$'

         erase_index = 0; // we shall split the string at the character that's *right where* the end bit starts

      }

      old_str_len = strlen (resolved_str); // measure current string length

      endbit_len = strlen (endbit); // measure the length of the end bit (skip the closing curly brace)

      erased_char = endbit[erase_index]; // remember which is the character we're going to erase

      endbit[erase_index] = 0; // split the string at the end of the variable name

      if (strcmp (varname, "PFS") == 0)

         replacement = PATH_SEP; // special case: if it's the PFS variable, select ":" or ";" based on the host platform

      else if (strcmp (varname, "PROCESSOR") == 0)

         replacement = image_processor; // special case: if it's PROCESSOR, replace it with the processor name (e.g. "aarch64le")

      else if (strcmp (varname, "PROCESSOR_BASE") == 0)

         replacement = image_processor_base; // special case: if it's PROCESSOR_BASE, replace it with the processor base name (e.g. "aarch64")

      else

         replacement = getenv (varname); // peek at the environment for its value

      if (replacement == NULL)

         replacement = ""; // if this variable isn't defined, fallback to an empty string, just like what a UNIX shell does

      endbit[erase_index] = erased_char; // put the erased character back

      replacement_len = strlen (replacement); // measure replacement length

      new_str_len = (size_t) token - (size_t) resolved_str + replacement_len + endbit_len; // measure updated string len

      if (new_str_len > old_str_len)

      {

         reallocated_ptr = realloc (resolved_str, new_str_len + 1); // grow it if necessary

         ASSERT_WITH_ERRNO (reallocated_ptr);

         token = &((char *) reallocated_ptr)[token - resolved_str]; // fix the pointers that may have moved

         endbit = &((char *) reallocated_ptr)[endbit - resolved_str]; // fix the pointers that may have moved

         resolved_str = reallocated_ptr;

      }

      memmove (token + replacement_len, endbit, endbit_len + 1); // move the end bit to its final location (including its nul terminator)

      memcpy (token, replacement, replacement_len); // and patch the replacement in between

   }

 

   return (resolved_str); // finished, return the mallocated resolved string (caller frees)

 

 

static char *resolve_pathname (const char *pathname, const char *search_paths_or_NULL_for_MKIFS_PATH_envvar)

   // locates pathname among search path and returns resolved pathname (static buffer) or NULL.

 

   typedef struct default_path_s { bool uses_processor_base; char *subpath; } default_path_t;

 

   static const default_path_t default_paths[] =

   {

      { false, "/sbin"     }, // prefix with $PROCESSOR/

      { false, "/usr/sbin" }, // prefix with $PROCESSOR/

      { false, "/boot/sys" }, // prefix with $PROCESSOR/

      { true,  "/boot/sys" }, // prefix with $PROCESSOR_BASE/

      { false, "/bin"      }, // prefix with $PROCESSOR/

      { false, "/usr/bin"  }, // prefix with $PROCESSOR/

      { false, "/lib"      }, // prefix with $PROCESSOR/

      { false, "/lib/dll"  }, // prefix with $PROCESSOR/

      { false, "/usr/lib"  }  // prefix with $PROCESSOR/

   };

   static thread_local char *resolved_pathname = NULL;

 

   char *pathname_without_envvars;

   char *resolved_search_path;

   size_t defaultpath_index;

   struct stat stat_buf;

   char *nextsep;

   char *token;

 

   // resolve possible environment variables in pathname

   pathname_without_envvars = resolve_envvars (pathname);

 

   // NOTE: the QNX documentation states:

   // "- If path starts with a slash (/) on a Linux development host, or a disk volume label (i.e., drive letter and a colon) followed by a backslash (\) on a Windows host, the path is absolute and mkifs looks for the file at that exact host location. [...]

   //  - If path contains a slash or backslash character that's not at the start, the path is relative and mkifs tries to resolve it relative to the current working directory (CWD).

   //  - If path does not contain a directory separator or the file could not be found relative to the CWD, mkifs tries to resolve it relative to all directories given in the search attribute, in succession."

 

   // is it an absolute pathname (POSIX and Windows variants) ?

   if (IS_DIRSEP (pathname_without_envvars[0])

       || (isalpha (pathname_without_envvars[0]) && (pathname_without_envvars[1] == ':') && IS_DIRSEP (pathname_without_envvars[2]))

       )

      return (pathname_without_envvars); // in this case, it MUST exist at its designated location

 

   // else is it a relative pathname ?

   else if (((strchr (pathname_without_envvars, '/') != NULL)

             || (strchr (pathname_without_envvars, '\\') != NULL)

            ) && (stat (pathname_without_envvars, &stat_buf) == 0) && S_ISREG (stat_buf.st_mode))

      return (pathname_without_envvars); // in this case, see if it exists relatively to the current working directory, and if it does, return it

 

   // what we've been given is just a basename, so search it among the search paths we have

 

   // QNX docs:

   // When searching for host files to be included in the image, search the default paths used for storing binaries within the specified directory before searching the default paths within $QNX_TARGET.

   // You can define multiple -r options; each adds a set of paths to search for files.

   // The -r options are evaluated from left to right meaning the paths prefixed with the first (leftmost) rootdir are searched first, then those prefixed with the second rootdir, and so on.

   // Normally, mkifs searches any paths defined in $MKIFS_PATH when it was called and then the default paths within $QNX_TARGET.

   // The default paths are based on the CPU architecture specified by $PROCESSOR and $PROCESSOR_BASE.

   // If you specify -r options, mkifs searches the default paths prefixed with each dir variable before searching those within $QNX_TARGET.

   // These paths are:

   //   dir/${PROCESSOR}/sbin

   //   dir/${PROCESSOR}/usr/sbin

   //   dir/${PROCESSOR}/boot/sys

   //   dir/${PROCESSOR_BASE}/boot/sys

   //   dir/${PROCESSOR}/bin

   //   dir/${PROCESSOR}/usr/bin

   //   dir/${PROCESSOR}/lib

   //   dir/${PROCESSOR}/lib/dll

   //   dir/${PROCESSOR}/usr/lib

   // NOTE: The structure of the directory paths under dir must be identical to that of the default paths under $QNX_TARGET, but the root dir itself may be any path you choose.

   // For example, if you wanted to include /scratch/aarch64le/sbin/devb-sata, you would specify a -r option like this:

   //   -r /scratch

   // Note that you don't include $PROCESSOR or $PROCESSOR_BASE in dir.

 

   //  - search all paths in explicit path/[default paths] (if explicit path supplied)

   //  - search all paths in (-r flags if have some|MKIFS_PATH)/[default paths] (if no explicit path supplied)

   //  - search all paths in $QNX_TARGET/[default paths]

 

   // initial allocation (per thread)

   if (resolved_pathname == NULL)

   {

      resolved_pathname = malloc (MAXPATHLEN);

      ASSERT_WITH_ERRNO (resolved_pathname);

   }

 

   // if no file-specific explicit search path was supplied, use the path list supplied by the -r command-line arguments, else fallback to MKIFS_PATH if we don't have any

   if (search_paths_or_NULL_for_MKIFS_PATH_envvar == NULL)

      search_paths_or_NULL_for_MKIFS_PATH_envvar = (SEARCH_PATH != NULL ? SEARCH_PATH : getenv ("MKIFS_PATH"));

 

   // construct a potential final path using each element of the search path

   if (search_paths_or_NULL_for_MKIFS_PATH_envvar != NULL)

   {

      // the first step is to resolve all environment variables in the search path

      resolved_search_path = resolve_envvars (search_paths_or_NULL_for_MKIFS_PATH_envvar);

 

      // now split this search path string into multiple tokens and process them one after the other

      token = (*resolved_search_path != 0 ? resolved_search_path : NULL);

      nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP)] : NULL);

      while (token != NULL)

      {

         // look under this search path at each of the known subpaths

         for (defaultpath_index = 0; defaultpath_index < sizeof (default_paths) / sizeof (default_paths[0]); defaultpath_index++)

         {

            sprintf_s (resolved_pathname, MAXPATHLEN, "%.*s/%s/%s/%s", (int) (nextsep - token), token, (default_paths[defaultpath_index].uses_processor_base ? image_processor_base : image_processor), default_paths[defaultpath_index].subpath, pathname_without_envvars);

            if ((stat (resolved_pathname, &stat_buf) == 0) && S_ISREG (stat_buf.st_mode))

            {

               free (pathname_without_envvars);

               return (resolved_pathname); // if a file can indeed be found at this location, stop searching

            }

         }

 

         token = (*nextsep != 0 ? nextsep + 1 : NULL);

         nextsep = (token != NULL ? &token[strcspn (token, PATH_SEP)] : NULL);

      }

   }

 

   // file not found in search paths: look under QNX_TARGET at each of the known subpaths

   for (defaultpath_index = 0; defaultpath_index < sizeof (default_paths) / sizeof (default_paths[0]); defaultpath_index++)

   {

      sprintf_s (resolved_pathname, MAXPATHLEN, "%s/%s/%s/%s", QNX_TARGET, (default_paths[defaultpath_index].uses_processor_base ? image_processor_base : image_processor), default_paths[defaultpath_index].subpath, pathname_without_envvars);

      if ((stat (resolved_pathname, &stat_buf) == 0) && S_ISREG (stat_buf.st_mode))

      {

         free (pathname_without_envvars);

         return (resolved_pathname); // if a file can indeed be found at this location, stop searching

      }

   }

 

   free (pathname_without_envvars);

   errno = ENOENT; // we exhausted all possibilities

   return (NULL); // file not found, return with ENOENT

 

 

static size_t Buffer_WriteIFSDirectoryEntryAt (buffer_t *ifs, const size_t write_offset, const fsentry_t *fsentry)

   // writes a directory entry in the image filesystem buffer pointed to by ifs at write_offset (or fakes so if ifs is NULL)

   // and return the number of bytes written (or that would have been written)

 

   static const uint8_t zeropad_buffer[] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";

 

   size_t datalen;

   size_t count;

 

   count = 0;

   if (ifs != NULL)

      ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->header, sizeof (fsentry->header))); // write the entry header (PACKED STRUCT)

   count += sizeof (fsentry->header);

   if (S_ISREG (fsentry->header.mode))

   {

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.file.offset, sizeof (uint32_t))); // write offset

      count += sizeof (uint32_t);

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.file.size,   sizeof (uint32_t))); // write size

      count += sizeof (uint32_t);

      datalen = strlen (fsentry->u.file.path) + 1;

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.file.path, datalen)); // write null-terminated path (no leading slash)

      count += datalen;

   }

   else if (S_ISDIR (fsentry->header.mode))

   {

      datalen = strlen (fsentry->u.dir.path) + 1;

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.dir.path, datalen)); // write null-terminated path (no leading slash)

      count += datalen;

   }

   else if (S_ISLNK (fsentry->header.mode))

   {

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.symlink.sym_offset, sizeof (uint16_t))); // write offset

      count += sizeof (uint16_t);

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.symlink.sym_size,   sizeof (uint16_t))); // write size

      count += sizeof (uint16_t);

      datalen = strlen (fsentry->u.symlink.path) + 1;

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.symlink.path, datalen)); // write null-terminated path (no leading slash)

      count += datalen;

      datalen = strlen (fsentry->u.symlink.contents) + 1;

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.symlink.contents, datalen)); // write null-terminated symlink contents

      count += datalen;

   }

   else

   {

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.device.dev,  sizeof (uint32_t))); // write dev number

      count += sizeof (uint32_t);

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, &fsentry->u.device.rdev, sizeof (uint32_t))); // write rdev number

      count += sizeof (uint32_t);

      datalen = strlen (fsentry->u.device.path) + 1;

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, fsentry->u.device.path, datalen)); // write null-terminated path (no leading slash)

      count += datalen;

   }

 

   ASSERT (count <= fsentry->header.size, "attempt to write invalid dirent (claimed size %zd, written size %zd). Aborting.", (size_t) fsentry->header.size, count);

   if (count < fsentry->header.size)

   {

      if (ifs != NULL)

         ASSERT_WITH_ERRNO (Buffer_WriteAt (ifs, write_offset + count, zeropad_buffer, fsentry->header.size - count)); // pad as necessary

      count += fsentry->header.size - count;

   }

 

   return (count);

 

 

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

 

   elf_program_header_t *phdr;

   elf_header_t *elf;

   size_t fixed_physical_addr;

   size_t corrective_offset;

   //size_t segment_type;

   size_t size_in_memory;

   size_t table_index;

   size_t table_count;

   size_t data_offset;

 

   ASSERT (S_ISREG (fsentry->header.mode), "function called for invalid dirent"); // consistency check

   data_offset = ifs_data->size; // see where we are

 

   // is the file we're storing a preprocessed ELF file ?

   if (fsentry->header.ino & IFS_INO_PROCESSED_ELF)

   {

 

      elf = (elf_header_t *) fsentry->UNSAVED_databuf; // quick access to ELF header

      table_count = ELF_GET_NUMERIC (elf, elf, program_header_table_len); // get the number of program headers

      for (table_index = 0; table_index < table_count; table_index++)

      {

         phdr = (elf_program_header_t *) &fsentry->UNSAVED_databuf[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header

         //segment_type = ELF_GET_NUMERIC (elf, phdr, segment_type); // get segment type

         //if (!((segment_type >= 2) && (segment_type <= 7) || ((segment_type >= 0x6474e550) && (segment_type <= 0x6474e552)) || (segment_type == 0x70000001)))

         //   continue; // NOTE: only certain segments types must be corrected

 

 

         corrective_offset = ELF_GET_NUMERIC (elf, phdr, virtual_addr) - ELF_GET_NUMERIC (elf, phdr, file_offset);

         size_in_memory = ELF_GET_NUMERIC (elf, phdr, size_in_memory); // get this ELF segment's occupied size in memory

         if (size_in_memory != 0) // only patch the physical address of segments that have an actual size in memory

         {

            fixed_physical_addr = ELF_GET_NUMERIC (elf, phdr, physical_addr) + image_base + data_offset - corrective_offset;

            ELF_SET_NUMERIC (elf, phdr, physical_addr, fixed_physical_addr); // patch the physical address member of the program header table (NOTE: data_offset is the location where the file data is about to be written)

         }

      }

   }

 

   ASSERT_WITH_ERRNO (Buffer_Append (ifs_data, fsentry->UNSAVED_databuf, fsentry->u.file.size)); // write file data blob

   return (ifs_data->size - data_offset); // return the number of bytes written

 

 

static inline size_t Buffer_LocateOrAppendIfNecessaryAndReturnOffsetOf (buffer_t *buffer, const char *str)

   // helper function used in add_fsentry(): locates or appends str to buffer and returns its relative offset in the buffer

 

   size_t str_len_including_terminator = strlen (str) + 1;

   void *occurrence = Buffer_FindFirst (buffer, str, str_len_including_terminator);

   if (occurrence == NULL)

   {

      ASSERT_WITH_ERRNO (Buffer_Append (buffer, str, str_len_including_terminator));

      occurrence = Buffer_FindFirst (buffer, str, str_len_including_terminator);

      ASSERT_WITH_ERRNO (occurrence);

   }

   return (Buffer_OffsetOf (buffer, occurrence)); // can't fail

 

 

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)

   // NOTE: for each ELF file, mkifs

   // -> alters the program header table and offsets each p_addr (physical address) member by <image_base> plus the current file offset (this cannot be done right now, will need to be done once they are known)

   // -> throws away and reconstructs the sections table by keeping only the sections that are in the program header, and writes the section table at the start of the first thrown-away section

   // FIXME: what if a thrown away section is located between two program segments ? are they collapsed, moving the segments beyond it one slot down ?

 

   // reconstructed ELF:

   // ==== START OF FILE ====

   // ELF header

   // program header table

   //  (same sections, just p_addr offset changed)

   // section data 5 (named ".note.gnu.build-id")

   //  "............GNU....ZY.....c.o..l"

   // PROGRAM

   // sections table

   // + section 1: ALL ZEROES

   // + section 2: fileoffs 0x21a8 size 0xfd --> "QNX_info" --> QNX binary description: "NAME=pci_debug2.so.3.0\nDESCRIPTION=PCI Server System Debug Module\nDATE=2023/11/19-10:01:13-EST\nSTATE=lookup\nHOST=docker-n1.bts.rim.net\nUSER=builder\nVERSION=QNXOS_main\nTAGID=QNXOS_800-135\nPACKAGE=com.qnx.qnx800.target.pci.debug/3.0.0.00135T202311191043L\n"

   // + section 3: fileoffs 0x22a5 size 0x1c --> ".gnu_debuglink" --> indicates the debug file and its checksum: "pci_debug2.so.3.0.sym" "\0\0\0" "VX2p"

   // + section 4: fileoffs 0x22c1 size 0x2ad --> "QNX_usage" --> HELP TEXT: "\n-------------------------------------------------------------------------------\n%C\n\nThis module implements debug logging for all PCI server modules. It is\nincluded by setting the environment variable PCI_DEBUG_MODULE and uses\nthe slogger2 APIs.\nNOTE:.On systems which support slogger2, you are encouraged to use this module.instead of pci_debug.so...Release History.---------------..3.0 - This module is functionally equivalent to the previous 2.x version.      however it is incompatible with all pre v3.x PCI components..2.1 - fixes a bug whereby if slogger2 is not running and the PCI_DEBUG_MODULE.      environment variable is set, the client will SIGSEGV..2.0 - initial release.."

   // + section 5: fileoffs 0x190 size 0x32 --> ".note.gnu.build-id" --> GNU build ID

   // + section 6: fileoffs 0x256e size 0x40 --> ".shstrtab" --> sections names strings table

   // section data 2 (named "QNX_info")

   //  (QNX binary description)

   // section data 3 (named ".gnu_debuglink")

   //  (debug file)

   // section data 4 (named "QNX_usage")

   //  (help text)

   // section data 6 (named ".shstrtab")

   //  "\0"

   //  ".shstrtab\0"

   //  "QNX_info\0"

   //  ".gnu_debuglink\0"

   //  "QNX_usage\0"

   //  ".note.gnu.build-id\0"

   // ==== END OF FILE ====

 

   #define ELFHDR ((elf_header_t *) file->bytes) // this convenient definition will make sure the ELF header points at the right location, even after entry_parms.data->byte is reallocated

   #define ADD_SECTION(section_name,section_ptr) do { \

 

   typedef struct elf_section_s

   {

      const char *name;

      elf_section_header_t header;

      buffer_t data;

   } elf_section_t;

 

   const elf_section_header_t *shdr;

   elf_program_header_t *phdr;

   elf_program_header_t *other_phdr;

   elf_section_t *elf_sections = NULL; // mallocated

   elf_section_t *elf_section = NULL;

   size_t elf_section_count = 0;

   size_t new_shdrtable_offset;

   size_t new_shdrtable_len;

   size_t sectiondata_start;

   size_t sectiondata_size;

   size_t size_in_memory;

   size_t size_in_file;

   size_t file_offset;

   size_t array_index;

   size_t table_index;

   size_t table_count;

 

   // 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++)

   {

      phdr = (elf_program_header_t *) &file->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

      file_offset    = ELF_GET_NUMERIC (ELFHDR, phdr, file_offset); // get this ELF segment's start offset in the ELF file

      size_in_memory = ELF_GET_NUMERIC (ELFHDR, phdr, size_in_memory); // get this ELF segment's occupied size in memory

      size_in_file   = ELF_GET_NUMERIC (ELFHDR, phdr, size_in_file); // get this ELF segment's occupied size in the ELF file

      if (should_align_segsize_with_ramsize && (size_in_memory != size_in_file)) // should we align this segment's file size with its claimed RAM size ? (such is the case for e.g. procnto)

      {

         if (size_in_memory > size_in_file) // is it bigger ? if so, make sure we won't be overwriting other segments beyond this one

         {

            for (array_index = 0; array_index < table_count; array_index++)

            {

               other_phdr = (elf_program_header_t *) &file->bytes[ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_item_size) * array_index]; // quick access to program header

               if (other_phdr == phdr)

                  continue; // skip self

               if (ELF_GET_NUMERIC (ELFHDR, other_phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, other_phdr, size_in_file) < file_offset)

                  continue; // skip segments that are located before this one

               if (ELF_GET_NUMERIC (ELFHDR, other_phdr, file_offset) > file_offset + size_in_memory)

                  continue; // skip segments that are located after this one, including its corrected size

               DIE_WITH_EXITCODE (1, "remapping ELF segment would overwrite segment #%zd in the same file", array_index);

            }

 

            // finally, memset() the extra area

            Buffer_WriteAt (file, file_offset + size_in_memory, NULL, 0); // reallocate the ELF file data buffer if necessary

            phdr = (elf_program_header_t *) &file->bytes[ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_item_size) * table_index]; // restore access to program header (which may have moved)

            memset (&file->bytes[file_offset + size_in_file], 0, size_in_memory - size_in_file); // and write zeroes over the extra space

         }

         ELF_SET_NUMERIC (ELFHDR, phdr, size_in_file, size_in_memory); // patch this segment's size in the ELF file so that it matches the RAM size

      }

   }

 

   // now parse the program header table, and measure the farthest offset known by this table where we'll write the reconstructed section headers table

   new_shdrtable_offset = 0;

   table_count = ELF_GET_NUMERIC (ELFHDR, ELFHDR, program_header_table_len);

   for (table_index = 0; table_index < table_count; table_index++)

   {

      phdr = (elf_program_header_t *) &file->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

      if (ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_file) > new_shdrtable_offset)

         new_shdrtable_offset = ELF_GET_NUMERIC (ELFHDR, phdr, file_offset) + ELF_GET_NUMERIC (ELFHDR, phdr, size_in_file); // keep track of the farthest offset known by the program headers table

   }

   /*

   //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

 

   // go through the saved sections array and see if such an ELF section is present in the ELF file

   for (array_index = 0; array_index < saved_section_count; array_index++)

      if ((shdr = elf_get_section_header_by_name (ELFHDR, saved_sections[array_index])) != NULL) // does this ELF have such a section ?

      {

         ADD_SECTION (saved_sections[array_index], &elf_section); // yes, so save it

         sectiondata_start = ELF_GET_NUMERIC (ELFHDR, shdr, file_offset); // identify section data start offset

         sectiondata_size = ELF_GET_NUMERIC (ELFHDR, shdr, size); // identify section data length

         if (sectiondata_start + sectiondata_size >= new_shdrtable_offset) // should this section be moved ?

            ASSERT_WITH_ERRNO (Buffer_InitWithData (&elf_section->data, &file->bytes[sectiondata_start], sectiondata_size)); // have a copy of this section's data

         else

            Buffer_Initialize (&elf_section->data); // this section is located before the place where we'll write the new section headers table, thus it doesn't need to be moved

         //LOG_DEBUG ("%s: section '%s' start 0x%llx len 0x%llx", indicative_pathname, saved_ELF_sections[array_index], (unsigned long long) sectiondata_start, (unsigned long long) sectiondata_size);

 

         // prepare this section's "fixed" header

         memcpy (&elf_section->header, shdr, ELF_STRUCT_SIZE (ELFHDR, shdr)); // have a copy of the old section header first

         ELF_SET_NUMERIC (ELFHDR, &elf_section->header, name_offset, Buffer_LocateOrAppendIfNecessaryAndReturnOffsetOf (&elf_sections[0].data, elf_section->name)); // make sure this section name is in the ELF sections section header strings table and update the relative offset of the section name

      }

 

   // jump over the new section headers table and write the saved sections data after the section headers table

   file->size = new_shdrtable_offset + (1 + elf_section_count) * ELF_STRUCT_SIZE (ELFHDR, &elf_sections[0].header); // start by truncating the ELF file: assume there are no sections beyond the section headers table until known otherwise

   for (table_index = 1; table_index < elf_section_count; table_index++)

   {

      elf_section = &elf_sections[table_index]; // quick access to ELF section about to be written

      if (elf_section->data.bytes != NULL) // was this section data backed up waiting to be relocated ?

      {

         ELF_SET_NUMERIC (ELFHDR, &elf_section->header, file_offset, file->size); // fix section offset

         Buffer_AppendBuffer (file, &elf_section->data); // append this section's data to the ELF file

      }

   }

   // write the section header strings table as the last section

   elf_section = &elf_sections[0]; // quick access to ELF section about to be written

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, name_offset, Buffer_LocateOrAppendIfNecessaryAndReturnOffsetOf (&elf_sections[0].data, elf_section->name)); // update the relative offset of the section name

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, type, ELF_SECTIONTYPE_STRINGTABLE); // section type (SHT_STRTAB)

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, flags, 0); // section flags (we could set SHF_STRINGS i.e. 0x20 here, but mkifs does not, so mimic that)

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, virtual_addr, 0); // this section does not need to be mapped

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, file_offset, file->size); // fix section offset

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, size, elf_sections[0].data.size); // section size

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, linked_index, 0); // this section is not linked to any other

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, info, 0); // this section has no additional info

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, alignment, 1); // this section is byte-aligned

   ELF_SET_NUMERIC (ELFHDR, &elf_section->header, entry_size, 0); // this section is not a table, so entry_size is zero

   Buffer_AppendBuffer (file, &elf_section->data); // append section headers strings table section data to ELF file

 

   // now write the section headers table

   memset (&file->bytes[new_shdrtable_offset], 0, ELF_STRUCT_SIZE (ELFHDR, &elf_sections[0].header)); // the first section header is always zerofilled

   for (table_index = 1; table_index < elf_section_count; table_index++)

      Buffer_WriteAt (file, new_shdrtable_offset + table_index * ELF_STRUCT_SIZE (ELFHDR, &elf_sections[table_index].header), &elf_sections[table_index].header, ELF_STRUCT_SIZE (ELFHDR, &elf_sections[table_index].header)); // write each section header

   Buffer_WriteAt (file, new_shdrtable_offset + table_index * ELF_STRUCT_SIZE (ELFHDR, &elf_sections[table_index].header), &elf_sections[0].header, ELF_STRUCT_SIZE (ELFHDR, &elf_sections[0].header)); // write the section header names section header last

 

   // and finally fix the ELF master header

   new_shdrtable_len = 1 + elf_section_count; // take in account that the first entry in the section headers table is empty

   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, 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

 

   #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)

   {

      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

      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"));

      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"));

      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"));

      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"

   STRINGARRAY_PUSH (&linker_argv, NULL); // don't forget to terminate the argv array with a NULL pointer

   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);

   }

   _spawnv (_P_WAIT, linker.pathname, linker_argv.args); // spawn the linker and produce a relinked startup (wait for completion)

   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);

   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 aps_partnames = { NULL, 0 };

   static int inode_count = 0; // will be preincremented each time this function is called

 

   static const char *preserved_kernel_sections[] = { "QNX_info" };

 

   typedef struct scriptcmd_s

   {

      char *argv0;

      int cpu_number;

      bool is_external;

      int priority;

      int sched_policy;

      int aps_partindex;

      bool is_session_leader;

      bool is_background_task;

      bool has_debug_flag;

   } scriptcmd_t;

 

   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 };

   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;

   buffer_t compiled_scriptline;

   buffer_t *shstrtab = NULL;

   const char *canonical_dylib_name;

   const char *dynamic_strings; // strings table of the ".dynamic" section

   const char *last_dirsep;

   size_t array_index;

   size_t line_index;

   size_t fsentry_index;

   size_t pathbit_len;

   size_t wait_time;

   char *resolved_pathname;

   char *linebit_start;

   char *write_ptr;

   char *read_ptr;

   char *token;

   char *value;

   char *ctx;

   void *reallocated_ptr;

   void *old_data;

   bool is_quoted_context;

   bool is_end_of_line;

   struct stat stat_buf;

   fsentry_t *fsentry;

   int retval;

 

   // initial allocation (per thread)

   if (candidate_pathname == NULL)

   {

      candidate_pathname = malloc (MAXPATHLEN);

      ASSERT_WITH_ERRNO (candidate_pathname);

   }

 

   if (S_ISDIR (entry_parms->st_mode)) // are we storing a directory ?

   {

      if ((buildhost_pathname != NULL) && (buildhost_pathname[0] != 0)) // was a source file pathname supplied ?

      {

         memcpy (&default_parms, entry_parms, sizeof (parms_t)); // apply current entry parameters when including a directory recursively

         add_directory_contents_recursively (fsentries, fsentry_count, buildhost_pathname, strlen (buildhost_pathname), &default_parms); // if so, add this diretory contents recursively

      }

      LOG_INFO ("directory: ino 0x%x uid %d gid %d mode 0%o path \"%s\"", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname);

   }

   else if (S_ISLNK (entry_parms->st_mode)) // else are we storing a symbolic link ?

   {

      // 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 ("symlink: ino 0x%x uid %d gid %d mode 0%o path \"%s\" -> \"%s\"", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data.bytes);

      }

      else if (buildhost_pathname != NULL) // else was a source file pathname supplied ?

      {

         entry_parms->data.bytes = malloc (MAXPATHLEN); // allocate enough space for symlink data

         ASSERT_WITH_ERRNO (entry_parms->data.bytes);

         retval = readlink (buildhost_pathname, (char *) entry_parms->data.bytes, MAXPATHLEN); // read symlink contents

         ASSERT_WITH_ERRNO (retval > 0);

         entry_parms->data.size = retval; // save symlink target length

      }

      else

         DIE_WITH_EXITCODE (1, "unexpected code path: can't store a symlink without neither explicit contents nor a host pathname. This is a bug in the program. Please contact the author.");

   }

   else if (S_ISFIFO (entry_parms->st_mode)) // else are we storing a FIFO ?

   {

      if ((entry_parms->data.bytes == NULL) || (strchr ((char *) entry_parms->data.bytes, ':') == NULL))

         DIE_WITH_EXITCODE (1, "device entry \"%s\" malformed (no 'dev:rdev' pair)", stored_pathname);

      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) // [startup=...]

      {

         // parse each line of contents

         ASSERT (entry_parms->data.size > 0, "kernel specification without inline contents");

 

         // parse buffer (non-destructively) line after line

         Buffer_Initialize (&current_line);

         for (line_index = 0; Buffer_GetNthLine (&entry_parms->data, line_index, &current_line); line_index++)

         {

            read_ptr = (char *) current_line.bytes;

            while (isspace (*read_ptr))

               read_ptr++; // skip leading spaces

            if ((*read_ptr == '#') || (*read_ptr == 0))

               continue; // skip comments and empty lines

 

            // format of a line: [attributes] [env assignation] [...] [executable] [arg] [...] [comment]

            // example: "[uid=0 gid=0 perms=0700] CONFIG_PATH=/proc/boot:/etc procnto-smp-instr -v -mr -d 0777 -u 0777"

 

            LOG_DEBUG ("parsing line: %s", read_ptr);

 

            // does this line start with an attribute block ?

            if (*read_ptr == '[')

            {

               read_ptr++; // skip the leading square bracket

               linebit_start = read_ptr; // remember where it starts

               is_quoted_context = false; // reach the next unescaped closing square bracket that is not between quotes

               while ((*read_ptr != 0) && !((*read_ptr == ']') && (read_ptr[-1] != '\\') && !is_quoted_context))

               {

                  if (*read_ptr == '"')

                     is_quoted_context ^= true; // remember when we're between quotes

                  else if (!is_quoted_context && (*read_ptr == ' '))

                     *read_ptr = RECORD_SEP[0]; // turn all spaces outside quoted contexts into an ASCII record separator to ease token splitting

                  read_ptr++; // reach the next unescaped closing square bracket

               }

               if (*read_ptr != ']')

               {

                  LOG ("warning", 0, "syntax error in \"%s\" line %zd of inline document '%s': unterminated attributes block (skipping)", buildfile_pathname, 1 + line_index, stored_pathname);

                  continue; // invalid attribute block, skip line

               }

               is_end_of_line = (*read_ptr == 0); // see if we're at the end of line already

               *read_ptr = 0; // end the attribute block in all cases so that it is a parsable C string

 

               // now parse the attribute tokens (NOTE: THE LIST OF ALLOWED ATTRIBUTES HERE IS NOT DOCUMENTED)

               token = strtok_r (linebit_start, RECORD_SEP, &ctx);

               while (token != NULL)

               {

                  #define REACH_TOKEN_VALUE() do { value = strchr (token, '=') + 1; if (*value == '"') value++; } while (0)

                  if (false) {}

                  else if (strncmp (token, "prefix=",  7) == 0) { REACH_TOKEN_VALUE (); entry_parms->prefix  = (*value == '/' ? value + 1 : value); } // skip possible leading slash in prefix (NOTE: stolen pointer. Do not free.)

                  else if (strncmp (token, "uid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms->uid     = (int) read_integer (value, 10); }

                  else if (strncmp (token, "gid=",     4) == 0) { REACH_TOKEN_VALUE (); entry_parms->gid     = (int) read_integer (value, 10); }

                  else if (strncmp (token, "perms=",   6) == 0) { REACH_TOKEN_VALUE (); entry_parms->perms   = (int) read_integer (value, 8); }

                  else if (strcmp (token, "+followlink") == 0) entry_parms->should_follow_symlinks = true;

                  else if (strcmp (token, "-followlink") == 0) entry_parms->should_follow_symlinks = false;

                  else if (strcmp (token, "+keeplinked") == 0) entry_parms->should_keep_ld_output = true;

                  else if (strcmp (token, "-keeplinked") == 0) entry_parms->should_keep_ld_output = false;

                  else LOG_WARNING ("unimplemented bootstrap executable attribute in \"%s\" line %zd of inline document '%s': '%s'", buildfile_pathname, 1 + line_index, stored_pathname, token);

                  #undef REACH_TOKEN_VALUE

                  token = strtok_r (NULL, RECORD_SEP, &ctx); // proceed to next attribute token

               }

 

               if (is_end_of_line)

                  continue; // if end of line was reached, proceed to the next line

               else

                  read_ptr++; // else reach the next character (after the NUL split) and continue processing the same line

            } // end of "this line starts with an attributes block"

 

            // at this point we are past the attributes block

 

            // reset contextual argv/envp arrays

            line_argv.args = NULL;

            line_argv.count = 0;

            line_envp.args = NULL;

            line_envp.count = 0;

 

            // now read each word (or quoted group of words), unescaping escaped characters

            while (*read_ptr != 0)

            {

               while ((*read_ptr != 0) && isspace (*read_ptr))

                  read_ptr++; // skip intermediate spaces and reach the next word

 

               if (*read_ptr == '#')

                  break; // if the rest of the line is commented out, stop parsing it and proceed to the next line

 

               linebit_start = read_ptr; // remember the word (or quoted group of words) starts here

               write_ptr = read_ptr;

               is_quoted_context = (*read_ptr == '"'); // see if we're entering a quoted context or not

               if (is_quoted_context)

                  read_ptr++; // skip a possible initial quote in the word

               while ((*read_ptr != 0) && ((!is_quoted_context && !isspace (*read_ptr)) || (is_quoted_context && (*read_ptr != '"'))))

               {

                  if (*read_ptr == '\\')

                     read_ptr++; // unescape characters that are escaped with '\' by advancing the read pointer

                  *write_ptr++ = *read_ptr++; // recopy characters as we read them

               }

               is_end_of_line = (*read_ptr == 0); // see if we're at the end of line already

               *write_ptr = 0; // stop the rewritten string here

 

               // end of word, i.e. we reached either a closing quote or a space. The string bit has been rewritted at linebit_start without quotes and with characters unescaped.

 

               if ((strchr (linebit_start, '=') != NULL) && (line_argv.count == 0)) // is it an assignation AND have we not started constructing argv yet?

               {

                  STRINGARRAY_PUSH (&line_envp, linebit_start); // linebit_start is of the form "NAME=VALUE": it's an environment variable assignation

                  LOG_DEBUG ("collected envp: [%s]", linebit_start);

               }

               else // it's an executable argument (argv)

               {

                  STRINGARRAY_PUSH (&line_argv, linebit_start); // linebit_start is either NOT of the form "NAME=VALUE" OR we started constructing argv: it's a command-line argument

                  LOG_DEBUG ("collected argv: [%s]", linebit_start);

               }

 

               if (!is_end_of_line)

                  read_ptr++; // if we haven't reach the end of the line yet, advance to the next character (after the NUL split)

            } // end while (*read_ptr != 0)

 

            // we finished parsing the line

 

            // did we fill an executable argv? As per QNX docs, the first executable must be startup-*, the last executable must be procnto.

            if (line_argv.count > 0)

            {

               if (startup_argv.args == NULL)

               {

                  startup_argv.args = line_argv.args; // relocate these pointers to the right place

                  startup_argv.count = line_argv.count;

                  STRINGARRAY_FREE (&startup_envp);

                  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

                  for (array_index = 0; array_index < line_envp.count; array_index++)

                     STRINGARRAY_PUSH (&startup_envp, line_envp.args[array_index]); // concatenate the local 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

                  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

                  for (array_index = 0; array_index < line_envp.count; array_index++)

                     STRINGARRAY_PUSH (&procnto_envp, line_envp.args[array_index]); // concatenate the local 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;

            }

            else // this line contained no executable invokation, so stack up its envp assignations into the global envp array

               for (array_index = 0; array_index < line_envp.count; array_index++)

                  STRINGARRAY_PUSH (&global_envp, line_envp.args[array_index]);

 

            // release the contextual argv/envp arrays

            STRINGARRAY_FREE (&line_argv);

            STRINGARRAY_FREE (&line_envp);

 

         } // end for (line_index = 0; Buffer_GetNthLine (&entry_parms->data, line_index, &current_line); line_index++)

         Buffer_Forget (&entry_parms->data); // free the inline specification once it's parsed

 

         ASSERT (startup_argv.args && startup_argv.args[0] && *startup_argv.args[0], "the QNX startup executable (startup-*) is missing in this bootstrap inline specification");

         ASSERT (procnto_argv.args && procnto_argv.args[0] && *procnto_argv.args[0], "the QNX kernel (procnto-*) is missing in this bootstrap inline specification");

 

         // 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]);

 

         // prelink procnto, map its .text segment at the right virtual address for the IFS and stamp in its executable arguments

         // then store the result in this entry's data blob

         prelink (entry_parms->search, // binary executable search path

                  (boot_type == BOOTTYPE_UEFI ? ".text=0xffff800000002000" : ".text=0xffff800000001000"), // FIXME: wild assumption!

                  &procnto_argv, &procnto_envp, // executable arguments (including its name) and environment to stamp in it

                  entry_parms->should_keep_ld_output, // whether to keep the linker-produced output file

                  &entry_parms->data, // buffer where to save the output

                  &procnto_bootargs_offset); // where to save the offset of the boot arguments