mirror of
https://github.com/apache/nuttx.git
synced 2026-08-01 20:28:58 +00:00
b7faaed58f
A module's function pointer is the address of a two-word descriptor in its writable segment, not a code address. Firmware that accepts one, stores it, and later branches to it therefore jumps into the module's RAM data. There is no diagnostic: the board takes a HardFault with a dead console. qsort and bsearch have resolved the descriptor since FDPIC support landed. Nothing else did, and nothing noticed, because qsort's comparison function was the only callback anything exercised. That left every other entry point looking perfectly usable -- a module could call one, it would return success, and the fault arrived later from somewhere else. Resolution is opt-in per call site via fdpic_callback(), and this covers the rest of them: pthread_create, signal, task_create, pthread_once, task_spawn, scandir and sigaction. Resolution happens once, in the innermost routine the paths share, for the reason qsort already documents: resolving twice would treat a code address as a descriptor. task_create_with_stack resolves and task_create forwards to it; nxsig_action() resolves for both signal() and a direct sigaction(), on the local copy it already makes, so the caller's const struct is untouched and the SA_SIGINFO form is covered through the union. Two entry points need care beyond that pattern: signal() has to exclude the dispositions by hand. SIG_IGN, SIG_DFL, SIG_HOLD and SIG_ERR are the integers 0, 1, 2 and -1 rather than addresses, and fdpic_callback() declines to dereference NULL and nothing else -- handing it SIG_ERR would read through (void *)-1. scandir takes two pointers. Its filter is called by scandir itself and is resolved here; its comparison function is handed to qsort(), whose own entry point resolves it, so resolving it here as well would resolve twice. The test passes both at once, which is what exercises that distinction. Resolving the code address is sufficient at all of these. A thread or task created from a module inherits its D-Space -- nxtask_dup_dspace() runs before up_initial_state() installs it in the FDPIC register -- and a signal handler or pthread_once init routine runs in a context that already holds the module's data base. Verified on an RP2350 with a module that hands its own function to each entry point. Each assertion was also checked against a deliberate breakage: removing the scandir filter resolution, and adding a second resolution of the comparison function, each take the board down with a HardFault rather than printing a FAIL line -- which is how a broken callback resolution manifests on Cortex-M, and confirms the assertions test what they name. mq_notify and timer_create with SIGEV_THREAD remain, and are harder: their callback runs on a work-queue worker that carries no module data base at all. Assisted-by: Claude Code:claude-opus-5 Signed-off-by: Marco Casaroli <marco.casaroli@gmail.com>
305 lines
11 KiB
C
305 lines
11 KiB
C
/****************************************************************************
|
|
* sched/task/task_create.c
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership. The
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance with the
|
|
* License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sched.h>
|
|
#include <errno.h>
|
|
#include <nuttx/debug.h>
|
|
|
|
#include <nuttx/arch.h>
|
|
#include <nuttx/kmalloc.h>
|
|
#include <nuttx/sched.h>
|
|
#include <nuttx/kthread.h>
|
|
#include <nuttx/fs/fs.h>
|
|
|
|
#ifdef CONFIG_FDPIC
|
|
# include <nuttx/binfmt/fdpic.h>
|
|
#endif
|
|
|
|
#include "sched/sched.h"
|
|
#include "group/group.h"
|
|
#include "task/task.h"
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: nxthread_create
|
|
*
|
|
* Description:
|
|
* This function creates and activates a new thread of the specified type
|
|
* with a specified priority and returns its system-assigned ID. It is the
|
|
* internal, common implementation of task_create() and kthread_create().
|
|
* See comments with task_create() for further information.
|
|
*
|
|
* Input Parameters:
|
|
* name - Name of the new task
|
|
* ttype - Type of the new task
|
|
* priority - Priority of the new task
|
|
* stack_addr - Address of the stack needed
|
|
* stack_size - Size (in bytes) of the stack needed
|
|
* entry - Entry point of a new task
|
|
* arg - A pointer to an array of input parameters. The array
|
|
* should be terminated with a NULL argv[] value. If no
|
|
* parameters are required, argv may be NULL.
|
|
* envp - A pointer to an array of environment strings. Terminated
|
|
* with a NULL entry.
|
|
*
|
|
* Returned Value:
|
|
* Returns the positive, non-zero process ID of the new task or a negated
|
|
* errno value to indicate the nature of any failure. If memory is
|
|
* insufficient or the task cannot be created -ENOMEM will be returned.
|
|
*
|
|
****************************************************************************/
|
|
|
|
int nxthread_create(FAR const char *name, uint8_t ttype, int priority,
|
|
FAR void *stack_addr, int stack_size, main_t entry,
|
|
FAR char * const argv[], FAR char * const envp[])
|
|
{
|
|
FAR struct tcb_s *tcb;
|
|
pid_t pid;
|
|
int ret;
|
|
|
|
/* Allocate a TCB for the new task. */
|
|
|
|
tcb = kmm_zalloc(sizeof(struct tcb_s));
|
|
if (!tcb)
|
|
{
|
|
serr("ERROR: Failed to allocate TCB\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* Setup the task type */
|
|
|
|
tcb->flags = ttype | TCB_FLAG_FREE_TCB;
|
|
|
|
/* Initialize the task */
|
|
|
|
ret = nxtask_init(tcb, name, priority,
|
|
stack_addr, stack_size, entry, argv, envp, NULL);
|
|
if (ret < OK)
|
|
{
|
|
kmm_free(tcb);
|
|
return ret;
|
|
}
|
|
|
|
/* Get the assigned pid before we start the task */
|
|
|
|
pid = tcb->pid;
|
|
|
|
/* Activate the task */
|
|
|
|
nxtask_activate(tcb);
|
|
|
|
return pid;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: nxtask_create
|
|
*
|
|
* Description:
|
|
* This function creates and activates a new task with a specified
|
|
* priority and returns its system-assigned ID.
|
|
*
|
|
* The entry address entry is the address of the "main" function of the
|
|
* task. This function will be called once the C environment has been
|
|
* set up. The specified function will be called with four arguments.
|
|
* Should the specified routine return, a call to exit() will
|
|
* automatically be made.
|
|
*
|
|
* Note that four (and only four) arguments must be passed for the spawned
|
|
* functions.
|
|
*
|
|
* nxtask_create() is identical to the function task_create(), differing
|
|
* only in its return value: This function does not modify the errno
|
|
* variable. This is a non-standard, internal OS function and is not
|
|
* intended for use by application logic. Applications should use
|
|
* task_create().
|
|
*
|
|
* Input Parameters:
|
|
* name - Name of the new task
|
|
* priority - Priority of the new task
|
|
* stack_addr - Address of the stack needed
|
|
* stack_size - Size (in bytes) of the stack needed
|
|
* entry - Entry point of a new task
|
|
* arg - A pointer to an array of input parameters. The array
|
|
* should be terminated with a NULL argv[] value. If no
|
|
* parameters are required, argv may be NULL.
|
|
* envp - A pointer to an array of environment strings. Terminated
|
|
* with a NULL entry.
|
|
*
|
|
* Returned Value:
|
|
* Returns the positive, non-zero process ID of the new task or a negated
|
|
* errno value to indicate the nature of any failure. If memory is
|
|
* insufficient or the task cannot be created -ENOMEM will be returned.
|
|
*
|
|
****************************************************************************/
|
|
|
|
int nxtask_create(FAR const char *name, int priority,
|
|
FAR void *stack_addr, int stack_size, main_t entry,
|
|
FAR char * const argv[], FAR char * const envp[])
|
|
{
|
|
return nxthread_create(name, TCB_FLAG_TTYPE_TASK, priority, stack_addr,
|
|
stack_size, entry, argv, envp ? envp : environ);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: task_create
|
|
*
|
|
* Description:
|
|
* This function creates and activates a new task with a specified
|
|
* priority and returns its system-assigned ID.
|
|
*
|
|
* The entry address entry is the address of the "main" function of the
|
|
* task. This function will be called once the C environment has been
|
|
* set up. The specified function will be called with four arguments.
|
|
* Should the specified routine return, a call to exit() will
|
|
* automatically be made.
|
|
*
|
|
* Note that four (and only four) arguments must be passed for the spawned
|
|
* functions.
|
|
*
|
|
* Input Parameters:
|
|
* name - Name of the new task
|
|
* priority - Priority of the new task
|
|
* stack_size - size (in bytes) of the stack needed
|
|
* entry - Entry point of a new task
|
|
* arg - A pointer to an array of input parameters. The array
|
|
* should be terminated with a NULL argv[] value. If no
|
|
* parameters are required, argv may be NULL.
|
|
*
|
|
* Returned Value:
|
|
* Returns the non-zero process ID of the new task or ERROR if memory is
|
|
* insufficient or the task cannot be created. The errno will be set in
|
|
* the failure case to indicate the nature of the error.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifndef CONFIG_BUILD_KERNEL
|
|
int task_create_with_stack(FAR const char *name, int priority,
|
|
FAR void *stack_addr, int stack_size,
|
|
main_t entry, FAR char * const argv[])
|
|
{
|
|
int ret;
|
|
|
|
#ifdef CONFIG_FDPIC
|
|
/* An FDPIC module passes the address of a function descriptor, not a code
|
|
* address. Resolving it here covers task_create() too, which is a plain
|
|
* forwarder -- and covers it exactly once, which matters: resolving twice
|
|
* would treat an already-resolved code address as a descriptor.
|
|
*
|
|
* The new task inherits the creator's D-Space, so it starts with the
|
|
* module's own data base installed and needs only the code address.
|
|
*/
|
|
|
|
entry = (main_t)fdpic_callback((FAR void *)entry);
|
|
#endif
|
|
|
|
ret = nxtask_create(name, priority, stack_addr,
|
|
stack_size, entry, argv, NULL);
|
|
if (ret < 0)
|
|
{
|
|
set_errno(-ret);
|
|
ret = ERROR;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int task_create(FAR const char *name, int priority,
|
|
int stack_size, main_t entry, FAR char * const argv[])
|
|
{
|
|
return task_create_with_stack(name, priority, NULL,
|
|
stack_size, entry, argv);
|
|
}
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Name: kthread_create_with_stack
|
|
*
|
|
* Description:
|
|
* This function creates and activates a kernel thread task with
|
|
* kernel-mode privileges. It is identical to kthread_create() except
|
|
* that it get the stack memory from caller.
|
|
*
|
|
* Input Parameters:
|
|
* name - Name of the new task
|
|
* priority - Priority of the new task
|
|
* stack_addr - Stack buffer of the new task
|
|
* stack_size - Stack size of the new task
|
|
* entry - Entry point of a new task
|
|
* arg - A pointer to an array of input parameters. The array
|
|
* should be terminated with a NULL argv[] value. If no
|
|
* parameters are required, argv may be NULL.
|
|
*
|
|
* Returned Value:
|
|
* Returns the positive, non-zero process ID of the new task or a negated
|
|
* errno value to indicate the nature of any failure. If memory is
|
|
* insufficient or the task cannot be created -ENOMEM will be returned.
|
|
*
|
|
****************************************************************************/
|
|
|
|
int kthread_create_with_stack(FAR const char *name, int priority,
|
|
FAR void *stack_addr, int stack_size,
|
|
main_t entry, FAR char * const argv[])
|
|
{
|
|
return nxthread_create(name, TCB_FLAG_TTYPE_KERNEL, priority,
|
|
stack_addr, stack_size, entry, argv, NULL);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: kthread_create
|
|
*
|
|
* Description:
|
|
* This function creates and activates a kernel thread task with kernel-
|
|
* mode privileges. It is identical to task_create() except that it
|
|
* configures the newly started thread to run in kernel model.
|
|
*
|
|
* Input Parameters:
|
|
* name - Name of the new task
|
|
* priority - Priority of the new task
|
|
* stack_size - size (in bytes) of the stack needed
|
|
* entry - Entry point of a new task
|
|
* arg - A pointer to an array of input parameters. The array
|
|
* should be terminated with a NULL argv[] value. If no
|
|
* parameters are required, argv may be NULL.
|
|
*
|
|
* Returned Value:
|
|
* Returns the positive, non-zero process ID of the new task or a negated
|
|
* errno value to indicate the nature of any failure. If memory is
|
|
* insufficient or the task cannot be created -ENOMEM will be returned.
|
|
*
|
|
****************************************************************************/
|
|
|
|
int kthread_create(FAR const char *name, int priority,
|
|
int stack_size, main_t entry, FAR char * const argv[])
|
|
{
|
|
return kthread_create_with_stack(name, priority,
|
|
NULL, stack_size, entry, argv);
|
|
}
|