int clearenv(void)
{
FAR struct tcb_s *tcb = this_task();
DEBUGASSERT(tcb->group);
env_release(tcb->group);
return OK;
}
void script_delete(JScript** script)
{
JScript* s = *script;
*script = N_NULL;
scanner_delete(&s->scanner);
NBK_free(s);
env_release();
}
int clearenv(void)
{
FAR _TCB *tcb = (FAR _TCB*)g_readytorun.head;
DEBUGASSERT(tcb->group);
env_release(tcb->group);
return OK;
}
int sched_releasetcb(FAR _TCB *tcb)
{
int ret = OK;
int i;
if (tcb)
{
/* Relase any timers that the task might hold. We do this
* before release the PID because it may still be trying to
* deliver signals (although interrupts are should be
* disabled here).
*/
#ifndef CONFIG_DISABLE_POSIX_TIMERS
#ifdef CONFIG_HAVE_WEAKFUNCTIONS
if (timer_deleteall != NULL)
#endif
{
timer_deleteall(tcb->pid);
}
#endif
/* Release the task's process ID if one was assigned. PID
* zero is reserved for the IDLE task. The TCB of the IDLE
* task is never release so a value of zero simply means that
* the process ID was never allocated to this TCB.
*/
if (tcb->pid)
{
sched_releasepid(tcb->pid);
}
/* Delete the thread's stack if one has been allocated */
#ifndef CONFIG_CUSTOM_STACK
if (tcb->stack_alloc_ptr)
{
up_release_stack(tcb);
}
#endif
/* Delete the tasks's allocated DSpace region (external modules only) */
#ifdef CONFIG_PIC
if (tcb->dspace)
{
if (tcb->dspace->crefs <= 1)
{
sched_free(tcb->dspace);
}
else
{
tcb->dspace->crefs--;
}
}
#endif
/* Release command line arguments that were allocated for task
* start/re-start.
*/
if ((tcb->flags & TCB_FLAG_TTYPE_MASK) == TCB_FLAG_TTYPE_TASK)
{
for (i = 1; i < CONFIG_MAX_TASK_ARGS+1 && tcb->argv[i]; i++)
{
sched_free((FAR void*)tcb->argv[i]);
}
}
/* Release any allocated file structures */
ret = sched_releasefiles(tcb);
/* Release environment variables */
(void)env_release(tcb);
/* And, finally, release the TCB itself */
sched_free(tcb);
}
return ret;
}
static inline void group_release(FAR struct task_group_s *group)
{
/* Free all un-reaped child exit status */
#if defined(CONFIG_SCHED_HAVE_PARENT) && defined(CONFIG_SCHED_CHILD_STATUS)
group_removechildren(group);
#endif
#ifndef CONFIG_DISABLE_SIGNALS
/* Release pending signals */
sig_release(group);
#endif
#ifndef CONFIG_DISABLE_PTHREAD
/* Release pthread resources */
pthread_release(group);
#endif
#if CONFIG_NFILE_DESCRIPTORS > 0
/* Free all file-related resources now. We really need to close files as
* soon as possible while we still have a functioning task.
*/
/* Free resources held by the file descriptor list */
files_releaselist(&group->tg_filelist);
#if CONFIG_NFILE_STREAMS > 0
/* Free resource held by the stream list */
lib_stream_release(group);
#endif /* CONFIG_NFILE_STREAMS */
#endif /* CONFIG_NFILE_DESCRIPTORS */
#if CONFIG_NSOCKET_DESCRIPTORS > 0
/* Free resource held by the socket list */
net_releaselist(&group->tg_socketlist);
#endif /* CONFIG_NSOCKET_DESCRIPTORS */
#ifndef CONFIG_DISABLE_ENVIRON
/* Release all shared environment variables */
env_release(group);
#endif
#ifndef CONFIG_DISABLE_MQUEUE
/* Close message queues opened by members of the group */
mq_release(group);
#endif
#if defined(CONFIG_BUILD_KERNEL) && defined(CONFIG_MM_SHM)
/* Release any resource held by shared memory virtual page allocator */
(void)shm_group_release(group);
#endif
#ifdef CONFIG_ARCH_ADDRENV
/* Destroy the group address environment */
(void)up_addrenv_destroy(&group->tg_addrenv);
/* Mark no address environment */
g_gid_current = 0;
#endif
#if defined(HAVE_GROUP_MEMBERS) || defined(CONFIG_ARCH_ADDRENV)
/* Remove the group from the list of groups */
group_remove(group);
#endif
#ifdef HAVE_GROUP_MEMBERS
/* Release the members array */
if (group->tg_members)
{
sched_kfree(group->tg_members);
group->tg_members = NULL;
}
#endif
#if CONFIG_NFILE_STREAMS > 0 && defined(CONFIG_MM_KERNEL_HEAP)
/* In a flat, single-heap build. The stream list is part of the
* group structure and, hence will be freed when the group structure
* is freed. Otherwise, it is separately allocated an must be
* freed here.
*/
# if defined(CONFIG_BUILD_PROTECTED)
/* In the protected build, the task's stream list is always allocated
* and freed from the single, global user allocator.
*/
sched_ufree(group->tg_streamlist);
# elif defined(CONFIG_BUILD_KERNEL)
/* In the kernel build, the unprivileged process' stream list will be
* allocated from with its per-process, private user heap. But in that
* case, there is no reason to do anything here: That allocation resides
* in the user heap which which be completely freed when we destroy the
* process' address environment.
*/
if ((group->tg_flags & GROUP_FLAG_PRIVILEGED) != 0)
{
/* But kernel threads are different in this build configuration: Their
* stream lists were allocated from the common, global kernel heap and
* must explicitly freed here.
*/
sched_kfree(group->tg_streamlist);
}
# endif
#endif
#if defined(CONFIG_SCHED_WAITPID) && !defined(CONFIG_SCHED_HAVE_PARENT)
/* If there are threads waiting for this group to be freed, then we cannot
* yet free the memory resources. Instead just mark the group deleted
* and wait for those threads complete their waits.
*/
if (group->tg_nwaiters > 0)
{
group->tg_flags |= GROUP_FLAG_DELETED;
}
else
#endif
{
/* Release the group container itself */
sched_kfree(group);
}
}
static void finalize(void) {
index_free(g.index);
env_release(g.names);
env_release(g.env);
}