Subversion Repositories QNX 8.QNX8 IFS tool

 

 

 

 

 

 

 

 

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

 

 

 

 

 

 

 

 

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_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 char image_processor[16] = "x86_64"; // default CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)

static char image_processor_base[16] = "x86_64"; // default base CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)

static char image_processor[16] = "aarch64le"; // default CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)

static char image_processor_base[16] = "aarch64"; // default base CPU type for which this image is built, either "x86_64" or "aarch64le" (will be used to find out the right include paths under $QNX_TARGET)

static char *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 char *bootfile_pathname = NULL;           // HACK: pathname to bootcode binary blob file to put at the start of a bootable IFS

static size_t bootfile_size = 0;                 // HACK: size of the bootcode binary blob file to put at the start of a bootable IFS

static char *startupfile_pathname = NULL;        // 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; // HACK: startup code entrypoint offset from image base for a bootable IFS

static char *kernelfile_pathname = NULL;         // HACK: pathname to precompiled kernel file blob to put in a bootable IFS

static size_t kernelfile_offset = 0;             // HACK: kernel file offset in bootable IFS

 

 

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); // 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_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, 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 char *indicative_pathname); // strips an ELF file buffer the way mkifs does it and returns whether it succeeded

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

   // 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, 0); // 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_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;

 

   void *reallocated_ptr;

   char *resolved_search_path;

   char *replacement;

   size_t old_searchpath_len;

   size_t new_searchpath_len;

   size_t replacement_len;

   size_t middlebit_len;

   size_t endbit_len;

   size_t defaultpath_index;

   struct stat stat_buf;

   int erase_index;

   char erased_char;

   char *varname;

   char *nextsep;

   char *endbit;

   char *token;

 

   // initial allocation (per thread)

   if (resolved_pathname == NULL)

   {

      resolved_pathname = malloc (MAXPATHLEN);

      ASSERT_WITH_ERRNO (resolved_pathname);

   }

 

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

   if (IS_DIRSEP (pathname[0])

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

       )

      strcpy_s (resolved_pathname, MAXPATHLEN, pathname); // in this case, it MUST exist at its designated location (either absolute or relative to the current working directory)

   else // the path is relative, 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]

 

      // 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 = strdup (search_paths_or_NULL_for_MKIFS_PATH_envvar);

         ASSERT_WITH_ERRNO (resolved_search_path);

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

                || (((token = strstr (resolved_search_path, "$")) != 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_searchpath_len = strlen (resolved_search_path); // 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

            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_searchpath_len = (size_t) token - (size_t) resolved_search_path + replacement_len + endbit_len; // measure updated search path len

            if (new_searchpath_len > old_searchpath_len)

            {

               reallocated_ptr = realloc (resolved_search_path, new_searchpath_len + 1); // grow it if necessary

               ASSERT_WITH_ERRNO (reallocated_ptr);

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

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

               resolved_search_path = 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

         }

 

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

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

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

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

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

      }

   }

 

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

   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)

      && (strstr (fsentry->u.file.path, "/procnto-smp-instr") == NULL)

       )

   {

 

      elf = (elf_header_t *) fsentry->u.file.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->u.file.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);

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

         if (segment_size != 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->u.file.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 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_program_header_t *phdr;

   const elf_section_header_t *shdr;

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

   size_t table_index;

   size_t table_count;

   size_t page_size;

 

   // find out the platform page size

   if (ELF_GET_NUMERIC (ELFHDR, ELFHDR, instruction_set) == ELF_MACHINE_X86_64)

      page_size = 4 * 1024; // 4 kb pages on Intel processors

   else if (ELF_GET_NUMERIC (ELFHDR, ELFHDR, instruction_set) == ELF_MACHINE_AARCH64)

      page_size = 16 * 1024; // 16 kb pages on ARM64

   else

   {

      errno = ENOTSUP; // unsupported architecture: set errno to something meaningful

      return (0); // and return an error value

   }

 

   // 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, page_size); // 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, page_size)));

 

   // 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 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 int inode_count = 0; // will be preincremented each time this function is called

 

   const char *stored_pathname_without_leading_slash;

   const char *original_stored_pathname = NULL;

   buffer_t *shstrtab = NULL;

   const char *canonical_dylib_name;

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

   const char *last_dirsep;

   char *global_envstring = NULL;

   size_t global_envstring_len = 0;

   size_t fsentry_index;

   char *startup_name = NULL;

   char *procnto_name = NULL;

   char *resolved_pathname;

   void *reallocated_ptr;

   void *old_data;

   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 ?

   {

      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_ISREG (entry_parms->st_mode)) // else are we storing a regular file ?

   {

      if (strcmp (stored_pathname, "/proc/boot/boot") == 0) // is it the kernel ?

      {

         // HACK: for now just consider the kernel as a binary blob

         // FIXME: reimplement properly

         char *linebit_start;

         char *content_line;

         char *write_ptr;

         char *token;

         char *value;

         char *ctx;

         bool is_quoted_context;

         bool was_string_split;

 

         // parse each line of contents

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

         for (content_line = strtok_r (entry_parms->data.bytes, "\n", &ctx); content_line != NULL; content_line = strtok_r (NULL, "\n", ctx))

         {

            while (isspace (*content_line))

               content_line++; // skip leading spaces

            if ((*content_line == '#') || (*content_line == 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", content_line);

 

            // does this line start with an attribute block ?

            if (*content_line == '[')

            {

               content_line++; // skip the leading square bracket

               linebit_start = content_line; // remember where it starts

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

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

               {

                  if (*content_line == '"')

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

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

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

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

               }

               if (*content_line != ']')

               {

                  LOG ("warning", 0, "syntax error in \"%s\" line %d: unterminated attributes block (skipping)", buildfile_pathname, lineno);

                  continue; // invalid attribute block, skip line

               }

               *content_line = 0; // end the attribute block 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); }

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

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

                  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 %d: '%s'", buildfile_pathname, lineno, token);

                  #undef REACH_TOKEN_VALUE

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

               }

 

               content_line++; // reach the next character

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

                  content_line++; // skip leading spaces

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

 

            // there's data in this line. We expect an executable OR a variable name. Read it and unescape escaped characters

            while (*content_line != 0)

            {

               linebit_start = content_line; // remember the name starts here

               write_ptr = linebit_start;

               is_quoted_context = (*content_line == '"');

               if (is_quoted_context)

                  content_line++; // skip a possible initial quote in the name

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

               {

                  if (*content_line == '\\')

                  {

                     content_line++;

                     *write_ptr++ = *content_line; // unescape characters that are escaped with '\'

                  }

                  else

                     *write_ptr++ = *content_line;

                  content_line++;

               }

 

               // we reached a closing quote, a space OR an equal sign

               if (*content_line == '=')

               {

                  // it's an environment variable assignation

                  *write_ptr++ = *content_line++; // skip the equal sign

                  is_quoted_context = (*content_line == '"');

                  if (is_quoted_context)

                     content_line++; // skip a possible initial quote in the value

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

                  {

                     if (*content_line == '\\')

                     {

                        content_line++;

                        *write_ptr++ = *content_line; // unescape characters that are escaped with '\'

                     }

                     else

                        *write_ptr++ = *content_line;

                     content_line++;

                  }

                  if (*write_ptr != 0)

                  {

                     *write_ptr = 0; // terminate the string if necessary

                     was_string_split = true;

                  }

                  else

                     was_string_split = false;

                  if (is_quoted_context && (*content_line == '"'))

                     content_line++; // skip a possible final quote

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

                     content_line++; // skip spaces

 

                  // now linebit_start is of the form "NAME=VALUE"

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

 

                  // TODO: grow global_envstring

 

                  //reallocated_ptr = realloc (global_envstring, global_envstring_len + strlen ())

 

                  if (was_string_split)

                     *write_ptr = ' '; // restore string continuity for parsing to continue

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

                     content_line++; // skip spaces

               }

               else // it's either a closing quote or a space

               {

                  *write_ptr = 0; // terminate the string

                  if (is_quoted_context && (*content_line == '"'))

                     content_line++; // skip a possible final quote

 

                  LOG_DEBUG ("exe name: [%s]", linebit_start);

 

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

                     content_line++; // skip leading spaces

 

                  // it's an executable name. As per QNX docs, the first executable must be startup-*, the last executable must be procnto.

                  if (startup_name == NULL)

                     startup_name = strdup (linebit_start);

                  else

                  {

                     if (procnto_name != NULL)

                        free (procnto_name);

                     procnto_name = strdup (linebit_start);

                  }

 

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

                     break; // if we reach the end of the line, stop parsing

 

                  // what comes after now must be optional arguments

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

                     content_line++; // skip leading spaces

 

                  // FIXME: parse executable command-line arguments

 

                  break; // stop parsing once all the arguments have been read

               }

            }

         } // end of parsing

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

         entry_parms->data.bytes = NULL;

         entry_parms->data.len = 0;

 

         ASSERT (startup_name && *startup_name, "the QNX startup executable (startup-*) is missing in this bootstrap inline specification");

         ASSERT (procnto_name && *procnto_name, "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_name);

         LOG_DEBUG ("Kernel: %s", procnto_name);

 

         sprintf (candidate_pathname, "%s/%s", (entry_parms->prefix != NULL ? entry_parms->prefix : ""), procnto_name); // fix the entry name

         stored_pathname = candidate_pathname;

         entry_parms->extra_ino_flags |= /*IFS_INO_PROCESSED_ELF | */IFS_INO_BOOTSTRAP_EXE; // procnto needs to have these flags stamped on the inode

         entry_parms->st_mode = S_IFREG | entry_parms->perms; // apply specified procnto permissions

         image_kernel_ino = entry_parms->extra_ino_flags | (inode_count + 1);

 

         static thread_local char linker_pathname[MAXPATHLEN] = "";

         static thread_local char linker_sysroot_arg[MAXPATHLEN] = "";

         static thread_local char linker_script_pathname_arg[MAXPATHLEN] = "";

         static thread_local char procnto_buildhost_pathname[MAXPATHLEN] = "";

         static thread_local char procnto_sym_filename[MAXPATHLEN] = "";

 

         // construct the arguments that are based on environment variables (infer QNX_HOST from QNX_TARGET)

         sprintf (linker_pathname, "%s/../../host/win64/x86_64/usr/bin/%s-ld.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 (linker_pathname, "%s/../../host/linux/x86_64/usr/bin/%s-ld", QNX_TARGET, (strcmp (image_processor, "x86_64") == 0 ? "x86_64-pc-nto-qnx8.0.0" : "aarch64-unknown-nto-qnx8.0.0"));

         sprintf (linker_pathname, "%s/../../host/qnx8/x86_64/usr/bin/%s-ld", 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 (linker_sysroot_arg, "--sysroot=%s/%s/", QNX_TARGET, image_processor);

         sprintf (linker_script_pathname_arg, "-T%s/%s/lib/nto.link", QNX_TARGET, image_processor);

 

         resolved_pathname = resolve_pathname (procnto_name, entry_parms->search); // locate the procnto kernel location

         ASSERT (resolved_pathname, "QNX kernel \"%s\" not found in search path", procnto_name);

         strcpy (procnto_buildhost_pathname, resolved_pathname);

 

         sprintf_s (procnto_sym_filename, sizeof (procnto_sym_filename), "%s.sym%s", procnto_name, sym_suffix);

 

         const char *linker_argv[] = // construct the linker invokation argv

         {

            strrchr (linker_pathname, '/') + 1, // "${TARGET_TRIPLE}-ld"

            linker_sysroot_arg, // "--sysroot=${QNX_TARGET}/${TARGET_CPU}/"

            linker_script_pathname_arg, // "-T${QNX_TARGET}/${TARGET_CPU}/lib/nto.link"

            "--section-start",

            ".text=0xffff800000001000",

            "--no-relax",

            procnto_buildhost_pathname, // "${QNX_TARGET}/${TARGET_CPU}/boot/sys/procnto-smp-instr"

            "-o",

            procnto_sym_filename, // "procnto-smp-instr.sym"

            NULL

         };

         if (verbose_level > 2)

         {

            fprintf (stderr, "ifstool: calling:");

            for (table_index = 0; table_index < sizeof (linker_argv) / sizeof (linker_argv[0]) - 1; table_index++)

               fprintf (stderr, " '%s'", linker_argv[table_index]);

            fputc ('\n', stderr);

         }

         _spawnv (_P_WAIT, linker_pathname, linker_argv); // spawn the linker and produce a stripped procnto (wait for completion)

         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

 

         // now strip this prelinked ELF kernel file

         Buffer_StripELFFile (&entry_parms->data, (const char **) saved_ELF_sections, 1, stored_pathname); // strip the ELF file as per QNX docs (only keep ONE section, which is "QNX_info")

         entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF; // mark this inode as a preprocessed ELF file

 

         /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */

         /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */

         /* HACK */

         /* HACK */ sprintf_s (candidate_pathname, MAXPATHLEN, "%s/procnto-smp-instr", (entry_parms->prefix != NULL ? entry_parms->prefix : "")); // HACK: fix the entry name

         /* HACK */ stored_pathname = candidate_pathname;

         /* HACK */ entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE; // procnto needs to have these flags stamped on the inode

         /* HACK */ entry_parms->st_mode = S_IFREG | 0700; // procnto requires 0700 permissions

         /* HACK */ image_kernel_ino = entry_parms->extra_ino_flags | (inode_count + 1);

         /* HACK */ free (entry_parms->data.bytes); // discard inline contents

         /* HACK */ Buffer_Initialize (&entry_parms->data);

         /* HACK */ if (!Buffer_ReadFromFile (&entry_parms->data, kernelfile_pathname)) // read kernel file as a precompiled binary blob

         /* HACK */ {

         /* HACK */    fprintf (stderr, "fatal error: unable to read precompiled kernel file \"%s\" specified in --kernelfile argument\n", kernelfile_pathname);

         /* HACK */    exit (1);

         /* HACK */ }

         /* HACK */

         /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */

         /* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK *//* HACK */

      }

      else if (entry_parms->is_compiled_bootscript) // else is it a startup script ?

         image_bootscript_ino = inode_count + 1; // save boot script inode number for image header

 

      // 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: %s", buildhost_pathname, buildfile_pathname, lineno, 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;

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

      }

      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

      {

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

            const elf_section_header_t *shdr_dynstr = elf_get_section_header_by_name (ELFHDR, ".dynstr");

 

            // make sure we have both the dynamic section header and its own strings table header

            if ((shdr_dynamic != NULL) && (shdr_dynstr != NULL))

            {

               dynamic_strings = (char *) &entry_parms->data.bytes[ELF_GET_NUMERIC (ELFHDR, shdr_dynstr, file_offset)]; // quick access to dynamic sections strings table

 

               // walk through the dynamic section, look for the DT_SONAME entry

               canonical_dylib_name = NULL; // assume none until told otherwise

               for (elf_dynamic_section_entry_t *dynamic_entry = (elf_dynamic_section_entry_t *) &entry_parms->data.bytes[ELF_GET_NUMERIC (ELFHDR, shdr_dynamic, file_offset)];

                    (ELF_GET_NUMERIC (ELFHDR, dynamic_entry, tag) != ELF_DT_NULL);

                    dynamic_entry = (elf_dynamic_section_entry_t *) ((uint8_t *) dynamic_entry + ELF_STRUCT_SIZE (ELFHDR, dynamic_entry)))

                  if (ELF_GET_NUMERIC (ELFHDR, dynamic_entry, tag) == ELF_DT_SONAME)

                  {

                     canonical_dylib_name = dynamic_strings + ELF_GET_NUMERIC (ELFHDR, dynamic_entry, value);

                     break;

                  }

 

               // do we have it ?

               if ((canonical_dylib_name != NULL) && (canonical_dylib_name[0] != 0))

               {

                  sprintf_s (candidate_pathname, MAXPATHLEN, "%s/%s", (entry_parms->prefix != NULL ? entry_parms->prefix : ""), canonical_dylib_name);

                  if (strcmp (candidate_pathname, stored_pathname) != 0) // claimed dylib name differs from passed name ?

                  {

                     original_stored_pathname = stored_pathname; // if so, remember to create a symlink here

                     stored_pathname = candidate_pathname;

                  }

               }

            }

         } // end if the file we're storing is a dylib

 

         // now strip this ELF file if necessary

         if (!(entry_parms->extra_ino_flags & IFS_INO_PROCESSED_ELF))

         {

            Buffer_StripELFFile (&entry_parms->data, (const char **) saved_ELF_sections, saved_ELF_section_count, stored_pathname); // strip the ELF file à la mkifs

            entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF; // mark this inode as a preprocessed ELF file

         } // end if the file is not yet a processed ELF

      } // end if the file we're storing is an ELF file

      #undef ELFHDR // undefine the macro that used to always point to the ELF header at the beginning of the file

   }

   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, 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 // we must be storing a FIFO

   {

      if ((entry_parms->data.bytes == NULL) || (strchr (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);

   }

 

   // have a pointer to where the stored pathname actually starts, without the leading slash

   stored_pathname_without_leading_slash = stored_pathname[0] == '/' ? &stored_pathname[1] : stored_pathname;

 

   // see if this item already has an entry in the current list of filesystem entries

   for (fsentry_index = 0; fsentry_index < *fsentry_count; fsentry_index++)

   {

      fsentry = &(*fsentries)[fsentry_index]; // quick access to fs entry slot

      if (   (S_ISDIR  (fsentry->header.mode) && (strcmp (fsentry->u.dir.path,     stored_pathname_without_leading_slash) == 0))

          || (S_ISREG  (fsentry->header.mode) && (strcmp (fsentry->u.file.path,    stored_pathname_without_leading_slash) == 0))

          || (S_ISLNK  (fsentry->header.mode) && (strcmp (fsentry->u.symlink.path, stored_pathname_without_leading_slash) == 0))

          || (S_ISFIFO (fsentry->header.mode) && (strcmp (fsentry->u.symlink.path, stored_pathname_without_leading_slash) == 0)))

         break; // stop searching as soon as we find a duplicate

   }

 

   // is there already an entry for this item ?

   if (fsentry_index < *fsentry_count)

   {

      // if we should NOT ignore duplicates, bomb out, else just reuse that entry

      if (!entry_parms->should_ignore_duplicates)

         DIE_WITH_EXITCODE (1, "duplicate detected: entry \"%s\" specified in \"%s\" line %d already exists in IFS file", stored_pathname, buildfile_pathname, lineno);

   }

   else // this is a new entry: grow filesystem entries array to hold one more slot

   {

      reallocated_ptr = realloc (*fsentries, (*fsentry_count + 1) * sizeof (fsentry_t)); // attempt to reallocate

      ASSERT_WITH_ERRNO (reallocated_ptr); // verify

      *fsentries = reallocated_ptr; // save reallocated pointer

      fsentry = &(*fsentries)[*fsentry_count]; // quick access to fs entry slot

      (*fsentry_count)++; // remember there's one entry more in the array

   }

 

   // save (or update) this entry's parameters

   fsentry->header.extattr_offset = 0;

   fsentry->header.ino = entry_parms->extra_ino_flags | (++inode_count);

   fsentry->header.mode = entry_parms->st_mode;

   fsentry->header.gid = entry_parms->gid;

   fsentry->header.uid = entry_parms->uid;

   fsentry->header.mtime = (entry_parms->mtime == UINT32_MAX ? (uint32_t) time (NULL) : entry_parms->mtime);

   if (S_ISDIR (entry_parms->st_mode))

   {

      fsentry->u.dir.path = strdup (stored_pathname_without_leading_slash);

 

      fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + strlen (fsentry->u.dir.path) + 1, image_align); // now we can set the size

      fsentry->UNSAVED_was_data_written = true; // no data to save

   }

   else if (S_ISREG (entry_parms->st_mode))

   {

      fsentry->u.file.offset = WILL_BE_FILLED_LATER; // will be filled later in main() when the file's data blob will be written to the output file

      fsentry->u.file.size = (uint32_t) entry_parms->data.size;

      fsentry->u.file.path = strdup (stored_pathname_without_leading_slash);

      fsentry->u.file.UNSAVED_databuf = malloc (entry_parms->data.size);

      ASSERT_WITH_ERRNO (fsentry->u.file.UNSAVED_databuf);

      memcpy (fsentry->u.file.UNSAVED_databuf, entry_parms->data.bytes, entry_parms->data.size);

 

      fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint32_t) + sizeof (uint32_t) + strlen (fsentry->u.file.path) + 1, image_align); // now we can set the size

      fsentry->UNSAVED_was_data_written = false; // there *IS* data to save

   }

   else if (S_ISLNK (entry_parms->st_mode))

   {

      fsentry->u.symlink.sym_offset = (uint16_t) (strlen (stored_pathname_without_leading_slash) + 1);

      fsentry->u.symlink.sym_size = (uint16_t) entry_parms->data.size;

      fsentry->u.symlink.path = strdup (stored_pathname_without_leading_slash);

      fsentry->u.symlink.contents = strdup (entry_parms->data.bytes);

      ASSERT_WITH_ERRNO (fsentry->u.symlink.contents);

 

      fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint16_t) + sizeof (uint16_t) + (size_t) fsentry->u.symlink.sym_offset + fsentry->u.symlink.sym_size + 1, image_align); // now we can set the size

      fsentry->UNSAVED_was_data_written = true; // no data to save

   }

   else // necessarily a device node

   {

      fsentry->u.device.dev  = strtol (entry_parms->data.bytes, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers

      fsentry->u.device.rdev = strtol (strchr (entry_parms->data.bytes, ':') + 1, NULL, 0); // use strtol() to parse decimal (...), hexadecimal (0x...) and octal (0...) numbers

      fsentry->u.device.path = strdup (stored_pathname_without_leading_slash);

 

      fsentry->header.size = (uint16_t) ROUND_TO_UPPER_MULTIPLE (sizeof (fsentry->header) + sizeof (uint32_t) + sizeof (uint32_t) + strlen (fsentry->u.device.path), image_align); // now we can set the size

      fsentry->UNSAVED_was_data_written = true; // no data to save

   }

 

   // should we also add a symlink to this entry ? (in case we stored a dylib file under its canonical name)

   if (original_stored_pathname != NULL)