New interface task_spawn(); exec_builtin() now uses task_spawn(); All argv types should be char * const * not const char **

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

12 files changed, 970 insertions, 283 deletions

diff --git a/nuttx/sched/Makefile b/nuttx/sched/Makefile
index 961560176..0b0173306 100644
--- a/nuttx/sched/Makefile
+++ b/nuttx/sched/Makefile
@@ -48,6 +48,8 @@ TSK_SRCS += sched_removereadytorun.c sched_addprioritized.c sched_mergepending.c
 TSK_SRCS += sched_addblocked.c sched_removeblocked.c sched_free.c sched_gettcb.c
 TSK_SRCS += sched_verifytcb.c sched_releasetcb.c
 
+TSK_SRCS += task_spawn.c task_spawnparms.c
+
 ifneq ($(CONFIG_BINFMT_DISABLE),y)
 ifeq ($(CONFIG_LIBC_EXECFUNCS),y)
 TSK_SRCS += task_posixspawn.c
diff --git a/nuttx/sched/os_bringup.c b/nuttx/sched/os_bringup.c
index 610d8515a..85cb5e627 100644
--- a/nuttx/sched/os_bringup.c
+++ b/nuttx/sched/os_bringup.c
@@ -141,7 +141,7 @@ int os_bringup(void)
 
   g_pgworker = KERNEL_THREAD("pgfill", CONFIG_PAGING_DEFPRIO,
                              CONFIG_PAGING_STACKSIZE,
-                             (main_t)pg_worker, (const char **)NULL);
+                             (main_t)pg_worker, (FAR char * const *)NULL);
   ASSERT(g_pgworker != ERROR);
 #endif
 
@@ -154,7 +154,7 @@ int os_bringup(void)
 
   g_work[HPWORK].pid = KERNEL_THREAD("work0", CONFIG_SCHED_WORKPRIORITY,
                                      CONFIG_SCHED_WORKSTACKSIZE,
-                                     (main_t)work_hpthread, (const char **)NULL);
+                                     (main_t)work_hpthread, (FAR char * const *)NULL);
   ASSERT(g_work[HPWORK].pid != ERROR);
 
   /* Start a lower priority worker thread for other, non-critical continuation
@@ -166,7 +166,7 @@ int os_bringup(void)
 
   g_work[LPWORK].pid = KERNEL_THREAD("work1", CONFIG_SCHED_LPWORKPRIORITY,
                                      CONFIG_SCHED_LPWORKSTACKSIZE,
-                                     (main_t)work_lpthread, (const char **)NULL);
+                                     (main_t)work_lpthread, (FAR char * const *)NULL);
   ASSERT(g_work[LPWORK].pid != ERROR);
 #endif
 #endif
@@ -182,7 +182,7 @@ int os_bringup(void)
 
   init_taskid = TASK_CREATE("init", SCHED_PRIORITY_DEFAULT,
                             CONFIG_USERMAIN_STACKSIZE,
-                            (main_t)CONFIG_USER_ENTRYPOINT, (const char **)NULL);
+                            (main_t)CONFIG_USER_ENTRYPOINT, (FAR char * const *)NULL);
   ASSERT(init_taskid != ERROR);
 
   /* We an save a few bytes by discarding the IDLE thread's environment. */
diff --git a/nuttx/sched/os_internal.h b/nuttx/sched/os_internal.h
index 262a40ccc..73bff3422 100644
--- a/nuttx/sched/os_internal.h
+++ b/nuttx/sched/os_internal.h
@@ -259,16 +259,16 @@ void weak_function task_initialize(void);
 void task_start(void);
 int  task_schedsetup(FAR _TCB *tcb, int priority, start_t start,
                      main_t main, uint8_t ttype);
-int  task_argsetup(FAR _TCB *tcb, FAR const char *name, FAR const char *argv[]);
+int  task_argsetup(FAR _TCB *tcb, FAR const char *name, FAR char * const argv[]);
 void task_exithook(FAR _TCB *tcb, int status);
 int  task_deletecurrent(void);
 
 #ifndef CONFIG_CUSTOM_STACK
 int  kernel_thread(FAR const char *name, int priority, int stack_size,
-                   main_t entry, FAR const char *argv[]);
+                   main_t entry, FAR char * const argv[]);
 #else
 int  kernel_thread(FAR const char *name, int priority, main_t entry,
-                   FAR const char *argv[]);
+                   FAR char * const argv[]);
 #endif
 bool sched_addreadytorun(FAR _TCB *rtrtcb);
 bool sched_removereadytorun(FAR _TCB *rtrtcb);
diff --git a/nuttx/sched/sched_waitid.c b/nuttx/sched/sched_waitid.c
index 9c24189c4..26804f344 100644
--- a/nuttx/sched/sched_waitid.c
+++ b/nuttx/sched/sched_waitid.c
@@ -342,10 +342,10 @@ int waitid(idtype_t idtype, id_t id, FAR siginfo_t *info, int options)
         {
           /* We know that the child task was running okay we stared,
            * so we must have lost the signal.  What can we do?
-           * Let's claim we were interrupted by a signal.
+           * Let's return ECHILD.. that is at least informative.
            */
 
-          err = EINTR;
+          err = ECHILD;
           goto errout_with_errno;
         }
 #endif
diff --git a/nuttx/sched/sched_waitpid.c b/nuttx/sched/sched_waitpid.c
index 0285c2673..e44ef6e21 100644
--- a/nuttx/sched/sched_waitpid.c
+++ b/nuttx/sched/sched_waitpid.c
@@ -461,10 +461,10 @@ pid_t waitpid(pid_t pid, int *stat_loc, int options)
         {
           /* We know that the child task was running okay we stared,
            * so we must have lost the signal.  What can we do?
-           * Let's claim we were interrupted by a signal.
+           * Let's return ECHILD.. that is at least informative.
            */
 
-          err = EINTR;
+          err = ECHILD;
           goto errout_with_errno;
         }
 #endif
diff --git a/nuttx/sched/spawn_internal.h b/nuttx/sched/spawn_internal.h
new file mode 100644
index 000000000..6520f3947
--- /dev/null
+++ b/nuttx/sched/spawn_internal.h
@@ -0,0 +1,158 @@
+/****************************************************************************
+ * sched/spawn_internal.h
+ *
+ *   Copyright (C) 2013 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+#ifndef __SCHED_SPAWN_INERNAL_H
+#define __SCHED_SPAWN_INERNAL_H
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+#include <spawn.h>
+
+/****************************************************************************
+ * Pre-processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Type Definitions
+ ****************************************************************************/
+
+struct spawn_parms_s
+{
+  /* Common parameters */
+
+  int result;
+  FAR pid_t *pid;
+  FAR const posix_spawn_file_actions_t *file_actions;
+  FAR const posix_spawnattr_t *attr;
+  FAR char * const *argv;
+
+  /* Parameters that differ for posix_spawn[p] and task_spawn */
+
+  union
+  {
+    struct
+    {
+      FAR const char *path;
+    } posix;
+    struct
+    {
+      FAR const char *name;
+      main_t entry;
+    } task;
+  } u;
+};
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+extern sem_t g_spawn_parmsem;
+#ifndef CONFIG_SCHED_WAITPID
+extern sem_t g_spawn_execsem;
+#endif
+extern struct spawn_parms_s g_spawn_parms;
+
+/****************************************************************************
+ * Public Function Prototypes
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: spawn_semtake and spawn_semgive
+ *
+ * Description:
+ *   Give and take semaphores
+ *
+ * Input Parameters:
+ *
+ *   sem - The semaphore to act on.
+ *
+ * Returned Value:
+ *   None
+ *
+ ****************************************************************************/
+
+void spawn_semtake(FAR sem_t *sem);
+#define spawn_semgive(sem) sem_post(sem)
+
+/****************************************************************************
+ * Name: spawn_execattrs
+ *
+ * Description:
+ *   Set attributes of the new child task after it has been spawned.
+ *
+ * Input Parameters:
+ *
+ *   pid - The pid of the new task.
+ *   attr - The attributes to use
+ *
+ * Returned Value:
+ *   Errors are not reported by this function.  This is because errors
+ *   cannot occur, but ratther that the new task has already been started
+ *   so there is no graceful way to handle errors detected in this context
+ *   (unless we delete the new task and recover).
+ *
+ * Assumptions:
+ *   That task has been started but has not yet executed because pre-
+ *   emption is disabled.
+ *
+ ****************************************************************************/
+
+int spawn_execattrs(pid_t pid, FAR const posix_spawnattr_t *attr);
+
+/****************************************************************************
+ * Name: spawn_proxyattrs
+ *
+ * Description:
+ *   Set attributes of the proxy task before it has started the new child
+ *   task.
+ *
+ * Input Parameters:
+ *
+ *   pid - The pid of the new task.
+ *   attr - The attributes to use
+ *   file_actions - The attributes to use
+ *
+ * Returned Value:
+ *   0 (OK) on successed; A negated errno value is returned on failure.
+ *
+ ****************************************************************************/
+
+int spawn_proxyattrs(FAR const posix_spawnattr_t *attr,
+                     FAR const posix_spawn_file_actions_t *file_actions);
+
+#endif /* __SCHED_SPAWN_INERNAL_H */
diff --git a/nuttx/sched/task_create.c b/nuttx/sched/task_create.c
index 944743200..bcb9c77c0 100644
--- a/nuttx/sched/task_create.c
+++ b/nuttx/sched/task_create.c
@@ -100,10 +100,10 @@
 
 #ifndef CONFIG_CUSTOM_STACK
 static int thread_create(const char *name, uint8_t ttype, int priority,
-                         int stack_size, main_t entry, const char **argv)
+                         int stack_size, main_t entry, FAR char * const argv[])
 #else
 static int thread_create(const char *name, uint8_t ttype, int priority,
-                         main_t entry, const char **argv)
+                         main_t entry, FAR char * const argv[])
 #endif
 {
   FAR _TCB *tcb;
@@ -244,10 +244,10 @@ errout:
 
 #ifndef CONFIG_CUSTOM_STACK
 int task_create(const char *name, int priority,
-                int stack_size, main_t entry, const char *argv[])
+                int stack_size, main_t entry, FAR char * const argv[])
 #else
 int task_create(const char *name, int priority,
-                main_t entry, const char *argv[])
+                main_t entry, FAR char * const argv[])
 #endif
 {
 #ifndef CONFIG_CUSTOM_STACK
@@ -275,10 +275,10 @@ int task_create(const char *name, int priority,
 
 #ifndef CONFIG_CUSTOM_STACK
 int kernel_thread(const char *name, int priority,
-                  int stack_size, main_t entry, const char *argv[])
+                  int stack_size, main_t entry, FAR char * const argv[])
 #else
 int kernel_thread(const char *name, int priority,
-                  main_t entry, const char *argv[])
+                  main_t entry, FAR char * const argv[])
 #endif
 {
 #ifndef CONFIG_CUSTOM_STACK
diff --git a/nuttx/sched/task_init.c b/nuttx/sched/task_init.c
index 78f35bc2a..4214393e1 100644
--- a/nuttx/sched/task_init.c
+++ b/nuttx/sched/task_init.c
@@ -114,10 +114,10 @@
 #ifndef CONFIG_CUSTOM_STACK
 int task_init(FAR _TCB *tcb, const char *name, int priority,
               FAR uint32_t *stack, uint32_t stack_size,
-              main_t entry, const char *argv[])
+              main_t entry, FAR char * const argv[])
 #else
 int task_init(FAR _TCB *tcb, const char *name, int priority,
-              main_t entry, const char *argv[])
+              main_t entry, FAR char * const argv[])
 #endif
 {
   int errcode;
diff --git a/nuttx/sched/task_posixspawn.c b/nuttx/sched/task_posixspawn.c
index e9ad1fc45..f26391500 100644
--- a/nuttx/sched/task_posixspawn.c
+++ b/nuttx/sched/task_posixspawn.c
@@ -40,36 +40,19 @@
 #include <nuttx/config.h>
 
 #include <sys/wait.h>
-#include <unistd.h>
-#include <semaphore.h>
-#include <signal.h>
-#include <sched.h>
-#include <fcntl.h>
 #include <spawn.h>
-#include <errno.h>
-#include <assert.h>
 #include <debug.h>
 
 #include <nuttx/binfmt/binfmt.h>
-#include <nuttx/spawn.h>
 
 #include "os_internal.h"
 #include "group_internal.h"
+#include "spawn_internal.h"
 
 /****************************************************************************
  * Private Types
  ****************************************************************************/
 
-struct spawn_parms_s
-{
-  int result;
-  FAR pid_t *pid;
-  FAR const char *path;
-  FAR const posix_spawn_file_actions_t *file_actions;
-  FAR const posix_spawnattr_t *attr;
-  FAR char *const *argv;
-};
-
 /****************************************************************************
  * Public Data
  ****************************************************************************/
@@ -78,47 +61,12 @@ struct spawn_parms_s
  * Private Data
  ****************************************************************************/
 
-static sem_t g_ps_parmsem = SEM_INITIALIZER(1);
-#ifndef CONFIG_SCHED_WAITPID
-static sem_t g_ps_execsem = SEM_INITIALIZER(0);
-#endif
-static struct spawn_parms_s g_ps_parms;
-
 /****************************************************************************
  * Private Functions
  ****************************************************************************/
 
 /****************************************************************************
- * Name: spawn_semtake and spawn_semgive
- *
- * Description:
- *   Give and take semaphores
- *
- * Input Parameters:
- *
- *   sem - The semaphore to act on.
- *
- * Returned Value:
- *   None
- *
- ****************************************************************************/
-
-static void spawn_semtake(FAR sem_t *sem)
-{
-  int ret;
-
-  do
-    {
-      ret = sem_wait(sem);
-      ASSERT(ret == 0 || errno == EINTR);
-    }
-  while (ret != 0);
-}
-
-#define spawn_semgive(sem) sem_post(sem)
-
-/****************************************************************************
- * Name: spawn_exec
+ * Name: posix_spawn_exec
  *
  * Description:
  *   Execute the task from the file system.
@@ -156,11 +104,10 @@ static void spawn_semtake(FAR sem_t *sem)
  *
  ****************************************************************************/
 
-static int spawn_exec(FAR pid_t *pidp, FAR const char *path,
-                      FAR const posix_spawnattr_t *attr,
-                      FAR char *const argv[])
+static int posix_spawn_exec(FAR pid_t *pidp, FAR const char *path,
+                            FAR const posix_spawnattr_t *attr,
+                            FAR char * const argv[])
 {
-  struct sched_param param;
   FAR const struct symtab_s *symtab;
   int nsymbols;
   int pid;
@@ -181,7 +128,7 @@ static int spawn_exec(FAR pid_t *pidp, FAR const char *path,
 
   /* Start the task */
 
-  pid = exec(path, (FAR const char **)argv, symtab, nsymbols);
+  pid = exec(path, (FAR char * const *)argv, symtab, nsymbols);
   if (pid < 0)
     {
       ret = errno;
@@ -203,50 +150,7 @@ static int spawn_exec(FAR pid_t *pidp, FAR const char *path,
 
   if (attr)
     {
-      /* If we are only setting the priority, then call sched_setparm()
-       * to set the priority of the of the new task.
-       */
-
-      if ((attr->flags & POSIX_SPAWN_SETSCHEDPARAM) != 0)
-        {
-          /* Get the priority from the attrributes */
-
-          param.sched_priority = attr->priority;
-
-          /* If we are setting *both* the priority and the scheduler,
-           * then we will call sched_setscheduler() below.
-           */
-
-          if ((attr->flags & POSIX_SPAWN_SETSCHEDULER) == 0)
-            {
-              svdbg("Setting priority=%d for pid=%d\n",
-                    param.sched_priority, pid);
-
-              (void)sched_setparam(pid, &param);
-            }
-        }
-
-      /* If we are only changing the scheduling policy, then reset
-       * the priority to the default value (the same as this thread) in
-       * preparation for the sched_setscheduler() call below.
-       */
-
-      else if ((attr->flags & POSIX_SPAWN_SETSCHEDULER) != 0)
-        {
-          (void)sched_getparam(0, &param);
-        }
-
-      /* Are we setting the scheduling policy?  If so, use the priority
-       * setting determined above.
-       */
-
-      if ((attr->flags & POSIX_SPAWN_SETSCHEDULER) != 0)
-        {
-          svdbg("Setting policy=%d priority=%d for pid=%d\n",
-                attr->policy, param.sched_priority, pid);
-
-          (void)sched_setscheduler(pid, attr->policy, &param);
-        }
+      (void)spawn_execattrs(pid, attr);
     }
 
   /* Re-enable pre-emption and return */
@@ -257,94 +161,7 @@ errout:
 }
 
 /****************************************************************************
- * Name: spawn_close, spawn_dup2, and spawn_open
- *
- * Description:
- *   Implement individual file actions
- *
- * Input Parameters:
- *   action - describes the action to be performed
- *
- * Returned Value:
- *   posix_spawn() and posix_spawnp() will return zero on success.
- *   Otherwise, an error number will be returned as the function return
- *   value to indicate the error.
- *
- ****************************************************************************/
-
-static inline int spawn_close(FAR struct spawn_close_file_action_s *action)
-{
-  /* The return value from close() is ignored */
-
-  svdbg("Closing fd=%d\n", action->fd);
-
-  (void)close(action->fd);
-  return OK;
-}
-
-static inline int spawn_dup2(FAR struct spawn_dup2_file_action_s *action)
-{
-  int ret;
-
-  /* Perform the dup */
-
-  svdbg("Dup'ing %d->%d\n", action->fd1, action->fd2);
-
-  ret = dup2(action->fd1, action->fd2);
-  if (ret < 0)
-    {
-      int errcode = errno;
-
-      sdbg("ERROR: dup2 failed: %d\n", errcode);
-      return errcode;
-    }
-
-  return OK;
-}
-
-static inline int spawn_open(FAR struct spawn_open_file_action_s *action)
-{
-  int fd;
-  int ret = OK;
-
-  /* Open the file */
-
-  svdbg("Open'ing path=%s oflags=%04x mode=%04x\n",
-        action->path, action->oflags, action->mode);
-
-  fd = open(action->path, action->oflags, action->mode);
-  if (fd < 0)
-    {
-      ret = errno;
-      sdbg("ERROR: open failed: %d\n", ret);
-    }
-
-  /* Does the return file descriptor happen to match the required file
-   * desciptor number?
-   */
-
-  else if (fd != action->fd)
-    {
-      /* No.. dup2 to get the correct file number */
-
-      svdbg("Dup'ing %d->%d\n", fd, action->fd);
-
-      ret = dup2(fd, action->fd);
-      if (ret < 0)
-        {
-          ret = errno;
-          sdbg("ERROR: dup2 failed: %d\n", ret);
-        }
-
-      svdbg("Closing fd=%d\n", fd);
-      close(fd);
-    }
-
-  return ret;
-}
-
-/****************************************************************************
- * Name: spawn_proxy
+ * Name: posix_spawn_proxy
  *
  * Description:
  *   Perform file_actions, then execute the task from the file system.
@@ -357,11 +174,9 @@ static inline int spawn_open(FAR struct spawn_open_file_action_s *action)
  *
  ****************************************************************************/
 
-static int spawn_proxy(int argc, char *argv[])
+static int posix_spawn_proxy(int argc, FAR char *argv[])
 {
-  FAR struct spawn_general_file_action_s *entry;
-  FAR const posix_spawnattr_t *attr = g_ps_parms.attr;
-  int ret = OK;
+  int ret;
 
   /* Perform file actions and/or set a custom signal mask.  We get here only
    * if the file_actions parameter to posix_spawn[p] was non-NULL and/or the
@@ -369,62 +184,22 @@ static int spawn_proxy(int argc, char *argv[])
    */
 
 #ifndef CONFIG_DISABLE_SIGNALS
-  DEBUGASSERT((g_ps_parms.file_actions && *g_ps_parms.file_actions) ||
-              (attr && (attr->flags & POSIX_SPAWN_SETSIGMASK) != 0));
+  DEBUGASSERT(g_spawn_parms.file_actions ||
+              (g_spawn_parms.attr &&
+              (g_spawn_parms.attr->flags & POSIX_SPAWN_SETSIGMASK) != 0));
 #else
-  DEBUGASSERT(g_ps_parms.file_actions && *g_ps_parms.file_actions);
+  DEBUGASSERT(g_spawn_parms.file_actions);
 #endif
 
-  /* Check if we need to change the signal mask */
-
-#ifndef CONFIG_DISABLE_SIGNALS
-  if (attr && (attr->flags & POSIX_SPAWN_SETSIGMASK) != 0)
-    {
-      (void)sigprocmask(SIG_SETMASK, &attr->sigmask, NULL);
-    }
-
-  /* Were we also requested to perform file actions? */
-
-  if (g_ps_parms.file_actions)
-#endif
-    {
-      /* Execute each file action */
-
-      for (entry = (FAR struct spawn_general_file_action_s *)*g_ps_parms.file_actions;
-           entry && ret == OK;
-           entry = entry->flink)
-        {
-          switch (entry->action)
-            {
-            case SPAWN_FILE_ACTION_CLOSE:
-              ret = spawn_close((FAR struct spawn_close_file_action_s *)entry);
-              break;
-
-            case SPAWN_FILE_ACTION_DUP2:
-              ret = spawn_dup2((FAR struct spawn_dup2_file_action_s *)entry);
-              break;
-
-            case SPAWN_FILE_ACTION_OPEN:
-              ret = spawn_open((FAR struct spawn_open_file_action_s *)entry);
-              break;
-
-            case SPAWN_FILE_ACTION_NONE:
-            default:
-              sdbg("ERROR: Unknown action: %d\n", entry->action);
-              ret = EINVAL;
-              break;
-            }
-        }
-    }
-
-  /* Check for failures */
+  /* Set the attributes and perform the file actions as appropriate */
 
+  ret = spawn_proxyattrs(g_spawn_parms.attr, g_spawn_parms.file_actions);
   if (ret == OK)
     {
       /* Start the task */
 
-      ret = spawn_exec(g_ps_parms.pid, g_ps_parms.path, attr,
-                       g_ps_parms.argv);
+      ret = posix_spawn_exec(g_spawn_parms.pid, g_spawn_parms.u.posix.path,
+                             g_spawn_parms.attr, g_spawn_parms.argv);
 
 #ifdef CONFIG_SCHED_HAVE_PARENT
       if (ret == OK)
@@ -433,7 +208,7 @@ static int spawn_proxy(int argc, char *argv[])
            * What should we do in the event of a failure?
            */
 
-          int tmp = task_reparent(0, *g_ps_parms.pid);
+          int tmp = task_reparent(0, *g_spawn_parms.pid);
           if (tmp < 0)
             {
               sdbg("ERROR: task_reparent() failed: %d\n", tmp);
@@ -446,9 +221,9 @@ static int spawn_proxy(int argc, char *argv[])
    * what we need to do.
    */
 
-  g_ps_parms.result = ret;
+  g_spawn_parms.result = ret;
 #ifndef CONFIG_SCHED_WAITPID
-  spawn_semgive(&g_ps_execsem);
+  spawn_semgive(&g_posix_spawn_execsem);
 #endif
   return OK;
 }
@@ -585,7 +360,7 @@ int posix_spawn(FAR pid_t *pid, FAR const char *path,
   if (file_actions ==  NULL || *file_actions == NULL)
 #endif
     {
-      return spawn_exec(pid, path, attr, argv);
+      return posix_spawn_exec(pid, path, attr, argv);
     }
 
   /* Otherwise, we will have to go through an intermediary/proxy task in order
@@ -601,16 +376,16 @@ int posix_spawn(FAR pid_t *pid, FAR const char *path,
 
   /* Get exclusive access to the global parameter structure */
 
-  spawn_semtake(&g_ps_parmsem);
+  spawn_semtake(&g_spawn_parmsem);
 
   /* Populate the parameter structure */
 
-  g_ps_parms.result       = ENOSYS;
-  g_ps_parms.pid          = pid;
-  g_ps_parms.path         = path;
-  g_ps_parms.file_actions = file_actions;
-  g_ps_parms.attr         = attr;
-  g_ps_parms.argv         = argv;
+  g_spawn_parms.result       = ENOSYS;
+  g_spawn_parms.pid          = pid;
+  g_spawn_parms.file_actions = file_actions ? *file_actions : NULL;
+  g_spawn_parms.attr         = attr;
+  g_spawn_parms.argv         = argv;
+  g_spawn_parms.u.posix.path = path;
 
   /* Get the priority of this (parent) task */
 
@@ -620,12 +395,12 @@ int posix_spawn(FAR pid_t *pid, FAR const char *path,
       int errcode = errno;
 
       sdbg("ERROR: sched_getparam failed: %d\n", errcode);
-      spawn_semgive(&g_ps_parmsem);
+      spawn_semgive(&g_spawn_parmsem);
       return errcode;
     }
 
   /* Disable pre-emption so that the proxy does not run until we waitpid
-   * is called.  This is probably unnecessary since the spawn_proxy has
+   * is called.  This is probably unnecessary since the posix_spawn_proxy has
    * the same priority as this thread; it should be schedule behind this
    * task in the ready-to-run list.
    */
@@ -638,13 +413,14 @@ int posix_spawn(FAR pid_t *pid, FAR const char *path,
    * task.
    */
 
-  proxy = TASK_CREATE("spawn_proxy", param.sched_priority,
-                      CONFIG_POSIX_SPAWN_STACKSIZE, (main_t)spawn_proxy,
-                      (FAR const char **)NULL);
+  proxy = TASK_CREATE("posix_spawn_proxy", param.sched_priority,
+                      CONFIG_POSIX_SPAWN_PROXY_STACKSIZE,
+                      (main_t)posix_spawn_proxy,
+                      (FAR char * const *)NULL);
   if (proxy < 0)
     {
       ret = get_errno();
-      sdbg("ERROR: Failed to start spawn_proxy: %d\n", ret);
+      sdbg("ERROR: Failed to start posix_spawn_proxy: %d\n", ret);
 
       goto errout_with_lock;
     }
@@ -659,17 +435,17 @@ int posix_spawn(FAR pid_t *pid, FAR const char *path,
        goto errout_with_lock;
      }
 #else
-   spawn_semtake(&g_ps_execsem);
+   spawn_semtake(&g_posix_spawn_execsem);
 #endif
 
    /* Get the result and relinquish our access to the parameter structure */
 
-   ret = g_ps_parms.result;
+   ret = g_spawn_parms.result;
 
 errout_with_lock:
 #ifdef CONFIG_SCHED_WAITPID
   sched_unlock();
 #endif
-  spawn_semgive(&g_ps_parmsem);
+  spawn_semgive(&g_spawn_parmsem);
   return ret;
 }
diff --git a/nuttx/sched/task_setup.c b/nuttx/sched/task_setup.c
index b770d46e6..649e97184 100644
--- a/nuttx/sched/task_setup.c
+++ b/nuttx/sched/task_setup.c
@@ -414,7 +414,7 @@ int task_schedsetup(FAR _TCB *tcb, int priority, start_t start, main_t main,
  *
  ****************************************************************************/
 
-int task_argsetup(FAR _TCB *tcb, const char *name, const char *argv[])
+int task_argsetup(FAR _TCB *tcb, const char *name, FAR char * const argv[])
 {
   int i;
 
diff --git a/nuttx/sched/task_spawn.c b/nuttx/sched/task_spawn.c
new file mode 100644
index 000000000..04a3944bf
--- /dev/null
+++ b/nuttx/sched/task_spawn.c
@@ -0,0 +1,411 @@
+/****************************************************************************
+ * sched/task_spawn.c
+ *
+ *   Copyright (C) 2013 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <sys/wait.h>
+#include <sched.h>
+#include <spawn.h>
+#include <debug.h>
+
+#include "os_internal.h"
+#include "group_internal.h"
+#include "spawn_internal.h"
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: task_spawn_exec
+ *
+ * Description:
+ *   Execute the task from the file system.
+ *
+ * Input Parameters:
+ *
+ *   pidp - Upon successful completion, this will return the task ID of the
+ *     child task in the variable pointed to by a non-NULL 'pid' argument.|
+ *
+ *   path - The 'path' argument identifies the file to execute.  If
+ *     CONFIG_BINFMT_EXEPATH is defined, this may be either a relative or
+ *     or an absolute path.  Otherwise, it must be an absolute path.
+ *
+ *   attr - If the value of the 'attr' parameter is NULL, the all default
+ *     values for the POSIX spawn attributes will be used.  Otherwise, the
+ *     attributes will be set according to the spawn flags.  The
+ *     following spawn flags are supported:
+ *
+ *     - POSIX_SPAWN_SETSCHEDPARAM: Set new tasks priority to the sched_param
+ *       value.
+ *     - POSIX_SPAWN_SETSCHEDULER: Set the new tasks scheduler priority to
+ *       the sched_policy value.
+ *
+ *     NOTE: POSIX_SPAWN_SETSIGMASK is handled in ps_proxy().
+ *
+ *   argv - argv[] is the argument list for the new task.  argv[] is an
+ *     array of pointers to null-terminated strings. The list is terminated
+ *     with a null pointer.
+ *
+ * Returned Value:
+ *   This function will return zero on success. Otherwise, an error number
+ *   will be returned as the function return value to indicate the error.
+ *   This errno value may be that set by execv(), sched_setpolicy(), or
+ *   sched_setparam().
+ *
+ ****************************************************************************/
+
+static int task_spawn_exec(FAR pid_t *pidp, FAR const char *name,
+                           main_t entry, FAR const posix_spawnattr_t *attr,
+                           FAR char * const *argv)
+{
+  int pid;
+  int ret = OK;
+
+  DEBUGASSERT(path);
+
+  /* Disable pre-emption so that we can modify the task parameters after
+   * we start the new task; the new task will not actually begin execution
+   * until we re-enable pre-emption.
+   */
+
+  sched_lock();
+
+  /* Start the task */
+
+  pid = TASK_CREATE(name, attr->priority, attr->stacksize, entry, argv);
+  if (pid < 0)
+    {
+      ret = errno;
+      sdbg("ERROR: TASK_CREATE failed: %d\n", ret);
+      goto errout;
+    }
+
+  /* Return the task ID to the caller */
+
+  if (pid)
+    {
+      *pidp = pid;
+    }
+
+  /* Now set the attributes.  Note that we ignore all of the return values
+   * here because we have already successfully started the task.  If we
+   * return an error value, then we would also have to stop the task.
+   */
+
+  if (attr)
+    {
+      (void)spawn_execattrs(pid, attr);
+    }
+
+  /* Re-enable pre-emption and return */
+
+errout:
+  sched_unlock();
+  return ret;
+}
+
+/****************************************************************************
+ * Name: task_spawn_proxy
+ *
+ * Description:
+ *   Perform file_actions, then execute the task from the file system.
+ *
+ * Input Parameters:
+ *   Standard task start-up parameters
+ *
+ * Returned Value:
+ *   Standard task return value.
+ *
+ ****************************************************************************/
+
+static int task_spawn_proxy(int argc, FAR char *argv[])
+{
+ int ret;
+
+  /* Perform file actions and/or set a custom signal mask.  We get here only
+   * if the file_actions parameter to task_spawn[p] was non-NULL and/or the
+   * option to change the signal mask was selected.
+   */
+
+#ifndef CONFIG_DISABLE_SIGNALS
+  DEBUGASSERT(g_spawn_parms.file_actions ||
+              (g_spawn_parms.attr &&
+              (g_spawn_parms.attr->flags & POSIX_SPAWN_SETSIGMASK) != 0));
+#else
+  DEBUGASSERT(g_spawn_parms.file_actions);
+#endif
+
+  /* Set the attributes and perform the file actions as appropriate */
+
+  ret = spawn_proxyattrs(g_spawn_parms.attr, g_spawn_parms.file_actions);
+  if (ret == OK)
+    {
+      /* Start the task */
+
+      ret = task_spawn_exec(g_spawn_parms.pid, g_spawn_parms.u.task.name,
+                            g_spawn_parms.u.task.entry, g_spawn_parms.attr,
+                            g_spawn_parms.argv);
+
+#ifdef CONFIG_SCHED_HAVE_PARENT
+      if (ret == OK)
+        {
+          /* Change of the parent of the task we just spawned to our parent.
+           * What should we do in the event of a failure?
+           */
+
+          int tmp = task_reparent(0, *g_spawn_parms.pid);
+          if (tmp < 0)
+            {
+              sdbg("ERROR: task_reparent() failed: %d\n", tmp);
+            }
+        }
+#endif
+    }
+
+  /* Post the semaphore to inform the parent task that we have completed
+   * what we need to do.
+   */
+
+  g_spawn_parms.result = ret;
+#ifndef CONFIG_SCHED_WAITPID
+  spawn_semgive(&g_task_spawn_execsem);
+#endif
+  return OK;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: task_spawn
+ *
+ * Description:
+ *   The task_spawn() function will create a new, child task, where the
+ *   entry point to the task is an address in memory.
+ *
+ * Input Parameters:
+ *
+ *   pid - Upon successful completion, task_spawn() will return the task ID
+ *     of the child task to the parent task, in the variable pointed to by
+ *     a non-NULL 'pid' argument.  If the 'pid' argument is a null pointer,
+ *     the process ID of the child is not returned to the caller.
+ *
+ *   name - The name to assign to the child task.
+ *
+ *   entry - The child task's entry point (an address in memory)
+ *
+ *   file_actions - If 'file_actions' is a null pointer, then file 
+ *     descriptors open in the calling process will remain open in the
+ *     child process (unless CONFIG_FDCLONE_STDIO is defined). If
+ *     'file_actions' is not NULL, then the file descriptors open in the
+ *     child process will be those open in the calling process as modified
+ *     by the spawn file actions object pointed to by file_actions.
+ *
+ *   attr - If the value of the 'attr' parameter is NULL, the all default
+ *     values for the POSIX spawn attributes will be used.  Otherwise, the
+ *     attributes will be set according to the spawn flags.  The
+ *     task_spawnattr_t spawn attributes object type is defined in spawn.h.
+ *     It will contains these attributes, not all of which are supported by
+ *     NuttX:
+ *
+ *     - POSIX_SPAWN_SETPGROUP:  Setting of the new task's process group is
+ *       not supported.  NuttX does not support process groups.
+ *     - POSIX_SPAWN_SETSCHEDPARAM: Set new tasks priority to the sched_param
+ *       value.
+ *     - POSIX_SPAWN_SETSCHEDULER: Set the new task's scheduler policy to
+ *       the sched_policy value.
+ *     - POSIX_SPAWN_RESETIDS: Resetting of the effective user ID of the child
+ *       process is not supported.  NuttX does not support effective user
+ *       IDs.
+ *     - POSIX_SPAWN_SETSIGMASK: Set the new task's signal mask.
+ *     - POSIX_SPAWN_SETSIGDEF:  Resetting signal default actions is not
+ *       supported.  NuttX does not support default signal actions.
+ *
+ *     And the non-standard:
+ *
+ *     - TASK_SPAWN_SETSTACKSIZE:  Set the stack size for the new task.
+ *
+ *   argv - argv[] is the argument list for the new task.  argv[] is an
+ *     array of pointers to null-terminated strings. The list is terminated
+ *     with a null pointer.
+ *
+ *   envp - The envp[] argument is not used by NuttX and may be NULL.
+ *
+ * Returned Value:
+ *   task_spawn() will return zero on success. Otherwise, an error number
+ *   will be returned as the function return value to indicate the error:
+ *
+ *   - EINVAL: The value specified by 'file_actions' or 'attr' is invalid.
+ *   - Any errors that might have been return if vfork() and excec[l|v]()
+ *     had been called.
+ *
+ ****************************************************************************/
+
+int task_spawn(FAR pid_t *pid, FAR const char *name, main_t entry,
+      FAR const posix_spawn_file_actions_t *file_actions,
+      FAR const posix_spawnattr_t *attr,
+      FAR char *const argv[], FAR char *const envp[])
+{
+  struct sched_param param;
+  pid_t proxy;
+#ifdef CONFIG_SCHED_WAITPID
+  int status;
+#endif
+  int ret;
+
+  DEBUGASSERT(path);
+
+  svdbg("pid=%p path=%s file_actions=%p attr=%p argv=%p\n",
+        pid, path, file_actions, attr, argv);
+
+  /* If there are no file actions to be performed and there is no change to
+   * the signal mask, then start the new child task directly from the parent task.
+   */
+
+#ifndef CONFIG_DISABLE_SIGNALS
+  if ((file_actions == NULL || *file_actions == NULL) &&
+      (attr == NULL || (attr->flags & POSIX_SPAWN_SETSIGMASK) == 0))
+#else
+  if (file_actions ==  NULL || *file_actions == NULL)
+#endif
+    {
+      return task_spawn_exec(pid, name, entry, attr, argv);
+    }
+
+  /* Otherwise, we will have to go through an intermediary/proxy task in order
+   * to perform the I/O redirection.  This would be a natural place to fork().
+   * However, true fork() behavior requires an MMU and most implementations
+   * of vfork() are not capable of these operations.
+   *
+   * Even without fork(), we can still do the job, but parameter passing is
+   * messier.  Unfortunately, there is no (clean) way to pass binary values
+   * as a task parameter, so we will use a semaphore-protected global
+   * structure.
+   */
+
+  /* Get exclusive access to the global parameter structure */
+
+  spawn_semtake(&g_spawn_parmsem);
+
+  /* Populate the parameter structure */
+
+  g_spawn_parms.result       = ENOSYS;
+  g_spawn_parms.pid          = pid;
+  g_spawn_parms.file_actions = file_actions ? *file_actions : NULL;
+  g_spawn_parms.attr         = attr;
+  g_spawn_parms.argv         = argv;
+  g_spawn_parms.u.task.name  = name;
+  g_spawn_parms.u.task.entry = entry;
+
+  /* Get the priority of this (parent) task */
+
+  ret = sched_getparam(0, &param);
+  if (ret < 0)
+    {
+      int errcode = errno;
+
+      sdbg("ERROR: sched_getparam failed: %d\n", errcode);
+      spawn_semgive(&g_spawn_parmsem);
+      return errcode;
+    }
+
+  /* Disable pre-emption so that the proxy does not run until we waitpid
+   * is called.  This is probably unnecessary since the task_spawn_proxy has
+   * the same priority as this thread; it should be schedule behind this
+   * task in the ready-to-run list.
+   */
+
+#ifdef CONFIG_SCHED_WAITPID
+  sched_lock();
+#endif
+
+  /* Start the intermediary/proxy task at the same priority as the parent
+   * task.
+   */
+
+  proxy = TASK_CREATE("task_spawn_proxy", param.sched_priority,
+                      CONFIG_POSIX_SPAWN_PROXY_STACKSIZE,
+                      (main_t)task_spawn_proxy,
+                      (FAR char * const*)NULL);
+  if (proxy < 0)
+    {
+      ret = get_errno();
+      sdbg("ERROR: Failed to start task_spawn_proxy: %d\n", ret);
+
+      goto errout_with_lock;
+    }
+
+   /* Wait for the proxy to complete its job */
+
+#ifdef CONFIG_SCHED_WAITPID
+   ret = waitpid(proxy, &status, 0);
+   if (ret < 0)
+     {
+       sdbg("ERROR: waitpid() failed: %d\n", errno);
+       goto errout_with_lock;
+     }
+#else
+   spawn_semtake(&g_task_spawn_execsem);
+#endif
+
+   /* Get the result and relinquish our access to the parameter structure */
+
+   ret = g_spawn_parms.result;
+
+errout_with_lock:
+#ifdef CONFIG_SCHED_WAITPID
+  sched_unlock();
+#endif
+  spawn_semgive(&g_spawn_parmsem);
+  return ret;
+}
diff --git a/nuttx/sched/task_spawnparms.c b/nuttx/sched/task_spawnparms.c
new file mode 100644
index 000000000..25cb86531
--- /dev/null
+++ b/nuttx/sched/task_spawnparms.c
@@ -0,0 +1,340 @@
+/****************************************************************************
+ * sched/task_spawnparms.c
+ *
+ *   Copyright (C) 2013 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <gnutt@nuttx.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <semaphore.h>
+#include <fcntl.h>
+#include <spawn.h>
+#include <debug.h>
+
+#include <nuttx/spawn.h>
+
+#include "spawn_internal.h"
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+sem_t g_spawn_parmsem = SEM_INITIALIZER(1);
+#ifndef CONFIG_SCHED_WAITPID
+sem_t g_spawn_execsem = SEM_INITIALIZER(0);
+#endif
+struct spawn_parms_s g_spawn_parms;
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: spawn_close, spawn_dup2, and spawn_open
+ *
+ * Description:
+ *   Implement individual file actions
+ *
+ * Input Parameters:
+ *   action - describes the action to be performed
+ *
+ * Returned Value:
+ *   posix_spawn() and posix_spawnp() will return zero on success.
+ *   Otherwise, an error number will be returned as the function return
+ *   value to indicate the error.
+ *
+ ****************************************************************************/
+
+static inline int spawn_close(FAR struct spawn_close_file_action_s *action)
+{
+  /* The return value from close() is ignored */
+
+  svdbg("Closing fd=%d\n", action->fd);
+
+  (void)close(action->fd);
+  return OK;
+}
+
+static inline int spawn_dup2(FAR struct spawn_dup2_file_action_s *action)
+{
+  int ret;
+
+  /* Perform the dup */
+
+  svdbg("Dup'ing %d->%d\n", action->fd1, action->fd2);
+
+  ret = dup2(action->fd1, action->fd2);
+  if (ret < 0)
+    {
+      int errcode = errno;
+
+      sdbg("ERROR: dup2 failed: %d\n", errcode);
+      return errcode;
+    }
+
+  return OK;
+}
+
+static inline int spawn_open(FAR struct spawn_open_file_action_s *action)
+{
+  int fd;
+  int ret = OK;
+
+  /* Open the file */
+
+  svdbg("Open'ing path=%s oflags=%04x mode=%04x\n",
+        action->path, action->oflags, action->mode);
+
+  fd = open(action->path, action->oflags, action->mode);
+  if (fd < 0)
+    {
+      ret = errno;
+      sdbg("ERROR: open failed: %d\n", ret);
+    }
+
+  /* Does the return file descriptor happen to match the required file
+   * desciptor number?
+   */
+
+  else if (fd != action->fd)
+    {
+      /* No.. dup2 to get the correct file number */
+
+      svdbg("Dup'ing %d->%d\n", fd, action->fd);
+
+      ret = dup2(fd, action->fd);
+      if (ret < 0)
+        {
+          ret = errno;
+          sdbg("ERROR: dup2 failed: %d\n", ret);
+        }
+
+      svdbg("Closing fd=%d\n", fd);
+      close(fd);
+    }
+
+  return ret;
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: spawn_semtake and spawn_semgive
+ *
+ * Description:
+ *   Give and take semaphores
+ *
+ * Input Parameters:
+ *
+ *   sem - The semaphore to act on.
+ *
+ * Returned Value:
+ *   None
+ *
+ ****************************************************************************/
+
+void spawn_semtake(FAR sem_t *sem)
+{
+  int ret;
+
+  do
+    {
+      ret = sem_wait(sem);
+      ASSERT(ret == 0 || errno == EINTR);
+    }
+  while (ret != 0);
+}
+
+/****************************************************************************
+ * Name: spawn_execattrs
+ *
+ * Description:
+ *   Set attributes of the new child task after it has been spawned.
+ *
+ * Input Parameters:
+ *
+ *   pid - The pid of the new task.
+ *   attr - The attributes to use
+ *
+ * Returned Value:
+ *   Errors are not reported by this function.  This is because errors
+ *   cannot occur, but ratther that the new task has already been started
+ *   so there is no graceful way to handle errors detected in this context
+ *   (unless we delete the new task and recover).
+ *
+ * Assumptions:
+ *   That task has been started but has not yet executed because pre-
+ *   emption is disabled.
+ *
+ ****************************************************************************/
+
+int spawn_execattrs(pid_t pid, FAR const posix_spawnattr_t *attr)
+{
+  struct sched_param param;
+
+  DEBUGASSERT(attr);
+
+  /* Now set the attributes.  Note that we ignore all of the return values
+   * here because we have already successfully started the task.  If we
+   * return an error value, then we would also have to stop the task.
+   */
+
+  /* If we are only setting the priority, then call sched_setparm()
+   * to set the priority of the of the new task.
+   */
+
+  if ((attr->flags & POSIX_SPAWN_SETSCHEDPARAM) != 0)
+    {
+      /* Get the priority from the attrributes */
+
+      param.sched_priority = attr->priority;
+
+      /* If we are setting *both* the priority and the scheduler,
+       * then we will call sched_setscheduler() below.
+       */
+
+      if ((attr->flags & POSIX_SPAWN_SETSCHEDULER) == 0)
+        {
+          svdbg("Setting priority=%d for pid=%d\n",
+                param.sched_priority, pid);
+
+          (void)sched_setparam(pid, &param);
+        }
+    }
+
+  /* If we are only changing the scheduling policy, then reset
+   * the priority to the default value (the same as this thread) in
+   * preparation for the sched_setscheduler() call below.
+   */
+
+  else if ((attr->flags & POSIX_SPAWN_SETSCHEDULER) != 0)
+    {
+      (void)sched_getparam(0, &param);
+    }
+
+  /* Are we setting the scheduling policy?  If so, use the priority
+   * setting determined above.
+   */
+
+  if ((attr->flags & POSIX_SPAWN_SETSCHEDULER) != 0)
+    {
+      svdbg("Setting policy=%d priority=%d for pid=%d\n",
+            attr->policy, param.sched_priority, pid);
+
+      (void)sched_setscheduler(pid, attr->policy, &param);
+    }
+
+  return OK;
+}
+
+/****************************************************************************
+ * Name: spawn_proxyattrs
+ *
+ * Description:
+ *   Set attributes of the proxy task before it has started the new child
+ *   task.
+ *
+ * Input Parameters:
+ *
+ *   pid - The pid of the new task.
+ *   attr - The attributes to use
+ *   file_actions - The attributes to use
+ *
+ * Returned Value:
+ *   0 (OK) on successed; A negated errno value is returned on failure.
+ *
+ ****************************************************************************/
+
+int spawn_proxyattrs(FAR const posix_spawnattr_t *attr,
+                     FAR const posix_spawn_file_actions_t *file_actions)
+{
+  FAR struct spawn_general_file_action_s *entry;
+  int ret = OK;
+
+  /* Check if we need to change the signal mask */
+
+#ifndef CONFIG_DISABLE_SIGNALS
+  if (attr && (attr->flags & POSIX_SPAWN_SETSIGMASK) != 0)
+    {
+      (void)sigprocmask(SIG_SETMASK, &attr->sigmask, NULL);
+    }
+
+  /* Were we also requested to perform file actions? */
+
+  if (file_actions)
+#endif
+    {
+      /* Yes.. Execute each file action */
+
+      for (entry = (FAR struct spawn_general_file_action_s *)file_actions;
+           entry && ret == OK;
+           entry = entry->flink)
+        {
+          switch (entry->action)
+            {
+            case SPAWN_FILE_ACTION_CLOSE:
+              ret = spawn_close((FAR struct spawn_close_file_action_s *)entry);
+              break;
+
+            case SPAWN_FILE_ACTION_DUP2:
+              ret = spawn_dup2((FAR struct spawn_dup2_file_action_s *)entry);
+              break;
+
+            case SPAWN_FILE_ACTION_OPEN:
+              ret = spawn_open((FAR struct spawn_open_file_action_s *)entry);
+              break;
+
+            case SPAWN_FILE_ACTION_NONE:
+            default:
+              sdbg("ERROR: Unknown action: %d\n", entry->action);
+              ret = EINVAL;
+              break;
+            }
+        }
+    }
+
+  return ret;
+}