+ if ((error = copyin(px_args.port_actions, px_spap,
+ px_args.port_actions_size)) != 0) {
+ goto bad;
+ }
+
+ /* Verify that the action count matches the struct size */
+ size_t pasize = PS_PORT_ACTIONS_SIZE(px_spap->pspa_count);
+ if (pasize == 0 || pasize != px_args.port_actions_size) {
+ error = EINVAL;
+ goto bad;
+ }
+ }
+#if CONFIG_PERSONAS
+ /* copy in the persona info */
+ if (px_args.persona_info_size != 0 && px_args.persona_info != 0) {
+ /* for now, we need the exact same struct in user space */
+ if (px_args.persona_info_size != sizeof(*px_persona)) {
+ error = ERANGE;
+ goto bad;
+ }
+
+ MALLOC(px_persona, struct _posix_spawn_persona_info *, px_args.persona_info_size, M_TEMP, M_WAITOK | M_ZERO);
+ if (px_persona == NULL) {
+ error = ENOMEM;
+ goto bad;
+ }
+ imgp->ip_px_persona = px_persona;
+
+ if ((error = copyin(px_args.persona_info, px_persona,
+ px_args.persona_info_size)) != 0) {
+ goto bad;
+ }
+ if ((error = spawn_validate_persona(px_persona)) != 0) {
+ goto bad;
+ }
+ }
+#endif
+#if CONFIG_MACF
+ if (px_args.mac_extensions_size != 0) {
+ if ((error = spawn_copyin_macpolicyinfo(&px_args, (_posix_spawn_mac_policy_extensions_t *)&imgp->ip_px_smpx)) != 0) {
+ goto bad;
+ }
+ }
+#endif /* CONFIG_MACF */
+ }
+
+ /* set uthread to parent */
+ uthread = get_bsdthread_info(current_thread());
+
+ /*
+ * <rdar://6640530>; this does not result in a behaviour change
+ * relative to Leopard, so there should not be any existing code
+ * which depends on it.
+ */
+ if (uthread->uu_flag & UT_VFORK) {
+ error = EINVAL;
+ goto bad;
+ }
+
+ /*
+ * If we don't have the extension flag that turns "posix_spawn()"
+ * into "execve() with options", then we will be creating a new
+ * process which does not inherit memory from the parent process,
+ * which is one of the most expensive things about using fork()
+ * and execve().
+ */
+ if (imgp->ip_px_sa == NULL || !(px_sa.psa_flags & POSIX_SPAWN_SETEXEC)) {
+ /* Set the new task's coalition, if it is requested. */
+ coalition_t coal[COALITION_NUM_TYPES] = { COALITION_NULL };
+#if CONFIG_COALITIONS
+ int i, ncoals;
+ kern_return_t kr = KERN_SUCCESS;
+ struct _posix_spawn_coalition_info coal_info;
+ int coal_role[COALITION_NUM_TYPES];
+
+ if (imgp->ip_px_sa == NULL || !px_args.coal_info) {
+ goto do_fork1;
+ }
+
+ memset(&coal_info, 0, sizeof(coal_info));
+
+ if (px_args.coal_info_size > sizeof(coal_info)) {
+ px_args.coal_info_size = sizeof(coal_info);
+ }
+ error = copyin(px_args.coal_info,
+ &coal_info, px_args.coal_info_size);
+ if (error != 0) {
+ goto bad;
+ }
+
+ ncoals = 0;
+ for (i = 0; i < COALITION_NUM_TYPES; i++) {
+ uint64_t cid = coal_info.psci_info[i].psci_id;
+ if (cid != 0) {
+ /*
+ * don't allow tasks which are not in a
+ * privileged coalition to spawn processes
+ * into coalitions other than their own
+ */
+ if (!task_is_in_privileged_coalition(p->task, i)) {
+ coal_dbg("ERROR: %d not in privilegd "
+ "coalition of type %d",
+ p->p_pid, i);
+ spawn_coalitions_release_all(coal);
+ error = EPERM;
+ goto bad;
+ }
+
+ coal_dbg("searching for coalition id:%llu", cid);
+ /*
+ * take a reference and activation on the
+ * coalition to guard against free-while-spawn
+ * races
+ */
+ coal[i] = coalition_find_and_activate_by_id(cid);
+ if (coal[i] == COALITION_NULL) {
+ coal_dbg("could not find coalition id:%llu "
+ "(perhaps it has been terminated or reaped)", cid);
+ /*
+ * release any other coalition's we
+ * may have a reference to
+ */
+ spawn_coalitions_release_all(coal);
+ error = ESRCH;
+ goto bad;
+ }
+ if (coalition_type(coal[i]) != i) {
+ coal_dbg("coalition with id:%lld is not of type:%d"
+ " (it's type:%d)", cid, i, coalition_type(coal[i]));
+ error = ESRCH;
+ goto bad;
+ }
+ coal_role[i] = coal_info.psci_info[i].psci_role;
+ ncoals++;
+ }
+ }
+ if (ncoals < COALITION_NUM_TYPES) {
+ /*
+ * If the user is attempting to spawn into a subset of
+ * the known coalition types, then make sure they have
+ * _at_least_ specified a resource coalition. If not,
+ * the following fork1() call will implicitly force an
+ * inheritance from 'p' and won't actually spawn the
+ * new task into the coalitions the user specified.
+ * (also the call to coalitions_set_roles will panic)
+ */
+ if (coal[COALITION_TYPE_RESOURCE] == COALITION_NULL) {
+ spawn_coalitions_release_all(coal);
+ error = EINVAL;
+ goto bad;
+ }
+ }
+do_fork1:
+#endif /* CONFIG_COALITIONS */
+
+ /*
+ * note that this will implicitly inherit the
+ * caller's persona (if it exists)
+ */
+ error = fork1(p, &imgp->ip_new_thread, PROC_CREATE_SPAWN, coal);
+ /* returns a thread and task reference */
+
+ if (error == 0) {
+ new_task = get_threadtask(imgp->ip_new_thread);
+ }
+#if CONFIG_COALITIONS
+ /* set the roles of this task within each given coalition */
+ if (error == 0) {
+ kr = coalitions_set_roles(coal, new_task, coal_role);
+ if (kr != KERN_SUCCESS) {
+ error = EINVAL;
+ }
+ if (kdebug_debugid_enabled(MACHDBG_CODE(DBG_MACH_COALITION,
+ MACH_COALITION_ADOPT))) {
+ for (i = 0; i < COALITION_NUM_TYPES; i++) {
+ if (coal[i] != COALITION_NULL) {
+ /*
+ * On 32-bit targets, uniqueid
+ * will get truncated to 32 bits
+ */
+ KDBG_RELEASE(MACHDBG_CODE(
+ DBG_MACH_COALITION,
+ MACH_COALITION_ADOPT),
+ coalition_id(coal[i]),
+ get_task_uniqueid(new_task));
+ }
+ }
+ }
+ }
+
+ /* drop our references and activations - fork1() now holds them */
+ spawn_coalitions_release_all(coal);
+#endif /* CONFIG_COALITIONS */
+ if (error != 0) {
+ goto bad;
+ }
+ imgp->ip_flags |= IMGPF_SPAWN; /* spawn w/o exec */
+ spawn_no_exec = TRUE; /* used in later tests */
+
+#if CONFIG_PERSONAS
+ /*
+ * If the parent isn't in a persona (launchd), and
+ * hasn't specified a new persona for the process,
+ * then we'll put the process into the system persona
+ *
+ * TODO: this will have to be re-worked because as of
+ * now, without any launchd adoption, the resulting
+ * xpcproxy process will not have sufficient
+ * privileges to setuid/gid.
+ */
+#if 0
+ if (!proc_has_persona(p) && imgp->ip_px_persona == NULL) {
+ MALLOC(px_persona, struct _posix_spawn_persona_info *,
+ sizeof(*px_persona), M_TEMP, M_WAITOK | M_ZERO);
+ if (px_persona == NULL) {
+ error = ENOMEM;
+ goto bad;
+ }
+ px_persona->pspi_id = persona_get_id(g_system_persona);
+ imgp->ip_px_persona = px_persona;
+ }
+#endif /* 0 */
+#endif /* CONFIG_PERSONAS */
+ } else {
+ /*
+ * For execve case, create a new task and thread
+ * which points to current_proc. The current_proc will point
+ * to the new task after image activation and proc ref drain.
+ *
+ * proc (current_proc) <----- old_task (current_task)
+ * ^ | ^
+ * | | |
+ * | ----------------------------------
+ * |
+ * --------- new_task (task marked as TF_EXEC_COPY)
+ *
+ * After image activation, the proc will point to the new task
+ * and would look like following.
+ *
+ * proc (current_proc) <----- old_task (current_task, marked as TPF_DID_EXEC)
+ * ^ |
+ * | |
+ * | ----------> new_task
+ * | |
+ * -----------------
+ *
+ * During exec any transition from new_task -> proc is fine, but don't allow
+ * transition from proc->task, since it will modify old_task.
+ */
+ imgp->ip_new_thread = fork_create_child(old_task,
+ NULL,
+ p,
+ FALSE,
+ p->p_flag & P_LP64,
+ task_get_64bit_data(old_task),
+ TRUE);
+ /* task and thread ref returned by fork_create_child */
+ if (imgp->ip_new_thread == NULL) {
+ error = ENOMEM;
+ goto bad;
+ }
+
+ new_task = get_threadtask(imgp->ip_new_thread);
+ imgp->ip_flags |= IMGPF_EXEC;
+ }
+
+ if (spawn_no_exec) {
+ p = (proc_t)get_bsdthreadtask_info(imgp->ip_new_thread);
+
+ /*
+ * We had to wait until this point before firing the
+ * proc:::create probe, otherwise p would not point to the
+ * child process.
+ */
+ DTRACE_PROC1(create, proc_t, p);
+ }
+ assert(p != NULL);
+
+ context.vc_thread = imgp->ip_new_thread;
+ context.vc_ucred = p->p_ucred; /* XXX must NOT be kauth_cred_get() */
+
+ /*
+ * Post fdcopy(), pre exec_handle_sugid() - this is where we want
+ * to handle the file_actions. Since vfork() also ends up setting
+ * us into the parent process group, and saved off the signal flags,
+ * this is also where we want to handle the spawn flags.
+ */
+
+ /* Has spawn file actions? */
+ if (imgp->ip_px_sfa != NULL) {
+ /*
+ * The POSIX_SPAWN_CLOEXEC_DEFAULT flag
+ * is handled in exec_handle_file_actions().
+ */
+ if ((error = exec_handle_file_actions(imgp,
+ imgp->ip_px_sa != NULL ? px_sa.psa_flags : 0)) != 0) {
+ goto bad;
+ }
+ }
+
+ /* Has spawn port actions? */
+ if (imgp->ip_px_spa != NULL) {
+ boolean_t is_adaptive = FALSE;
+ boolean_t portwatch_present = FALSE;
+
+ /* Will this process become adaptive? The apptype isn't ready yet, so we can't look there. */
+ if (imgp->ip_px_sa != NULL && px_sa.psa_apptype == POSIX_SPAWN_PROC_TYPE_DAEMON_ADAPTIVE) {
+ is_adaptive = TRUE;
+ }
+
+ /*
+ * portwatch only:
+ * Allocate a place to store the ports we want to bind to the new task
+ * We can't bind them until after the apptype is set.
+ */
+ if (px_spap->pspa_count != 0 && is_adaptive) {
+ portwatch_count = px_spap->pspa_count;
+ MALLOC(portwatch_ports, ipc_port_t *, (sizeof(ipc_port_t) * portwatch_count), M_TEMP, M_WAITOK | M_ZERO);
+ } else {
+ portwatch_ports = NULL;
+ }
+
+ if ((error = exec_handle_port_actions(imgp, &portwatch_present, portwatch_ports)) != 0) {
+ goto bad;
+ }
+
+ if (portwatch_present == FALSE && portwatch_ports != NULL) {
+ FREE(portwatch_ports, M_TEMP);
+ portwatch_ports = NULL;
+ portwatch_count = 0;
+ }
+ }
+
+ /* Has spawn attr? */
+ if (imgp->ip_px_sa != NULL) {
+ /*
+ * Set the process group ID of the child process; this has
+ * to happen before the image activation.
+ */
+ if (px_sa.psa_flags & POSIX_SPAWN_SETPGROUP) {
+ struct setpgid_args spga;
+ spga.pid = p->p_pid;
+ spga.pgid = px_sa.psa_pgroup;
+ /*
+ * Effectively, call setpgid() system call; works
+ * because there are no pointer arguments.
+ */
+ if ((error = setpgid(p, &spga, ival)) != 0) {
+ goto bad;
+ }
+ }
+
+ /*
+ * Reset UID/GID to parent's RUID/RGID; This works only
+ * because the operation occurs *after* the vfork() and
+ * before the call to exec_handle_sugid() by the image
+ * activator called from exec_activate_image(). POSIX
+ * requires that any setuid/setgid bits on the process
+ * image will take precedence over the spawn attributes
+ * (re)setting them.
+ *
+ * Modifications to p_ucred must be guarded using the
+ * proc's ucred lock. This prevents others from accessing
+ * a garbage credential.
+ */
+ while (px_sa.psa_flags & POSIX_SPAWN_RESETIDS) {
+ kauth_cred_t my_cred = kauth_cred_proc_ref(p);
+ kauth_cred_t my_new_cred = kauth_cred_setuidgid(my_cred, kauth_cred_getruid(my_cred), kauth_cred_getrgid(my_cred));
+
+ if (my_cred == my_new_cred) {
+ kauth_cred_unref(&my_cred);
+ break;
+ }
+
+ /* update cred on proc */
+ proc_ucred_lock(p);
+
+ if (p->p_ucred != my_cred) {
+ proc_ucred_unlock(p);
+ kauth_cred_unref(&my_new_cred);
+ continue;
+ }
+
+ /* donate cred reference on my_new_cred to p->p_ucred */
+ p->p_ucred = my_new_cred;
+ PROC_UPDATE_CREDS_ONPROC(p);
+ proc_ucred_unlock(p);
+
+ /* drop additional reference that was taken on the previous cred */
+ kauth_cred_unref(&my_cred);
+ }
+
+#if CONFIG_PERSONAS
+ if (spawn_no_exec && imgp->ip_px_persona != NULL) {
+ /*
+ * If we were asked to spawn a process into a new persona,
+ * do the credential switch now (which may override the UID/GID
+ * inherit done just above). It's important to do this switch
+ * before image activation both for reasons stated above, and
+ * to ensure that the new persona has access to the image/file
+ * being executed.
+ */
+ error = spawn_persona_adopt(p, imgp->ip_px_persona);
+ if (error != 0) {
+ goto bad;
+ }
+ }
+#endif /* CONFIG_PERSONAS */
+#if !SECURE_KERNEL
+ /*
+ * Disable ASLR for the spawned process.
+ *
+ * But only do so if we are not embedded + RELEASE.
+ * While embedded allows for a boot-arg (-disable_aslr)
+ * to deal with this (which itself is only honored on
+ * DEVELOPMENT or DEBUG builds of xnu), it is often
+ * useful or necessary to disable ASLR on a per-process
+ * basis for unit testing and debugging.
+ */
+ if (px_sa.psa_flags & _POSIX_SPAWN_DISABLE_ASLR) {
+ OSBitOrAtomic(P_DISABLE_ASLR, &p->p_flag);
+ }
+#endif /* !SECURE_KERNEL */
+
+ /* Randomize high bits of ASLR slide */
+ if (px_sa.psa_flags & _POSIX_SPAWN_HIGH_BITS_ASLR) {
+ imgp->ip_flags |= IMGPF_HIGH_BITS_ASLR;
+ }
+
+ /*
+ * Forcibly disallow execution from data pages for the spawned process
+ * even if it would otherwise be permitted by the architecture default.
+ */
+ if (px_sa.psa_flags & _POSIX_SPAWN_ALLOW_DATA_EXEC) {
+ imgp->ip_flags |= IMGPF_ALLOW_DATA_EXEC;
+ }
+ }
+
+ /*
+ * Disable ASLR during image activation. This occurs either if the
+ * _POSIX_SPAWN_DISABLE_ASLR attribute was found above or if
+ * P_DISABLE_ASLR was inherited from the parent process.
+ */
+ if (p->p_flag & P_DISABLE_ASLR) {
+ imgp->ip_flags |= IMGPF_DISABLE_ASLR;
+ }
+
+ /*
+ * Clear transition flag so we won't hang if exec_activate_image() causes
+ * an automount (and launchd does a proc sysctl to service it).
+ *
+ * <rdar://problem/6848672>, <rdar://problem/5959568>.
+ */
+ if (spawn_no_exec) {
+ proc_transend(p, 0);
+ proc_transit_set = 0;
+ }
+
+#if MAC_SPAWN /* XXX */
+ if (uap->mac_p != USER_ADDR_NULL) {
+ error = mac_execve_enter(uap->mac_p, imgp);
+ if (error) {
+ goto bad;
+ }
+ }
+#endif
+
+ /*
+ * Activate the image
+ */
+ error = exec_activate_image(imgp);
+
+ if (error == 0 && !spawn_no_exec) {
+ p = proc_exec_switch_task(p, old_task, new_task, imgp->ip_new_thread);
+ /* proc ref returned */
+ should_release_proc_ref = TRUE;
+
+ /*
+ * Need to transfer pending watch port boosts to the new task while still making
+ * sure that the old task remains in the importance linkage. Create an importance
+ * linkage from old task to new task, then switch the task importance base
+ * of old task and new task. After the switch the port watch boost will be
+ * boosting the new task and new task will be donating importance to old task.
+ */
+ inherit = ipc_importance_exec_switch_task(old_task, new_task);
+ }
+
+ if (error == 0) {
+ /* process completed the exec */
+ exec_done = TRUE;
+ } else if (error == -1) {
+ /* Image not claimed by any activator? */
+ error = ENOEXEC;
+ }
+
+ /*
+ * If we have a spawn attr, and it contains signal related flags,
+ * the we need to process them in the "context" of the new child
+ * process, so we have to process it following image activation,
+ * prior to making the thread runnable in user space. This is
+ * necessitated by some signal information being per-thread rather
+ * than per-process, and we don't have the new allocation in hand
+ * until after the image is activated.
+ */
+ if (!error && imgp->ip_px_sa != NULL) {
+ thread_t child_thread = imgp->ip_new_thread;
+ uthread_t child_uthread = get_bsdthread_info(child_thread);
+
+ /*
+ * Mask a list of signals, instead of them being unmasked, if
+ * they were unmasked in the parent; note that some signals
+ * are not maskable.
+ */
+ if (px_sa.psa_flags & POSIX_SPAWN_SETSIGMASK) {
+ child_uthread->uu_sigmask = (px_sa.psa_sigmask & ~sigcantmask);
+ }
+ /*
+ * Default a list of signals instead of ignoring them, if
+ * they were ignored in the parent. Note that we pass
+ * spawn_no_exec to setsigvec() to indicate that we called
+ * fork1() and therefore do not need to call proc_signalstart()
+ * internally.
+ */
+ if (px_sa.psa_flags & POSIX_SPAWN_SETSIGDEF) {
+ vec.sa_handler = SIG_DFL;
+ vec.sa_tramp = 0;
+ vec.sa_mask = 0;
+ vec.sa_flags = 0;
+ for (sig = 1; sig < NSIG; sig++) {
+ if (px_sa.psa_sigdefault & (1 << (sig - 1))) {
+ error = setsigvec(p, child_thread, sig, &vec, spawn_no_exec);
+ }
+ }
+ }
+
+ /*
+ * Activate the CPU usage monitor, if requested. This is done via a task-wide, per-thread CPU
+ * usage limit, which will generate a resource exceeded exception if any one thread exceeds the
+ * limit.
+ *
+ * Userland gives us interval in seconds, and the kernel SPI expects nanoseconds.
+ */
+ if (px_sa.psa_cpumonitor_percent != 0) {
+ /*
+ * Always treat a CPU monitor activation coming from spawn as entitled. Requiring
+ * an entitlement to configure the monitor a certain way seems silly, since
+ * whomever is turning it on could just as easily choose not to do so.
+ */
+ error = proc_set_task_ruse_cpu(p->task,
+ TASK_POLICY_RESOURCE_ATTRIBUTE_NOTIFY_EXC,
+ px_sa.psa_cpumonitor_percent,
+ px_sa.psa_cpumonitor_interval * NSEC_PER_SEC,
+ 0, TRUE);
+ }
+ }
+
+bad:
+
+ if (error == 0) {
+ /* reset delay idle sleep status if set */
+#if !CONFIG_EMBEDDED
+ if ((p->p_flag & P_DELAYIDLESLEEP) == P_DELAYIDLESLEEP) {
+ OSBitAndAtomic(~((uint32_t)P_DELAYIDLESLEEP), &p->p_flag);
+ }
+#endif /* !CONFIG_EMBEDDED */
+ /* upon successful spawn, re/set the proc control state */
+ if (imgp->ip_px_sa != NULL) {
+ switch (px_sa.psa_pcontrol) {
+ case POSIX_SPAWN_PCONTROL_THROTTLE:
+ p->p_pcaction = P_PCTHROTTLE;
+ break;
+ case POSIX_SPAWN_PCONTROL_SUSPEND:
+ p->p_pcaction = P_PCSUSP;
+ break;
+ case POSIX_SPAWN_PCONTROL_KILL:
+ p->p_pcaction = P_PCKILL;
+ break;
+ case POSIX_SPAWN_PCONTROL_NONE:
+ default:
+ p->p_pcaction = 0;
+ break;
+ }
+ ;
+ }
+ exec_resettextvp(p, imgp);
+
+#if CONFIG_MEMORYSTATUS
+ /* Has jetsam attributes? */
+ if (imgp->ip_px_sa != NULL && (px_sa.psa_jetsam_flags & POSIX_SPAWN_JETSAM_SET)) {
+ /*
+ * With 2-level high-water-mark support, POSIX_SPAWN_JETSAM_HIWATER_BACKGROUND is no
+ * longer relevant, as background limits are described via the inactive limit slots.
+ *
+ * That said, however, if the POSIX_SPAWN_JETSAM_HIWATER_BACKGROUND is passed in,
+ * we attempt to mimic previous behavior by forcing the BG limit data into the
+ * inactive/non-fatal mode and force the active slots to hold system_wide/fatal mode.
+ */
+ if (px_sa.psa_jetsam_flags & POSIX_SPAWN_JETSAM_HIWATER_BACKGROUND) {
+ memorystatus_update(p, px_sa.psa_priority, 0,
+ (px_sa.psa_jetsam_flags & POSIX_SPAWN_JETSAM_USE_EFFECTIVE_PRIORITY),
+ TRUE,
+ -1, TRUE,
+ px_sa.psa_memlimit_inactive, FALSE);
+ } else {
+ memorystatus_update(p, px_sa.psa_priority, 0,
+ (px_sa.psa_jetsam_flags & POSIX_SPAWN_JETSAM_USE_EFFECTIVE_PRIORITY),
+ TRUE,
+ px_sa.psa_memlimit_active,
+ (px_sa.psa_jetsam_flags & POSIX_SPAWN_JETSAM_MEMLIMIT_ACTIVE_FATAL),
+ px_sa.psa_memlimit_inactive,
+ (px_sa.psa_jetsam_flags & POSIX_SPAWN_JETSAM_MEMLIMIT_INACTIVE_FATAL));
+ }
+ }
+#endif /* CONFIG_MEMORYSTATUS */
+ if (imgp->ip_px_sa != NULL && px_sa.psa_thread_limit > 0) {
+ task_set_thread_limit(new_task, (uint16_t)px_sa.psa_thread_limit);
+ }
+ }
+
+ /*
+ * If we successfully called fork1(), we always need to do this;
+ * we identify this case by noting the IMGPF_SPAWN flag. This is
+ * because we come back from that call with signals blocked in the
+ * child, and we have to unblock them, but we want to wait until
+ * after we've performed any spawn actions. This has to happen
+ * before check_for_signature(), which uses psignal.
+ */
+ if (spawn_no_exec) {
+ if (proc_transit_set) {
+ proc_transend(p, 0);
+ }
+
+ /*
+ * Drop the signal lock on the child which was taken on our
+ * behalf by forkproc()/cloneproc() to prevent signals being
+ * received by the child in a partially constructed state.
+ */
+ proc_signalend(p, 0);
+
+ /* flag the 'fork' has occurred */
+ proc_knote(p->p_pptr, NOTE_FORK | p->p_pid);
+ }
+
+ /* flag exec has occurred, notify only if it has not failed due to FP Key error */
+ if (!error && ((p->p_lflag & P_LTERM_DECRYPTFAIL) == 0)) {
+ proc_knote(p, NOTE_EXEC);
+ }
+
+
+ if (error == 0) {
+ /*
+ * We need to initialize the bank context behind the protection of
+ * the proc_trans lock to prevent a race with exit. We can't do this during
+ * exec_activate_image because task_bank_init checks entitlements that
+ * aren't loaded until subsequent calls (including exec_resettextvp).
+ */
+ error = proc_transstart(p, 0, 0);
+
+ if (error == 0) {
+ task_bank_init(new_task);
+ proc_transend(p, 0);
+ }
+
+#if __arm64__
+ proc_legacy_footprint(p, new_task, __FUNCTION__);
+#endif /* __arm64__ */
+ }
+
+ /* Inherit task role from old task to new task for exec */
+ if (error == 0 && !spawn_no_exec) {
+ proc_inherit_task_role(new_task, old_task);
+ }
+
+ /*
+ * Apply the spawnattr policy, apptype (which primes the task for importance donation),
+ * and bind any portwatch ports to the new task.
+ * This must be done after the exec so that the child's thread is ready,
+ * and after the in transit state has been released, because priority is
+ * dropped here so we need to be prepared for a potentially long preemption interval
+ *
+ * TODO: Consider splitting this up into separate phases
+ */
+ if (error == 0 && imgp->ip_px_sa != NULL) {
+ struct _posix_spawnattr *psa = (struct _posix_spawnattr *) imgp->ip_px_sa;
+
+ exec_handle_spawnattr_policy(p, psa->psa_apptype, psa->psa_qos_clamp, psa->psa_darwin_role,
+ portwatch_ports, portwatch_count);
+ }
+
+ /*
+ * Apply the requested maximum address.
+ */
+ if (error == 0 && imgp->ip_px_sa != NULL) {
+ struct _posix_spawnattr *psa = (struct _posix_spawnattr *) imgp->ip_px_sa;
+
+ if (psa->psa_max_addr) {
+ vm_map_set_max_addr(get_task_map(new_task), psa->psa_max_addr);
+ }
+ }
+
+ if (error == 0) {
+ /* Apply the main thread qos */
+ thread_t main_thread = imgp->ip_new_thread;
+ task_set_main_thread_qos(new_task, main_thread);
+
+#if CONFIG_MACF
+ /*
+ * Processes with the MAP_JIT entitlement are permitted to have
+ * a jumbo-size map.
+ */
+ if (mac_proc_check_map_anon(p, 0, 0, 0, MAP_JIT, NULL) == 0) {
+ vm_map_set_jumbo(get_task_map(new_task));
+ }
+#endif /* CONFIG_MACF */
+ }
+
+ /*
+ * Release any ports we kept around for binding to the new task
+ * We need to release the rights even if the posix_spawn has failed.
+ */
+ if (portwatch_ports != NULL) {
+ for (int i = 0; i < portwatch_count; i++) {
+ ipc_port_t port = NULL;
+ if ((port = portwatch_ports[i]) != NULL) {
+ ipc_port_release_send(port);
+ }
+ }
+ FREE(portwatch_ports, M_TEMP);
+ portwatch_ports = NULL;
+ portwatch_count = 0;
+ }
+
+ /*
+ * We have to delay operations which might throw a signal until after
+ * the signals have been unblocked; however, we want that to happen
+ * after exec_resettextvp() so that the textvp is correct when they
+ * fire.
+ */
+ if (error == 0) {
+ error = check_for_signature(p, imgp);
+
+ /*
+ * Pay for our earlier safety; deliver the delayed signals from
+ * the incomplete spawn process now that it's complete.
+ */
+ if (imgp != NULL && spawn_no_exec && (p->p_lflag & P_LTRACED)) {
+ psignal_vfork(p, p->task, imgp->ip_new_thread, SIGTRAP);
+ }
+
+ if (error == 0 && !spawn_no_exec) {
+ KDBG(BSDDBG_CODE(DBG_BSD_PROC, BSD_PROC_EXEC),
+ p->p_pid);
+ }
+ }
+
+
+ if (imgp != NULL) {
+ if (imgp->ip_vp) {
+ vnode_put(imgp->ip_vp);
+ }
+ if (imgp->ip_scriptvp) {
+ vnode_put(imgp->ip_scriptvp);
+ }
+ if (imgp->ip_strings) {
+ execargs_free(imgp);
+ }
+ if (imgp->ip_px_sfa != NULL) {
+ FREE(imgp->ip_px_sfa, M_TEMP);
+ }
+ if (imgp->ip_px_spa != NULL) {
+ FREE(imgp->ip_px_spa, M_TEMP);
+ }
+#if CONFIG_PERSONAS
+ if (imgp->ip_px_persona != NULL) {
+ FREE(imgp->ip_px_persona, M_TEMP);
+ }
+#endif
+#if CONFIG_MACF
+ if (imgp->ip_px_smpx != NULL) {
+ spawn_free_macpolicyinfo(imgp->ip_px_smpx);
+ }
+ if (imgp->ip_execlabelp) {
+ mac_cred_label_free(imgp->ip_execlabelp);
+ }
+ if (imgp->ip_scriptlabelp) {
+ mac_vnode_label_free(imgp->ip_scriptlabelp);
projects / apple / xnu.git / blobdiff