void group_removechildren(FAR struct task_group_s *group) { FAR struct child_status_s *curr; FAR struct child_status_s *next; /* Remove all child structures for the TCB and return them to the freelist */ for (curr = group->tg_children; curr; curr = next) { next = curr->flink; group_freechild(curr); } group->tg_children = NULL; group_dumpchildren(group, "group_removechildren"); }
int task_reparent(pid_t ppid, pid_t chpid) { #ifdef CONFIG_SCHED_CHILD_STATUS FAR struct child_status_s *child; #endif FAR struct task_group_s *chgrp; FAR struct task_group_s *ogrp; FAR struct task_group_s *pgrp; struct tcb_s *tcb; gid_t ogid; gid_t pgid; irqstate_t flags; int ret; /* Disable interrupts so that nothing can change in the relatinoship of * the three task: Child, current parent, and new parent. */ flags = irqsave(); /* Get the child tasks task group */ tcb = sched_gettcb(chpid); if (!tcb) { ret = -ECHILD; goto errout_with_ints; } DEBUGASSERT(tcb->group); chgrp = tcb->group; /* Get the GID of the old parent task's task group (ogid) */ ogid = chgrp->tg_pgid; /* Get the old parent task's task group (ogrp) */ ogrp = group_findbygid(ogid); if (!ogrp) { ret = -ESRCH; goto errout_with_ints; } /* If new parent task's PID (ppid) is zero, then new parent is the * grandparent will be the new parent, i.e., the parent of the current * parent task. */ if (ppid == 0) { /* Get the grandparent task's task group (pgrp) */ pgid = ogrp->tg_pgid; pgrp = group_findbygid(pgid); } else { /* Get the new parent task's task group (pgrp) */ tcb = sched_gettcb(ppid); if (!tcb) { ret = -ESRCH; goto errout_with_ints; } pgrp = tcb->group; pgid = pgrp->tg_gid; } if (!pgrp) { ret = -ESRCH; goto errout_with_ints; } /* Then reparent the child. Notice that we don't actually change the * parent of the task. Rather, we change the parent task group for * all members of the child's task group. */ chgrp->tg_pgid = pgid; #ifdef CONFIG_SCHED_CHILD_STATUS /* Remove the child status entry from old parent task group */ child = group_removechild(ogrp, chpid); if (child) { /* Has the new parent's task group supressed child exit status? */ if ((pgrp->tg_flags && GROUP_FLAG_NOCLDWAIT) == 0) { /* No.. Add the child status entry to the new parent's task group */ group_addchild(pgrp, child); } else { /* Yes.. Discard the child status entry */ group_freechild(child); } /* Either case is a success */ ret = OK; } else { /* This would not be an error if the original parent's task group has * suppressed child exit status. */ ret = ((ogrp->tg_flags && GROUP_FLAG_NOCLDWAIT) == 0) ? -ENOENT : OK; } #else /* CONFIG_SCHED_CHILD_STATUS */ DEBUGASSERT(otcb->nchildren > 0); otcb->nchildren--; /* The orignal parent now has one few children */ ptcb->nchildren++; /* The new parent has one additional child */ ret = OK; #endif /* CONFIG_SCHED_CHILD_STATUS */ errout_with_ints: irqrestore(flags); return ret; }
int task_reparent(pid_t ppid, pid_t chpid) { #ifdef CONFIG_SCHED_CHILD_STATUS FAR struct child_status_s *child; #endif struct tcb_s *ptcb; struct tcb_s *chtcb; struct tcb_s *otcb; pid_t opid; irqstate_t flags; int ret; /* Disable interrupts so that nothing can change in the relatinoship of * the three task: Child, current parent, and new parent. */ flags = irqsave(); /* Get the child tasks TCB (chtcb) */ chtcb = sched_gettcb(chpid); if (!chtcb) { ret = -ECHILD; goto errout_with_ints; } /* Get the PID of the child task's parent (opid) */ opid = chtcb->ppid; /* Get the TCB of the child task's parent (otcb) */ otcb = sched_gettcb(opid); if (!otcb) { ret = -ESRCH; goto errout_with_ints; } /* If new parent task's PID (ppid) is zero, then new parent is the * grandparent will be the new parent, i.e., the parent of the current * parent task. */ if (ppid == 0) { ppid = otcb->ppid; } /* Get the new parent task's TCB (ptcb) */ ptcb = sched_gettcb(ppid); if (!ptcb) { ret = -ESRCH; goto errout_with_ints; } /* Then reparent the child */ chtcb->ppid = ppid; /* The task specified by ppid is the new parent */ #ifdef CONFIG_SCHED_CHILD_STATUS /* Remove the child status entry from old parent TCB */ child = group_removechild(otcb->group, chpid); if (child) { /* Has the new parent's task group supressed child exit status? */ if ((ptcb->group->tg_flags && GROUP_FLAG_NOCLDWAIT) == 0) { /* No.. Add the child status entry to the new parent's task group */ group_addchild(ptcb->group, child); } else { /* Yes.. Discard the child status entry */ group_freechild(child); } /* Either case is a success */ ret = OK; } else { /* This would not be an error if the original parent's task group has * suppressed child exit status. */ ret = ((otcb->group->tg_flags && GROUP_FLAG_NOCLDWAIT) == 0) ? -ENOENT : OK; } #else /* CONFIG_SCHED_CHILD_STATUS */ DEBUGASSERT(otcb->nchildren > 0); otcb->nchildren--; /* The orignal parent now has one few children */ ptcb->nchildren++; /* The new parent has one additional child */ ret = OK; #endif /* CONFIG_SCHED_CHILD_STATUS */ errout_with_ints: irqrestore(flags); return ret; }
pid_t waitpid(pid_t pid, int *stat_loc, int options) { FAR struct tcb_s *rtcb = this_task(); FAR struct tcb_s *ctcb; #ifdef CONFIG_SCHED_CHILD_STATUS FAR struct child_status_s *child; bool retains; #endif FAR struct siginfo info; sigset_t set; int errcode; int ret; DEBUGASSERT(stat_loc); /* waitpid() is a cancellation point */ (void)enter_cancellation_point(); /* None of the options are supported */ #ifdef CONFIG_DEBUG_FEATURES if (options != 0) { set_errno(ENOSYS); leave_cancellation_point(); return ERROR; } #endif /* Create a signal set that contains only SIGCHLD */ (void)sigemptyset(&set); (void)sigaddset(&set, SIGCHLD); /* Disable pre-emption so that nothing changes while the loop executes */ sched_lock(); /* Verify that this task actually has children and that the requested PID * is actually a child of this task. */ #ifdef CONFIG_SCHED_CHILD_STATUS /* Does this task retain child status? */ retains = ((rtcb->group->tg_flags && GROUP_FLAG_NOCLDWAIT) == 0); if (rtcb->group->tg_children == NULL && retains) { errcode = ECHILD; goto errout_with_errno; } else if (pid != (pid_t)-1) { /* Get the TCB corresponding to this PID and make sure that the * thread it is our child. */ ctcb = sched_gettcb(pid); #ifdef HAVE_GROUP_MEMBERS if (ctcb == NULL || ctcb->group->tg_pgid != rtcb->group->tg_gid) #else if (ctcb == NULL || ctcb->group->tg_ppid != rtcb->pid) #endif { errcode = ECHILD; goto errout_with_errno; } /* Does this task retain child status? */ if (retains) { /* Check if this specific pid has allocated child status? */ if (group_findchild(rtcb->group, pid) == NULL) { errcode = ECHILD; goto errout_with_errno; } } } #else /* CONFIG_SCHED_CHILD_STATUS */ if (rtcb->group->tg_nchildren == 0) { /* There are no children */ errcode = ECHILD; goto errout_with_errno; } else if (pid != (pid_t)-1) { /* Get the TCB corresponding to this PID and make sure that the * thread it is our child. */ ctcb = sched_gettcb(pid); #ifdef HAVE_GROUP_MEMBERS if (ctcb == NULL || ctcb->group->tg_pgid != rtcb->group->tg_gid) #else if (ctcb == NULL || ctcb->group->tg_ppid != rtcb->pid) #endif { errcode = ECHILD; goto errout_with_errno; } } #endif /* CONFIG_SCHED_CHILD_STATUS */ /* Loop until the child that we are waiting for dies */ for (; ; ) { #ifdef CONFIG_SCHED_CHILD_STATUS /* Check if the task has already died. Signals are not queued in * NuttX. So a possibility is that the child has died and we * missed the death of child signal (we got some other signal * instead). */ if (pid == (pid_t)-1) { /* We are waiting for any child, check if there are still * chilren. */ DEBUGASSERT(!retains || rtcb->group->tg_children); if (retains && (child = group_exitchild(rtcb->group)) != NULL) { /* A child has exited. Apparently we missed the signal. * Return the saved exit status. */ /* The child has exited. Return the saved exit status */ *stat_loc = child->ch_status << 8; /* Discard the child entry and break out of the loop */ (void)group_removechild(rtcb->group, child->ch_pid); group_freechild(child); break; } } /* We are waiting for a specific PID. Does this task retain child status? */ else if (retains) { /* Get the current status of the child task. */ child = group_findchild(rtcb->group, pid); DEBUGASSERT(child); /* Did the child exit? */ if ((child->ch_flags & CHILD_FLAG_EXITED) != 0) { /* The child has exited. Return the saved exit status */ *stat_loc = child->ch_status << 8; /* Discard the child entry and break out of the loop */ (void)group_removechild(rtcb->group, pid); group_freechild(child); break; } } else { /* We can use kill() with signal number 0 to determine if that * task is still alive. */ ret = kill(pid, 0); if (ret < 0) { /* It is no longer running. We know that the child task * was running okay when we started, so we must have lost * the signal. In this case, we know that the task exit'ed, * but we do not know its exit status. It would be better * to reported ECHILD than bogus status. */ errcode = ECHILD; goto errout_with_errno; } } #else /* CONFIG_SCHED_CHILD_STATUS */ /* Check if the task has already died. Signals are not queued in * NuttX. So a possibility is that the child has died and we * missed the death of child signal (we got some other signal * instead). */ if (rtcb->group->tg_nchildren == 0 || (pid != (pid_t)-1 && (ret = kill(pid, 0)) < 0)) { /* We know that the child task was running okay we stared, * so we must have lost the signal. What can we do? * Let's return ECHILD.. that is at least informative. */ errcode = ECHILD; goto errout_with_errno; } #endif /* CONFIG_SCHED_CHILD_STATUS */ /* Wait for any death-of-child signal */ ret = sigwaitinfo(&set, &info); if (ret < 0) { goto errout_with_lock; } /* Was this the death of the thread we were waiting for? In the of * pid == (pid_t)-1, we are waiting for any child thread. */ if (info.si_signo == SIGCHLD && (pid == (pid_t)-1 || info.si_pid == pid)) { /* Yes... return the status and PID (in the event it was -1) */ *stat_loc = info.si_status << 8; pid = info.si_pid; break; } } leave_cancellation_point(); sched_unlock(); return (int)pid; errout_with_errno: set_errno(errcode); errout_with_lock: leave_cancellation_point(); sched_unlock(); return ERROR; }