Integrate PATH traversal logic and binary format logic

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@5441 42af7a65-404d-4744-a932-0658087f49c3

binfmt/binfmt_dumpmodule.c

@@ -70,7 +70,7 @@
  ***********************************************************************/
 
 /***********************************************************************
- * Name: load_module
+ * Name: dump_module
  *
  * Description:
  *   Load a module into memory and prep it for execution.

binfmt/binfmt_exepath.c

@@ -85,7 +85,7 @@ struct exepath_s
  *   Initialize for the traversal of each value in the PATH variable.  The
  *   usage is sequence is as follows:
  *
- *   1) Call exepath_init() to initialze for the traversal.  exepath_init()
+ *   1) Call exepath_init() to initialize for the traversal.  exepath_init()
  *      will return an opaque handle that can then be provided to
  *      exepath_next() and exepath_release().
  *   2) Call exepath_next() repeatedly to examine every file that lies
@@ -163,7 +163,7 @@ EXEPATH_HANDLE exepath_init(void)
  *   memory.  This memory must be freed by the called by calling kfree().
  *
  *   NULL is returned if no path is found to any file with the provided
- *   'relpath' from any absolute path in the file variable.  In this case,
+ *   'relpath' from any absolute path in the PATH variable.  In this case,
  *   there is no point in calling exepath_next() further; exepath_release()
  *   must be called to release resources set aside by expath_init().
  *
@@ -263,7 +263,7 @@ FAR char *exepath_next(EXEPATH_HANDLE handle, FAR const char *relpath)
  * Name: exepath_release
  *
  * Description:
- *   Release all resources set aside by exepath_release when the handle value
+ *   Release all resources set aside by exepath_init() when the handle value
  *   was created.  The handle value is invalid on return from this function.
  *   Attempts to all exepath_next() or exepath_release() with such a 'stale'
  *   handle will result in undefined (i.e., not good) behavior.

binfmt/binfmt_loadmodule.c

@@ -43,6 +43,7 @@
 #include <debug.h>
 #include <errno.h>
 
+#include <nuttx/kmalloc.h>
 #include <nuttx/binfmt/binfmt.h>
 
 #include "binfmt_internal.h"
@@ -65,6 +66,57 @@
  * Private Functions
  ****************************************************************************/
 
+/****************************************************************************
+ * Name: load_absmodule
+ *
+ * Description:
+ *   Load a module into memory, bind it to an exported symbol take, and
+ *   prep the module for execution.  bin->filename is known to be an absolute
+ *   path to the file to be loaded.
+ *
+ * Returned Value:
+ *   Zero (OK) is returned on success; a negated errno value is returned on
+ *   failure.
+ *
+ ****************************************************************************/
+
+static int load_absmodule(FAR struct binary_s *bin)
+{
+  FAR struct binfmt_s *binfmt;
+  int ret = -ENOENT;
+
+  bdbg("Loading %s\n", bin->filename);
+
+  /* Disabling pre-emption should be sufficient protection while accessing
+   * the list of registered binary format handlers.
+   */
+
+  sched_lock();
+
+  /* Traverse the list of registered binary format handlers.  Stop
+   * when either (1) a handler recognized and loads the format, or
+   * (2) no handler recognizes the format.
+   */
+
+  for (binfmt = g_binfmts; binfmt; binfmt = binfmt->next)
+    {
+      /* Use this handler to try to load the format */
+
+      ret = binfmt->load(bin);
+      if (ret == OK)
+        {
+          /* Successfully loaded -- break out with ret == 0 */
+
+          bvdbg("Successfully loaded module %s\n", bin->filename);
+          dump_module(bin);
+          break;
+        }
+    }
+
+  sched_unlock();
+  return ret;
+}
+
 /****************************************************************************
  * Public Functions
  ****************************************************************************/
@@ -85,42 +137,72 @@
 
 int load_module(FAR struct binary_s *bin)
 {
-  FAR struct binfmt_s *binfmt;
-  int ret = -ENOENT;
+  int ret = -EINVAL;
+
+  /* Verify that we were provided something to work with */
 
 #ifdef CONFIG_DEBUG
   if (bin && bin->filename)
 #endif
     {
-      bdbg("Loading %s\n", bin->filename);
-
-      /* Disabling pre-emption should be sufficient protection while
-       * accessing the list of registered binary format handlers.
+      /* Were we given a relative path?  Or an absolute path to the file to
+       * be loaded.
        */
 
-      sched_lock();
-
-      /* Traverse the list of registered binary format handlers.  Stop
-       * when either (1) a handler recognized and loads the format, or
-       * (2) no handler recognizes the format.
-       */
-
-      for (binfmt = g_binfmts; binfmt; binfmt = binfmt->next)
+#ifdef CONFIG_BINFMT_EXEPATH
+      if (bin->filename[0] == '/')
         {
-          /* Use this handler to try to load the format */
+          FAR const char *relpath;
+          FAR char *fullpath;
+          EXEPATH_HANDLE handle;
 
-          ret = binfmt->load(bin);
-          if (ret == OK)
+          /* Set aside the relative path */
+
+          relpath = bin->filename;
+          ret     = -ENOENT;
+
+          /* Initialize to traverse the PATH variable */
+
+          handle = exepath_init();
+          if (handle)
             {
-              /* Successfully loaded -- break out with ret == 0 */
+              /* Get the next absolute file path */
 
-              bvdbg("Successfully loaded module %s\n", bin->filename);
-              dump_module(bin);
-              break;
+              while ((fullpath = exepath_next(handle, relpath)))
+                {
+                  /* Try to load the file at this path */
+
+                  bin->filename = fullpath;
+                  ret = load_absmodule(bin);
+
+                  /* Free the allocated fullpath */
+
+                  kfree(fullpath);
+
+                  /* Break out of the loop with ret == OK on success */
+
+                  if (ret == OK)
+                    {
+                      break;
+                    }
+                }
             }
-        }
 
-      sched_unlock();
+          /* Restore the relative path.  This is not needed for anything
+           * but debug output after the file has been loaded.
+           */
+
+          bin->filename = relpath;
+        }
+      else
+#endif
+        {
+          /* We already have the one and only absolute path to the file to
+           * be loaded.
+           */
+
+          ret = load_absmodule(bin);
+        }
     }
 
   /* This is an end-user function.  Return failures via errno */
@@ -131,6 +213,7 @@ int load_module(FAR struct binary_s *bin)
       errno = -ret;
       return ERROR;
     }
+
   return OK;
 }