From 2cc0db0c264e064ee203c2f19b91f7ba013fdf25 Mon Sep 17 00:00:00 2001 From: patacongo Date: Sat, 2 Feb 2013 19:32:46 +0000 Subject: All argv types should be char * const * not const char ** git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@5599 42af7a65-404d-4744-a932-0658087f49c3 --- apps/builtin/exec_builtin.c | 435 ++++++++++---------------------------------- 1 file changed, 100 insertions(+), 335 deletions(-) (limited to 'apps/builtin') diff --git a/apps/builtin/exec_builtin.c b/apps/builtin/exec_builtin.c index 5d3a1c08a..1924687e3 100644 --- a/apps/builtin/exec_builtin.c +++ b/apps/builtin/exec_builtin.c @@ -46,44 +46,30 @@ #include +#include +#include +#include +#include + +#if 0 #include #include #include -#include #include -#include -#include #include +#endif + #include /**************************************************************************** * Pre-processor Definitions ****************************************************************************/ -#ifndef CONFIG_BUILTIN_PROXY_STACKSIZE -# define CONFIG_BUILTIN_PROXY_STACKSIZE 1024 -#endif - /**************************************************************************** * Private Types ****************************************************************************/ -struct builtin_parms_s -{ - /* Input values */ - - FAR const char *redirfile; - FAR const char **argv; - int oflags; - int index; - - /* Returned values */ - - pid_t result; - int errcode; -}; - /**************************************************************************** * Private Function Prototypes ****************************************************************************/ @@ -92,376 +78,155 @@ struct builtin_parms_s * Private Data ****************************************************************************/ -static sem_t g_builtin_parmsem = SEM_INITIALIZER(1); -#ifndef CONFIG_SCHED_WAITPID -static sem_t g_builtin_execsem = SEM_INITIALIZER(0); -#endif -static struct builtin_parms_s g_builtin_parms; - /**************************************************************************** * Private Functions ****************************************************************************/ /**************************************************************************** - * Name: bultin_semtake and builtin_semgive - * - * Description: - * Give and take semaphores - * - * Input Parameters: - * - * sem - The semaphore to act on. - * - * Returned Value: - * None - * + * Public Functions ****************************************************************************/ -static void bultin_semtake(FAR sem_t *sem) -{ - int ret; - - do - { - ret = sem_wait(sem); - ASSERT(ret == 0 || get_errno() == EINTR); - } - while (ret != 0); -} - -#define builtin_semgive(sem) sem_post(sem) - /**************************************************************************** - * Name: builtin_taskcreate + * Name: exec_builtin * * Description: - * Execute the builtin task + * Executes builtin applications registered during 'make context' time. + * New application is run in a separate task context (and thread). + * + * Input Parameter: + * filename - Name of the linked-in binary to be started. + * argv - Argument list + * redirfile - If output if redirected, this parameter will be non-NULL + * and will provide the full path to the file. + * oflags - If output is redirected, this parameter will provide the + * open flags to use. This will support file replacement + * of appending to an existing file. * * Returned Value: - * On success, the task ID of the builtin task is returned; On failure, -1 - * (ERROR) is returned and the errno is set appropriately. + * This is an end-user function, so it follows the normal convention: + * Returns the PID of the exec'ed module. On failure, it.returns + * -1 (ERROR) and sets errno appropriately. * ****************************************************************************/ -static int builtin_taskcreate(int index, FAR const char **argv) +int exec_builtin(FAR const char *appname, FAR char * const *argv, + FAR const char *redirfile, int oflags) { - FAR const struct builtin_s *b; + FAR const struct builtin_s *builtin; + posix_spawnattr_t attr; + posix_spawn_file_actions_t file_actions; + struct sched_param param; + pid_t pid; + int index; int ret; - b = builtin_for_index(index); + /* Verify that an application with this name exists */ - if (b == NULL) - { - set_errno(ENOENT); - return ERROR; + index = builtin_isavail(appname); + if (index < 0) + { + ret = ENOENT; + goto errout_with_errno; } - /* Disable pre-emption. This means that although we start the builtin - * application here, it will not actually run until pre-emption is - * re-enabled below. - */ - - sched_lock(); + /* Get information about the builtin */ - /* Start the builtin application task */ - - ret = TASK_CREATE(b->name, b->priority, b->stacksize, b->main, - (argv) ? &argv[1] : (FAR const char **)NULL); + builtin = builtin_for_index(index); + if (builtin == NULL) + { + ret = ENOENT; + goto errout_with_errno; + } - /* If robin robin scheduling is enabled, then set the scheduling policy - * of the new task to SCHED_RR before it has a chance to run. - */ + /* Initialize attributes for task_spawn(). */ -#if CONFIG_RR_INTERVAL > 0 - if (ret > 0) + ret = posix_spawn_file_actions_init(&file_actions); + if (ret != 0) { - struct sched_param param; - - /* Pre-emption is disabled so the task creation and the - * following operation will be atomic. The priority of the - * new task cannot yet have changed from its initial value. - */ - - param.sched_priority = b->priority; - (void)sched_setscheduler(ret, SCHED_RR, ¶m); + goto errout_with_errno; } -#endif - - /* Now let the builtin application run */ - sched_unlock(); - - /* Return the task ID of the new task if the task was sucessfully - * started. Otherwise, ret will be ERROR (and the errno value will - * be set appropriately). - */ - - return ret; -} - -/**************************************************************************** - * Name: builtin_proxy - * - * Description: - * Perform output redirection, then execute the builtin task. - * - * Input Parameters: - * Standard task start-up parameters - * - * Returned Value: - * Standard task return value. - * - ****************************************************************************/ - -static int builtin_proxy(int argc, char *argv[]) -{ - int fd; - int ret = ERROR; - - /* Open the output file for redirection */ - - svdbg("Open'ing redirfile=%s oflags=%04x mode=0644\n", - g_builtin_parms.redirfile, g_builtin_parms.oflags); - - fd = open(g_builtin_parms.redirfile, g_builtin_parms.oflags, 0644); - if (fd < 0) + ret = posix_spawnattr_init(&attr); + if (ret != 0) { - /* Remember the errno value. ret is already set to ERROR */ - - g_builtin_parms.errcode = get_errno(); - sdbg("ERROR: open of %s failed: %d\n", - g_builtin_parms.redirfile, g_builtin_parms.errcode); + goto errout_with_errno; } - /* Does the return file descriptor happen to match the required file - * desciptor number? - */ + /* Set the correct task size and priority */ - else if (fd != 1) + param.sched_priority = builtin->priority; + ret = posix_spawnattr_setschedparam(&attr, ¶m); + if (ret != 0) { - /* No.. dup2 to get the correct file number */ - - svdbg("Dup'ing %d->1\n", fd); - - ret = dup2(fd, 1); - if (ret < 0) - { - g_builtin_parms.errcode = get_errno(); - sdbg("ERROR: dup2 failed: %d\n", g_builtin_parms.errcode); - } - - svdbg("Closing fd=%d\n", fd); - close(fd); + goto errout_with_errno; } - /* Was the setup successful? */ - - if (ret == OK) + ret = task_spawnattr_setstacksize(&attr, builtin->stacksize); + if (ret != 0) { - /* Yes.. Start the task. On success, the task ID of the builtin task - * is returned; On failure, -1 (ERROR) is returned and the errno - * is set appropriately. - */ - - ret = builtin_taskcreate(g_builtin_parms.index, g_builtin_parms.argv); - if (ret < 0) - { - g_builtin_parms.errcode = get_errno(); - sdbg("ERROR: builtin_taskcreate failed: %d\n", - g_builtin_parms.errcode); - } + goto errout_with_errno; } - /* NOTE: There is a logical error here if CONFIG_SCHED_HAVE_PARENT is - * defined: The new task is the child of this proxy task, not the - * original caller. As a consequence, operations like waitpid() will - * fail on the caller's thread. - */ - - /* Post the semaphore to inform the parent task that we have completed - * what we need to do. - */ - - g_builtin_parms.result = ret; -#ifndef CONFIG_SCHED_WAITPID - builtin_semgive(&g_builtin_execsem); -#endif - return 0; -} - -/**************************************************************************** - * Name: builtin_startproxy - * - * Description: - * Perform output redirection, then execute the builtin task. - * - * Input Parameters: - * Standard task start-up parameters - * - * Returned Value: - * On success, the task ID of the builtin task is returned; On failure, -1 - * (ERROR) is returned and the errno is set appropriately. - * - ****************************************************************************/ - -static inline int builtin_startproxy(int index, FAR const char **argv, - FAR const char *redirfile, int oflags) -{ - struct sched_param param; - pid_t proxy; - int errcode = OK; -#ifdef CONFIG_SCHED_WAITPID - int status; -#endif - int ret; - - svdbg("index=%d argv=%p redirfile=%s oflags=%04x\n", - index, argv, redirfile, oflags); - - /* 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 */ - - bultin_semtake(&g_builtin_parmsem); - - /* Populate the parameter structure */ - - g_builtin_parms.redirfile = redirfile; - g_builtin_parms.argv = argv; - g_builtin_parms.result = ERROR; - g_builtin_parms.oflags = oflags; - g_builtin_parms.index = index; - - /* Get the priority of this (parent) task */ + /* If robin robin scheduling is enabled, then set the scheduling policy + * of the new task to SCHED_RR before it has a chance to run. + */ - ret = sched_getparam(0, ¶m); - if (ret < 0) +#if CONFIG_RR_INTERVAL > 0 + ret = posix_spawnattr_setschedpolicy(&attr, SCHED_RR); + if (ret != 0) { - errcode = get_errno(); - sdbg("ERROR: sched_getparam failed: %d\n", errcode); - goto errout_with_sem; + goto errout_with_errno; } - /* Disable pre-emption so that the proxy does not run until we waitpid - * is called. This is probably unnecessary since the builtin_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("builtin_proxy", param.sched_priority, - CONFIG_BUILTIN_PROXY_STACKSIZE, (main_t)builtin_proxy, - (FAR const char **)NULL); - if (proxy < 0) + ret = posix_spawnattr_setflags(&attr, + POSIX_SPAWN_SETSCHEDPARAM | + POSIX_SPAWN_SETSCHEDULER); + if (ret != 0) { - errcode = get_errno(); - sdbg("ERROR: Failed to start builtin_proxy: %d\n", errcode); - goto errout_with_lock; + goto errout_with_errno; } - - /* Wait for the proxy to complete its job. We could use waitpid() - * for this. - */ - -#ifdef CONFIG_SCHED_WAITPID - ret = waitpid(proxy, &status, 0); - if (ret < 0) - { - sdbg("ERROR: waitpid() failed: %d\n", get_errno()); - goto errout_with_lock; - } #else - bultin_semtake(&g_builtin_execsem); -#endif - - /* Get the result and relinquish our access to the parameter structure */ - - set_errno(g_builtin_parms.errcode); - builtin_semgive(&g_builtin_parmsem); - return g_builtin_parms.result; - -errout_with_lock: -#ifdef CONFIG_SCHED_WAITPID - sched_unlock(); + ret = posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETSCHEDPARAM); + if (ret != 0) + { + goto errout_with_errno; + } #endif -errout_with_sem: - set_errno(errcode); - builtin_semgive(&g_builtin_parmsem); - return ERROR; -} - -/**************************************************************************** - * Public Functions - ****************************************************************************/ - -/**************************************************************************** - * Name: exec_builtin - * - * Description: - * Executes builtin applications registered during 'make context' time. - * New application is run in a separate task context (and thread). - * - * Input Parameter: - * filename - Name of the linked-in binary to be started. - * argv - Argument list - * redirfile - If output if redirected, this parameter will be non-NULL - * and will provide the full path to the file. - * oflags - If output is redirected, this parameter will provide the - * open flags to use. This will support file replacement - * of appending to an existing file. - * - * Returned Value: - * This is an end-user function, so it follows the normal convention: - * Returns the PID of the exec'ed module. On failure, it.returns - * -1 (ERROR) and sets errno appropriately. - * - ****************************************************************************/ - -int exec_builtin(FAR const char *appname, FAR const char **argv, - FAR const char *redirfile, int oflags) -{ - int index; - int ret = ERROR; + /* Is output being redirected? */ - /* Verify that an application with this name exists */ - - index = builtin_isavail(appname); - if (index >= 0) + if (redirfile) { - /* Is output being redirected? */ + /* Set up to close open redirfile and set to stdout (1) */ - if (redirfile) + ret = posix_spawn_file_actions_addopen(&file_actions, 1, + redirfile, O_WRONLY, 0644); + if (ret != 0) { - ret = builtin_startproxy(index, argv, redirfile, oflags); - } - else - { - /* Start the builtin application task */ - - ret = builtin_taskcreate(index, argv); + sdbg("ERROR: posix_spawn_file_actions_addopen failed: %d\n", ret); + goto errout_with_errno; } } + /* Start the built-in */ + + ret = task_spawn(&pid, builtin->name, builtin->main, &file_actions, + &attr, (argv) ? &argv[1] : (FAR char * const *)NULL, + (FAR char * const *)NULL); + if (ret != 0) + { + sdbg("ERROR: task_spawn failed: %d\n", ret); + goto errout_with_errno; + } /* Return the task ID of the new task if the task was sucessfully * started. Otherwise, ret will be ERROR (and the errno value will * be set appropriately). */ - return ret; + return pid; + +errout_with_errno: + set_errno(ret); + return ERROR; } -- cgit v1.2.3