/*
* fork_create_child
*
* Description: Common operations associated with the creation of a child
* process
*
* Parameters: parent_task parent task
* child_proc child process
* inherit_memory TRUE, if the parents address space is
* to be inherited by the child
* is64bit TRUE, if the child being created will
* be associated with a 64 bit process
* rather than a 32 bit process
*
* Note: This code is called in the fork() case, from the execve() call
* graph, if implementing an execve() following a vfork(), from
* the posix_spawn() call graph (which implicitly includes a
* vfork() equivalent call, and in the system bootstrap case.
*
* It creates a new task and thread (and as a side effect of the
* thread creation, a uthread), which is then associated with the
* process 'child'. If the parent process address space is to
* be inherited, then a flag indicates that the newly created
* task should inherit this from the child task.
*
* As a special concession to bootstrapping the initial process
* in the system, it's possible for 'parent_task' to be TASK_NULL;
* in this case, 'inherit_memory' MUST be FALSE.
*/
thread_t
fork_create_child(task_t parent_task, proc_t child_proc, int inherit_memory, int is64bit)
{
thread_t child_thread = NULL;
task_t child_task;
kern_return_t result;
/* Create a new task for the child process */
result = task_create_internal(parent_task,
inherit_memory,
is64bit,
&child_task);
if (result != KERN_SUCCESS) {
printf("execve: task_create_internal failed. Code: %d\n", result);
goto bad;
}
/* Set the child process task to the new task */
child_proc->task = child_task;
/* Set child task process to child proc */
set_bsdtask_info(child_task, child_proc);
/* Propagate CPU limit timer from parent */
if (timerisset(&child_proc->p_rlim_cpu))
task_vtimer_set(child_task, TASK_VTIMER_RLIM);
/* Set/clear 64 bit vm_map flag */
if (is64bit)
vm_map_set_64bit(get_task_map(child_task));
else
vm_map_set_32bit(get_task_map(child_task));
#if CONFIG_MACF
/* Update task for MAC framework */
/* valid to use p_ucred as child is still not running ... */
mac_task_label_update_cred(child_proc->p_ucred, child_task);
#endif
/*
* Set child process BSD visible scheduler priority if nice value
* inherited from parent
*/
if (child_proc->p_nice != 0)
resetpriority(child_proc);
/* Create a new thread for the child process */
result = thread_create(child_task, &child_thread);
if (result != KERN_SUCCESS) {
printf("execve: thread_create failed. Code: %d\n", result);
task_deallocate(child_task);
child_task = NULL;
}
bad:
thread_yield_internal(1);
return(child_thread);
}
/* ARGSUSED */
static void
schedcpu(void)
{
register fixpt_t loadfac = loadfactor(averunnable.ldavg[0]);
struct thread *td;
struct proc *p;
struct td_sched *ts;
int awake;
sx_slock(&allproc_lock);
FOREACH_PROC_IN_SYSTEM(p) {
PROC_LOCK(p);
if (p->p_state == PRS_NEW) {
PROC_UNLOCK(p);
continue;
}
FOREACH_THREAD_IN_PROC(p, td) {
awake = 0;
thread_lock(td);
ts = td->td_sched;
/*
* Increment sleep time (if sleeping). We
* ignore overflow, as above.
*/
/*
* The td_sched slptimes are not touched in wakeup
* because the thread may not HAVE everything in
* memory? XXX I think this is out of date.
*/
if (TD_ON_RUNQ(td)) {
awake = 1;
td->td_flags &= ~TDF_DIDRUN;
} else if (TD_IS_RUNNING(td)) {
awake = 1;
/* Do not clear TDF_DIDRUN */
} else if (td->td_flags & TDF_DIDRUN) {
awake = 1;
td->td_flags &= ~TDF_DIDRUN;
}
/*
* ts_pctcpu is only for ps and ttyinfo().
*/
ts->ts_pctcpu = (ts->ts_pctcpu * ccpu) >> FSHIFT;
/*
* If the td_sched has been idle the entire second,
* stop recalculating its priority until
* it wakes up.
*/
if (ts->ts_cpticks != 0) {
#if (FSHIFT >= CCPU_SHIFT)
ts->ts_pctcpu += (realstathz == 100)
? ((fixpt_t) ts->ts_cpticks) <<
(FSHIFT - CCPU_SHIFT) :
100 * (((fixpt_t) ts->ts_cpticks)
<< (FSHIFT - CCPU_SHIFT)) / realstathz;
#else
ts->ts_pctcpu += ((FSCALE - ccpu) *
(ts->ts_cpticks *
FSCALE / realstathz)) >> FSHIFT;
#endif
ts->ts_cpticks = 0;
}
/*
* If there are ANY running threads in this process,
* then don't count it as sleeping.
* XXX: this is broken.
*/
if (awake) {
if (ts->ts_slptime > 1) {
/*
* In an ideal world, this should not
* happen, because whoever woke us
* up from the long sleep should have
* unwound the slptime and reset our
* priority before we run at the stale
* priority. Should KASSERT at some
* point when all the cases are fixed.
*/
updatepri(td);
}
ts->ts_slptime = 0;
} else
ts->ts_slptime++;
if (ts->ts_slptime > 1) {
thread_unlock(td);
continue;
}
td->td_estcpu = decay_cpu(loadfac, td->td_estcpu);
resetpriority(td);
resetpriority_thread(td);
thread_unlock(td);
}
/*
* fork_create_child
*
* Description: Common operations associated with the creation of a child
* process
*
* Parameters: parent_task parent task
* parent_coalitions parent's set of coalitions
* child_proc child process
* inherit_memory TRUE, if the parents address space is
* to be inherited by the child
* is64bit TRUE, if the child being created will
* be associated with a 64 bit process
* rather than a 32 bit process
*
* Note: This code is called in the fork() case, from the execve() call
* graph, if implementing an execve() following a vfork(), from
* the posix_spawn() call graph (which implicitly includes a
* vfork() equivalent call, and in the system bootstrap case.
*
* It creates a new task and thread (and as a side effect of the
* thread creation, a uthread) in the parent coalition set, which is
* then associated with the process 'child'. If the parent
* process address space is to be inherited, then a flag
* indicates that the newly created task should inherit this from
* the child task.
*
* As a special concession to bootstrapping the initial process
* in the system, it's possible for 'parent_task' to be TASK_NULL;
* in this case, 'inherit_memory' MUST be FALSE.
*/
thread_t
fork_create_child(task_t parent_task, coalition_t *parent_coalitions, proc_t child_proc, int inherit_memory, int is64bit)
{
thread_t child_thread = NULL;
task_t child_task;
kern_return_t result;
/* Create a new task for the child process */
result = task_create_internal(parent_task,
parent_coalitions,
inherit_memory,
is64bit,
&child_task);
if (result != KERN_SUCCESS) {
printf("%s: task_create_internal failed. Code: %d\n",
__func__, result);
goto bad;
}
/* Set the child process task to the new task */
child_proc->task = child_task;
/* Set child task process to child proc */
set_bsdtask_info(child_task, child_proc);
/* Propagate CPU limit timer from parent */
if (timerisset(&child_proc->p_rlim_cpu))
task_vtimer_set(child_task, TASK_VTIMER_RLIM);
/* Set/clear 64 bit vm_map flag */
if (is64bit)
vm_map_set_64bit(get_task_map(child_task));
else
vm_map_set_32bit(get_task_map(child_task));
/*
* Set child process BSD visible scheduler priority if nice value
* inherited from parent
*/
if (child_proc->p_nice != 0)
resetpriority(child_proc);
/* Create a new thread for the child process */
result = thread_create_with_continuation(child_task, &child_thread, (thread_continue_t)proc_wait_to_return);
if (result != KERN_SUCCESS) {
printf("%s: thread_create failed. Code: %d\n",
__func__, result);
task_deallocate(child_task);
child_task = NULL;
}
/*
* Tag thread as being the first thread in its task.
*/
thread_set_tag(child_thread, THREAD_TAG_MAINTHREAD);
bad:
thread_yield_internal(1);
return(child_thread);
}