335 lines
10 KiB
C
335 lines
10 KiB
C
/****************************************************************************
|
|
* binfmt/binfmt_schedunload.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 <sched.h>
|
|
#include <debug.h>
|
|
#include <errno.h>
|
|
|
|
#include <nuttx/kmalloc.h>
|
|
#include <nuttx/binfmt/binfmt.h>
|
|
|
|
#include "binfmt_internal.h"
|
|
|
|
#if !defined(CONFIG_BINFMT_DISABLE) && defined(CONFIG_SCHED_HAVE_PARENT)
|
|
|
|
/****************************************************************************
|
|
* Pre-processor Definitions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Private Function Prototypes
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Private Data
|
|
****************************************************************************/
|
|
|
|
FAR struct binary_s *g_unloadhead;
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: unload_list_add
|
|
*
|
|
* Description:
|
|
* If CONFIG_SCHED_HAVE_PARENT is defined then schedul_unload() will
|
|
* manage instances of struct binary_s allocated with kmm_malloc. It
|
|
* will keep the binary data in a link list and when SIGCHLD is received
|
|
* (meaning that the task has exit'ed, schedul_unload() will find the
|
|
* data, unload the module, and free the structure.
|
|
*
|
|
* This function will add one structure to the linked list
|
|
*
|
|
* Input Parameter:
|
|
* pid - The task ID of the child task
|
|
* bin - This structure must have been allocated with kmm_malloc() and must
|
|
* persist until the task unloads
|
|
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
static void unload_list_add(pid_t pid, FAR struct binary_s *bin)
|
|
{
|
|
irqstate_t flags;
|
|
|
|
/* Save the PID in the structure so that we recover it later */
|
|
|
|
bin->pid = pid;
|
|
|
|
/* Disable deliver of any signals while we muck with the list. The graceful
|
|
* way to do this would be block delivery of SIGCHLD would be with
|
|
* sigprocmask. Here we do it the quick'n'dirty way by just disabling
|
|
* interrupts.
|
|
*/
|
|
|
|
flags = irqsave();
|
|
bin->flink = g_unloadhead;
|
|
g_unloadhead = bin;
|
|
irqrestore(flags);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: unload_list_remove
|
|
*
|
|
* Description:
|
|
* If CONFIG_SCHED_HAVE_PARENT is defined then schedul_unload() will
|
|
* manage instances of struct binary_s allocated with kmm_malloc. It
|
|
* will keep the binary data in a link list and when SIGCHLD is received
|
|
* (meaning that the task has exit'ed, schedul_unload() will find the
|
|
* data, unload the module, and free the structure.
|
|
*
|
|
* This function will remove one structure to the linked list
|
|
*
|
|
* Input Parameter:
|
|
* pid - The task ID of the child task
|
|
*
|
|
* Returned Value:
|
|
* On success, the load structure is returned. NULL is returned on
|
|
* failure.
|
|
*
|
|
****************************************************************************/
|
|
|
|
static FAR struct binary_s *unload_list_remove(pid_t pid)
|
|
{
|
|
FAR struct binary_s *curr;
|
|
FAR struct binary_s *prev;
|
|
|
|
/* Note the asymmetry. We do not have to disable interrupts here because
|
|
* the main thread cannot run while we are in the interrupt handler. Here,
|
|
* it should be sufficient to disable pre-emption so that no other thread
|
|
* can run.
|
|
*/
|
|
|
|
sched_lock();
|
|
|
|
/* Find the structure in the unload list with the matching PID */
|
|
|
|
for (prev = NULL, curr = g_unloadhead;
|
|
curr && (curr->pid != pid);
|
|
prev = curr, curr = curr->flink);
|
|
|
|
/* Did we find it? It must be there. Hmmm.. we should probably ASSERT if
|
|
* we do not!
|
|
*/
|
|
|
|
if (curr)
|
|
{
|
|
/* Was there another entry before this one? */
|
|
|
|
if (prev)
|
|
{
|
|
/* Yes.. remove the current entry from after the previous entry */
|
|
|
|
prev->flink = curr->flink;
|
|
}
|
|
else
|
|
{
|
|
/* No.. remove the current entry from the head of the list */
|
|
|
|
g_unloadhead = curr->flink;
|
|
}
|
|
|
|
/* Nullify the forward link ... superstitious */
|
|
|
|
curr->flink = NULL;
|
|
}
|
|
|
|
sched_unlock();
|
|
return curr;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: unload_callback
|
|
*
|
|
* Description:
|
|
* If CONFIG_SCHED_HAVE_PARENT is defined, this function may be called to
|
|
* automatically unload the module when task exits. It assumes that
|
|
* bin was allocated with kmm_malloc() or friends and will also automatically
|
|
* free the structure with kmm_free() when the task exists.
|
|
*
|
|
* Input Parameter:
|
|
* pid - The ID of the task that just exited
|
|
* arg - A reference to the load structure cast to FAR void *
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
static void unload_callback(int signo, siginfo_t *info, void *ucontext)
|
|
{
|
|
FAR struct binary_s *bin;
|
|
int ret;
|
|
|
|
/* Sanity checking */
|
|
|
|
if (!info || signo != SIGCHLD)
|
|
{
|
|
blldbg("ERROR:Bad signal callback: signo=%d info=%p\n", signo, info);
|
|
return;
|
|
}
|
|
|
|
/* Get the load information for this pid */
|
|
|
|
bin = unload_list_remove(info->si_pid);
|
|
if (!bin)
|
|
{
|
|
blldbg("ERROR: Could not find load info for PID=%d\n", info->si_pid);
|
|
return;
|
|
}
|
|
|
|
/* Unload the module */
|
|
|
|
ret = unload_module(bin);
|
|
if (ret < 0)
|
|
{
|
|
blldbg("ERROR: unload_module failed: %d\n", get_errno());
|
|
}
|
|
|
|
/* Free the load structure */
|
|
|
|
kmm_free(bin);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: schedule_unload
|
|
*
|
|
* Description:
|
|
* If CONFIG_SCHED_HAVE_PARENT is defined, this function may be called by
|
|
* the parent of the newly created task to automatically unload the
|
|
* module when the task exits. This assumes that (1) the caller is the
|
|
* parent of the created task, (2) that bin was allocated with kmm_malloc()
|
|
* or friends. It will also automatically free the structure with kmm_free()
|
|
* after unloading the module.
|
|
*
|
|
* Input Parameter:
|
|
* pid - The task ID of the child task
|
|
* bin - This structure must have been allocated with kmm_malloc() and must
|
|
* persist until the task unloads
|
|
*
|
|
* Returned Value:
|
|
* This is an end-user function, so it follows the normal convention:
|
|
* It returns 0 (OK) if the callback was successfully scheduled. On
|
|
* failure, it returns -1 (ERROR) and sets errno appropriately.
|
|
*
|
|
* On failures, the 'bin' structure will not be deallocated and the
|
|
* module not not be unloaded.
|
|
*
|
|
****************************************************************************/
|
|
|
|
int schedule_unload(pid_t pid, FAR struct binary_s *bin)
|
|
{
|
|
struct sigaction act;
|
|
struct sigaction oact;
|
|
sigset_t sigset;
|
|
irqstate_t flags;
|
|
int errorcode;
|
|
int ret;
|
|
|
|
/* Make sure that SIGCHLD is unmasked */
|
|
|
|
(void)sigemptyset(&sigset);
|
|
(void)sigaddset(&sigset, SIGCHLD);
|
|
ret = sigprocmask(SIG_UNBLOCK, &sigset, NULL);
|
|
if (ret != OK)
|
|
{
|
|
/* The errno value will get trashed by the following debug output */
|
|
|
|
errorcode = get_errno();
|
|
bvdbg("ERROR: sigprocmask failed: %d\n", ret);
|
|
goto errout;
|
|
}
|
|
|
|
/* Add the structure to the list. We want to do this *before* connecting
|
|
* the signal handler. This does, however, make error recovery more
|
|
* complex if sigaction() fails below because then we have to remove the
|
|
* unload structure for the list in an unexpected context.
|
|
*/
|
|
|
|
unload_list_add(pid, bin);
|
|
|
|
/* Register the SIGCHLD handler */
|
|
|
|
act.sa_sigaction = unload_callback;
|
|
act.sa_flags = SA_SIGINFO;
|
|
|
|
(void)sigfillset(&act.sa_mask);
|
|
(void)sigdelset(&act.sa_mask, SIGCHLD);
|
|
|
|
ret = sigaction(SIGCHLD, &act, &oact);
|
|
if (ret != OK)
|
|
{
|
|
/* The errno value will get trashed by the following debug output */
|
|
|
|
errorcode = get_errno();
|
|
bvdbg("ERROR: sigaction failed: %d\n" , ret);
|
|
|
|
/* Emergency removal from the list */
|
|
|
|
flags = irqsave();
|
|
if (unload_list_remove(pid) != bin)
|
|
{
|
|
blldbg("ERROR: Failed to remove structure\n");
|
|
}
|
|
|
|
irqrestore(flags);
|
|
goto errout;
|
|
}
|
|
|
|
return OK;
|
|
|
|
errout:
|
|
set_errno(errorcode);
|
|
return ERROR;
|
|
}
|
|
|
|
#endif /* !CONFIG_BINFMT_DISABLE && CONFIG_SCHED_HAVE_PARENT */
|
|
|