/* Do not include dtrace.h, it redefines kmem_[alloc/free] */
extern void dtrace_fasttrap_fork(proc_t, proc_t);
extern void (*dtrace_helpers_fork)(proc_t, proc_t);
+extern void (*dtrace_proc_waitfor_exec_ptr)(proc_t);
extern void dtrace_lazy_dofs_duplicate(proc_t, proc_t);
+/*
+ * Since dtrace_proc_waitfor_exec_ptr can be added/removed in dtrace_subr.c,
+ * we will store its value before actually calling it.
+ */
+static void (*dtrace_proc_waitfor_hook)(proc_t) = NULL;
+
#include <sys/dtrace_ptss.h>
#endif
#include <security/audit/audit.h>
#include <mach/mach_types.h>
+#include <kern/coalition.h>
#include <kern/kern_types.h>
#include <kern/kalloc.h>
#include <kern/mach_param.h>
void *act_thread_csave(void);
-thread_t cloneproc(task_t, proc_t, int);
+thread_t cloneproc(task_t, coalition_t, proc_t, int, int);
proc_t forkproc(proc_t);
void forkproc_free(proc_t);
-thread_t fork_create_child(task_t parent_task, proc_t child, int inherit_memory, int is64bit);
+thread_t fork_create_child(task_t parent_task, coalition_t parent_coalition, proc_t child, int inherit_memory, int is64bit);
void proc_vfork_begin(proc_t parent_proc);
void proc_vfork_end(proc_t parent_proc);
thread_t child_thread;
int err;
- if ((err = fork1(parent_proc, &child_thread, PROC_CREATE_VFORK)) != 0) {
+ if ((err = fork1(parent_proc, &child_thread, PROC_CREATE_VFORK, COALITION_NULL)) != 0) {
retval[1] = 0;
} else {
- /*
- * kludge: rely on uu_proc being set in the vfork case,
- * rather than returning the actual thread. We can remove
- * this when we remove the uu_proc/current_proc() kludge.
- */
- proc_t child_proc = current_proc();
+ uthread_t ut = get_bsdthread_info(current_thread());
+ proc_t child_proc = ut->uu_proc;
retval[0] = child_proc->p_pid;
retval[1] = 1; /* flag child return for user space */
proc_signalend(child_proc, 0);
proc_transend(child_proc, 0);
- /* flag the fork has occurred */
proc_knote(parent_proc, NOTE_FORK | child_proc->p_pid);
DTRACE_PROC1(create, proc_t, child_proc);
+ ut->uu_flag &= ~UT_VFORKING;
}
- return(err);
+ return (err);
}
* Mach thread_t of the child process
* breated
* kind kind of creation being requested
+ * coalition if spawn, coalition the child process
+ * should join, or COALITION_NULL to
+ * inherit the parent's. On non-spawns,
+ * this param is ignored and the child
+ * always inherits the parent's coalition.
*
* Notes: Permissable values for 'kind':
*
* back to the other information.
*/
int
-fork1(proc_t parent_proc, thread_t *child_threadp, int kind)
+fork1(proc_t parent_proc, thread_t *child_threadp, int kind, coalition_t coalition)
{
thread_t parent_thread = (thread_t)current_thread();
uthread_t parent_uthread = (uthread_t)get_bsdthread_info(parent_thread);
child_proc->p_vforkact = parent_thread;
child_proc->p_stat = SRUN;
- parent_uthread->uu_flag |= UT_VFORK;
+ /*
+ * Until UT_VFORKING is cleared at the end of the vfork
+ * syscall, the process identity of this thread is slightly
+ * murky.
+ *
+ * As long as UT_VFORK and it's associated field (uu_proc)
+ * is set, current_proc() will always return the child process.
+ *
+ * However dtrace_proc_selfpid() returns the parent pid to
+ * ensure that e.g. the proc:::create probe actions accrue
+ * to the parent. (Otherwise the child magically seems to
+ * have created itself!)
+ */
+ parent_uthread->uu_flag |= UT_VFORK | UT_VFORKING;
parent_uthread->uu_proc = child_proc;
parent_uthread->uu_userstate = (void *)act_thread_csave();
parent_uthread->uu_vforkmask = parent_uthread->uu_sigmask;
* will, in effect, create a duplicate of it, with only minor
* differences. Contrarily, spawned processes do not inherit.
*/
- if ((child_thread = cloneproc(parent_proc->task, parent_proc, spawn ? FALSE : TRUE)) == NULL) {
+ if ((child_thread = cloneproc(parent_proc->task,
+ spawn ? coalition : COALITION_NULL,
+ parent_proc,
+ spawn ? FALSE : TRUE,
+ FALSE)) == NULL) {
/* Failed to create thread */
err = EAGAIN;
goto bad;
/* return the thread pointer to the caller */
*child_threadp = child_thread;
-#if CONFIG_MEMORYSTATUS
- if (!err) {
- memorystatus_list_add(child_proc->p_pid, DEFAULT_JETSAM_PRIORITY, -1);
- }
-#endif
-
bad:
/*
* In the error case, we return a 0 value for the returned pid (but
* process
*
* Parameters: parent_task parent task
+ * parent_coalition parent_coalition
* child_proc child process
* inherit_memory TRUE, if the parents address space is
* to be inherited by the child
* 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.
+ * thread creation, a uthread) in the parent coalition, 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)
+fork_create_child(task_t parent_task, coalition_t parent_coalition, proc_t child_proc, int inherit_memory, int is64bit)
{
thread_t child_thread = NULL;
task_t child_task;
/* Create a new task for the child process */
result = task_create_internal(parent_task,
+ parent_coalition,
inherit_memory,
is64bit,
&child_task);
if (result != KERN_SUCCESS) {
- printf("execve: task_create_internal failed. Code: %d\n", result);
+ printf("%s: task_create_internal failed. Code: %d\n",
+ __func__, result);
goto bad;
}
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
/* 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);
+ 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.
- */
+ * Tag thread as being the first thread in its task.
+ */
thread_set_tag(child_thread, THREAD_TAG_MAINTHREAD);
bad:
retval[1] = 0; /* flag parent return for user space */
- if ((err = fork1(parent_proc, &child_thread, PROC_CREATE_FORK)) == 0) {
+ if ((err = fork1(parent_proc, &child_thread, PROC_CREATE_FORK, COALITION_NULL)) == 0) {
task_t child_task;
proc_t child_proc;
proc_knote(parent_proc, NOTE_FORK | child_proc->p_pid);
DTRACE_PROC1(create, proc_t, child_proc);
+#if CONFIG_DTRACE
+ if ((dtrace_proc_waitfor_hook = dtrace_proc_waitfor_exec_ptr) != NULL)
+ (*dtrace_proc_waitfor_hook)(child_proc);
+#endif
+
/* "Return" to the child */
(void)thread_resume(child_thread);
* memory from the parent; if this is
* non-NULL, then the parent_task must
* also be non-NULL
+ * memstat_internal Whether to track the process in the
+ * jetsam priority list (if configured)
*
* Returns: !NULL pointer to new child thread
* NULL Failure (unspecified)
* live with this being somewhat awkward.
*/
thread_t
-cloneproc(task_t parent_task, proc_t parent_proc, int inherit_memory)
+cloneproc(task_t parent_task, coalition_t parent_coalition, proc_t parent_proc, int inherit_memory, int memstat_internal)
{
+#if !CONFIG_MEMORYSTATUS
+#pragma unused(memstat_internal)
+#endif
task_t child_task;
proc_t child_proc;
thread_t child_thread = NULL;
goto bad;
}
- child_thread = fork_create_child(parent_task, child_proc, inherit_memory, (parent_task == TASK_NULL) ? FALSE : (parent_proc->p_flag & P_LP64));
+ child_thread = fork_create_child(parent_task, parent_coalition, child_proc, inherit_memory, (parent_task == TASK_NULL) ? FALSE : (parent_proc->p_flag & P_LP64));
if (child_thread == NULL) {
/*
OSBitAndAtomic(~((uint32_t)P_LP64), (UInt32 *)&child_proc->p_flag);
}
+#if CONFIG_MEMORYSTATUS
+ if (memstat_internal) {
+ proc_list_lock();
+ child_proc->p_memstat_state |= P_MEMSTAT_INTERNAL;
+ proc_list_unlock();
+ }
+#endif
+
/* make child visible */
pinsertchild(parent_proc, child_proc);
/* Need to undo the effects of the fdcopy(), if any */
fdfree(p);
-#if !CONFIG_EMBEDDED
- if (p->p_legacy_behavior & PROC_LEGACY_BEHAVIOR_IOTHROTTLE) {
- throttle_legacy_process_decr();
- }
-#endif
-
/*
* Drop the reference on a text vnode pointer, if any
* XXX This code is broken in forkproc(); see <rdar://4256419>;
* Increase reference counts on shared objects.
* The p_stats and p_sigacts substructs are set in vm_fork.
*/
-#if !CONFIG_EMBEDDED
child_proc->p_flag = (parent_proc->p_flag & (P_LP64 | P_TRANSLATED | P_AFFINITY | P_DISABLE_ASLR | P_DELAYIDLESLEEP));
-#else /* !CONFIG_EMBEDDED */
- child_proc->p_flag = (parent_proc->p_flag & (P_LP64 | P_TRANSLATED | P_AFFINITY | P_DISABLE_ASLR));
-#endif /* !CONFIG_EMBEDDED */
if (parent_proc->p_flag & P_PROFIL)
startprofclock(child_proc);
-#if !CONFIG_EMBEDDED
- if (child_proc->p_legacy_behavior & PROC_LEGACY_BEHAVIOR_IOTHROTTLE) {
- throttle_legacy_process_incr();
- }
-#endif
+ child_proc->p_vfs_iopolicy = (parent_proc->p_vfs_iopolicy & (P_VFS_IOPOLICY_FORCE_HFS_CASE_SENSITIVITY));
/*
* Note that if the current thread has an assumed identity, this
/* Intialize new process stats, including start time */
/* <rdar://6640543> non-zeroed portion contains garbage AFAICT */
- bzero(&child_proc->p_stats->pstat_startzero,
- (unsigned) ((caddr_t)&child_proc->p_stats->pstat_endzero -
- (caddr_t)&child_proc->p_stats->pstat_startzero));
- bzero(&child_proc->p_stats->user_p_prof, sizeof(struct user_uprof));
- microtime(&child_proc->p_start);
- child_proc->p_stats->p_start = child_proc->p_start; /* for compat */
+ bzero(child_proc->p_stats, sizeof(*child_proc->p_stats));
+ microtime_with_abstime(&child_proc->p_start, &child_proc->p_stats->ps_start);
if (parent_proc->p_sigacts != NULL)
(void)memcpy(child_proc->p_sigacts,
* but indicate that the process is in (the creation) transition.
*/
proc_signalstart(child_proc, 0);
- proc_transstart(child_proc, 0);
+ proc_transstart(child_proc, 0, 0);
+
+ child_proc->p_pcaction = 0;
- child_proc->p_pcaction = (parent_proc->p_pcaction) & P_PCMAX;
TAILQ_INIT(&child_proc->p_uthlist);
TAILQ_INIT(&child_proc->p_aio_activeq);
TAILQ_INIT(&child_proc->p_aio_doneq);
child_proc->p_lflag |= P_LREGISTER;
}
child_proc->p_dispatchqueue_offset = parent_proc->p_dispatchqueue_offset;
+ child_proc->p_dispatchqueue_serialno_offset = parent_proc->p_dispatchqueue_serialno_offset;
#if PSYNCH
pth_proc_hashinit(child_proc);
#endif /* PSYNCH */
}
#endif
- /* Default to no tracking of dirty state */
- child_proc->p_dirty = 0;
+#if CONFIG_MEMORYSTATUS
+ /* Memorystatus + jetsam init */
+ child_proc->p_memstat_state = 0;
+ child_proc->p_memstat_effectivepriority = JETSAM_PRIORITY_DEFAULT;
+ child_proc->p_memstat_requestedpriority = JETSAM_PRIORITY_DEFAULT;
+ child_proc->p_memstat_userdata = 0;
+#if CONFIG_FREEZE
+ child_proc->p_memstat_suspendedfootprint = 0;
+#endif
+ child_proc->p_memstat_dirty = 0;
+ child_proc->p_memstat_idledeadline = 0;
+#endif /* CONFIG_MEMORYSTATUS */
bad:
return(child_proc);
p = (proc_t) get_bsdtask_info(task);
uth = (uthread_t)ut;
- uth->uu_kwe.kwe_uth = uth;
uth->uu_thread = thread;
/*
struct _select *sel;
uthread_t uth = (uthread_t)uthread;
proc_t p = (proc_t)bsd_info;
-
+ void *pth_name;
if (uth->uu_lowpri_window || uth->uu_throttle_info) {
/*
* Calling this routine will clean up any throttle info reference
* still inuse by the thread.
*/
- throttle_lowpri_io(FALSE);
+ throttle_lowpri_io(0);
}
/*
* Per-thread audit state should never last beyond system
if (uth->uu_allocsize && uth->uu_wqset){
kfree(uth->uu_wqset, uth->uu_allocsize);
- sel->count = 0;
uth->uu_allocsize = 0;
uth->uu_wqset = 0;
- sel->wql = 0;
}
-
- if(uth->pth_name != NULL)
- {
- kfree(uth->pth_name, MAXTHREADNAMESIZE);
- uth->pth_name = 0;
+
+ /*
+ * <rdar://17834538>
+ * Set pth_name to NULL before calling free().
+ * Previously there was a race condition in the
+ * case this code was executing during a stackshot
+ * where the stackshot could try and copy pth_name
+ * after it had been freed and before if was marked
+ * as null.
+ */
+ if (uth->pth_name != NULL) {
+ pth_name = uth->pth_name;
+ uth->pth_name = NULL;
+ kfree(pth_name, MAXTHREADNAMESIZE);
}
+
if ((task != kernel_task) && p) {
if (((uth->uu_flag & UT_VFORK) == UT_VFORK) && (uth->uu_proc != PROC_NULL)) {
void
uthread_zone_free(void *uthread)
{
+ uthread_t uth = (uthread_t)uthread;
+
+ if (uth->t_tombstone) {
+ kfree(uth->t_tombstone, sizeof(struct doc_tombstone));
+ uth->t_tombstone = NULL;
+ }
+
/* and free the uthread itself */
zfree(uthread_zone, uthread);
}
projects / apple / xnu.git / blobdiff