kern_return_t
thread_policy_set_internal(
thread_t thread,
thread_policy_flavor_t flavor,
thread_policy_t policy_info,
mach_msg_type_number_t count)
{
kern_return_t result = KERN_SUCCESS;
spl_t s;
thread_mtx_lock(thread);
if (!thread->active) {
thread_mtx_unlock(thread);
return (KERN_TERMINATED);
}
switch (flavor) {
case THREAD_EXTENDED_POLICY:
{
boolean_t timeshare = TRUE;
if (count >= THREAD_EXTENDED_POLICY_COUNT) {
thread_extended_policy_t info;
info = (thread_extended_policy_t)policy_info;
timeshare = info->timeshare;
}
sched_mode_t mode = (timeshare == TRUE) ? TH_MODE_TIMESHARE : TH_MODE_FIXED;
s = splsched();
thread_lock(thread);
thread_set_user_sched_mode_and_recompute_pri(thread, mode);
thread_unlock(thread);
splx(s);
sfi_reevaluate(thread);
break;
}
case THREAD_TIME_CONSTRAINT_POLICY:
{
thread_time_constraint_policy_t info;
if (count < THREAD_TIME_CONSTRAINT_POLICY_COUNT) {
result = KERN_INVALID_ARGUMENT;
break;
}
info = (thread_time_constraint_policy_t)policy_info;
if ( info->constraint < info->computation ||
info->computation > max_rt_quantum ||
info->computation < min_rt_quantum ) {
result = KERN_INVALID_ARGUMENT;
break;
}
s = splsched();
thread_lock(thread);
thread->realtime.period = info->period;
thread->realtime.computation = info->computation;
thread->realtime.constraint = info->constraint;
thread->realtime.preemptible = info->preemptible;
thread_set_user_sched_mode_and_recompute_pri(thread, TH_MODE_REALTIME);
thread_unlock(thread);
splx(s);
sfi_reevaluate(thread);
break;
}
case THREAD_PRECEDENCE_POLICY:
{
thread_precedence_policy_t info;
if (count < THREAD_PRECEDENCE_POLICY_COUNT) {
result = KERN_INVALID_ARGUMENT;
break;
}
info = (thread_precedence_policy_t)policy_info;
s = splsched();
thread_lock(thread);
thread->importance = info->importance;
thread_recompute_priority(thread);
thread_unlock(thread);
splx(s);
break;
}
case THREAD_AFFINITY_POLICY:
{
thread_affinity_policy_t info;
if (!thread_affinity_is_supported()) {
result = KERN_NOT_SUPPORTED;
break;
}
if (count < THREAD_AFFINITY_POLICY_COUNT) {
result = KERN_INVALID_ARGUMENT;
break;
}
info = (thread_affinity_policy_t) policy_info;
/*
* Unlock the thread mutex here and
* return directly after calling thread_affinity_set().
* This is necessary for correct lock ordering because
* thread_affinity_set() takes the task lock.
*/
thread_mtx_unlock(thread);
return thread_affinity_set(thread, info->affinity_tag);
}
case THREAD_THROUGHPUT_QOS_POLICY:
{
thread_throughput_qos_policy_t info = (thread_throughput_qos_policy_t) policy_info;
int tqos;
if (count < THREAD_LATENCY_QOS_POLICY_COUNT) {
result = KERN_INVALID_ARGUMENT;
break;
}
if ((result = qos_throughput_policy_validate(info->thread_throughput_qos_tier)) !=
KERN_SUCCESS) {
break;
}
tqos = qos_extract(info->thread_throughput_qos_tier);
thread->effective_policy.t_through_qos = tqos;
}
break;
case THREAD_LATENCY_QOS_POLICY:
{
thread_latency_qos_policy_t info = (thread_latency_qos_policy_t) policy_info;
int lqos;
if (count < THREAD_THROUGHPUT_QOS_POLICY_COUNT) {
result = KERN_INVALID_ARGUMENT;
break;
}
if ((result = qos_latency_policy_validate(info->thread_latency_qos_tier)) !=
KERN_SUCCESS) {
break;
}
lqos = qos_extract(info->thread_latency_qos_tier);
/* The expected use cases (opt-in) of per-thread latency QoS would seem to
* preclude any requirement at present to re-evaluate timers on a thread level
* latency QoS change.
*/
thread->effective_policy.t_latency_qos = lqos;
}
break;
case THREAD_QOS_POLICY:
case THREAD_QOS_POLICY_OVERRIDE:
{
thread_qos_policy_t info = (thread_qos_policy_t)policy_info;
if (count < THREAD_QOS_POLICY_COUNT) {
result = KERN_INVALID_ARGUMENT;
break;
}
if (info->qos_tier < 0 || info->qos_tier >= THREAD_QOS_LAST) {
result = KERN_INVALID_ARGUMENT;
break;
}
if (info->tier_importance > 0 || info->tier_importance < THREAD_QOS_MIN_TIER_IMPORTANCE) {
result = KERN_INVALID_ARGUMENT;
break;
}
if (info->qos_tier == THREAD_QOS_UNSPECIFIED && info->tier_importance != 0) {
result = KERN_INVALID_ARGUMENT;
break;
}
/*
* Going into task policy requires the task mutex,
* because of the way synchronization against the IO policy
* subsystem works.
*
* We need to move thread policy to the thread mutex instead.
* <rdar://problem/15831652> separate thread policy from task policy
*/
if (flavor == THREAD_QOS_POLICY_OVERRIDE) {
int strongest_override = info->qos_tier;
if (info->qos_tier != THREAD_QOS_UNSPECIFIED &&
thread->requested_policy.thrp_qos_override != THREAD_QOS_UNSPECIFIED)
strongest_override = MAX(thread->requested_policy.thrp_qos_override, info->qos_tier);
thread_mtx_unlock(thread);
/* There is a race here. To be closed in <rdar://problem/15831652> separate thread policy from task policy */
proc_set_task_policy(thread->task, thread, TASK_POLICY_ATTRIBUTE, TASK_POLICY_QOS_OVERRIDE, strongest_override);
return (result);
}
thread_mtx_unlock(thread);
proc_set_task_policy2(thread->task, thread, TASK_POLICY_ATTRIBUTE, TASK_POLICY_QOS_AND_RELPRIO, info->qos_tier, -info->tier_importance);
thread_mtx_lock(thread);
if (!thread->active) {
thread_mtx_unlock(thread);
return (KERN_TERMINATED);
}
break;
}
default:
result = KERN_INVALID_ARGUMENT;
break;
}
thread_mtx_unlock(thread);
return (result);
}
static int
handle_apptype( int scope,
int action,
__unused int policy,
int policy_subtype,
__unused user_addr_t attrp,
proc_t target_proc,
__unused uint64_t target_threadid)
{
int error = 0;
if (scope != PROC_POLICY_SCOPE_PROCESS)
return (EINVAL);
/* Temporary compatibility with old importance donation interface until libproc is moved to new boost calls */
switch (policy_subtype) {
case PROC_POLICY_IOS_DONATEIMP:
if (action != PROC_POLICY_ACTION_ENABLE)
return (EINVAL);
if (target_proc != current_proc())
return (EINVAL);
/* PROCESS ENABLE APPTYPE DONATEIMP */
task_importance_mark_donor(target_proc->task, TRUE);
return(0);
case PROC_POLICY_IOS_HOLDIMP:
if (action != PROC_POLICY_ACTION_ENABLE)
return (EINVAL);
if (target_proc != current_proc())
return (EINVAL);
/* PROCESS ENABLE APPTYPE HOLDIMP */
error = task_importance_hold_legacy_external_assertion(current_task(), 1);
return(error);
case PROC_POLICY_IOS_DROPIMP:
if (action != PROC_POLICY_ACTION_ENABLE)
return (EINVAL);
if (target_proc != current_proc())
return (EINVAL);
/* PROCESS ENABLE APPTYPE DROPIMP */
error = task_importance_drop_legacy_external_assertion(current_task(), 1);
return(error);
default:
/* continue to TAL handling */
break;
}
if (policy_subtype != PROC_POLICY_OSX_APPTYPE_TAL)
return (EINVAL);
/* need to be super user to do this */
if (kauth_cred_issuser(kauth_cred_get()) == 0)
return (EPERM);
if (proc_task_is_tal(target_proc->task) == FALSE)
return (EINVAL);
switch (action) {
case PROC_POLICY_ACTION_ENABLE:
/* PROCESS ENABLE APPTYPE TAL */
proc_set_task_policy(target_proc->task,
TASK_POLICY_ATTRIBUTE, TASK_POLICY_TAL,
TASK_POLICY_ENABLE);
break;
case PROC_POLICY_ACTION_DISABLE:
/* PROCESS DISABLE APPTYPE TAL */
proc_set_task_policy(target_proc->task,
TASK_POLICY_ATTRIBUTE, TASK_POLICY_TAL,
TASK_POLICY_DISABLE);
break;
default:
return (EINVAL);
}
return(0);
}
/*
* Routine: macx_swapoff
* Function:
* Syscall interface to remove a file from backing store
*/
int
macx_swapoff(
struct macx_swapoff_args *args)
{
__unused int flags = args->flags;
kern_return_t kr;
mach_port_t backing_store;
struct vnode *vp = 0;
struct nameidata nd, *ndp;
struct proc *p = current_proc();
int i;
int error;
boolean_t funnel_state;
vfs_context_t ctx = vfs_context_current();
int orig_iopol_disk;
AUDIT_MACH_SYSCALL_ENTER(AUE_SWAPOFF);
funnel_state = thread_funnel_set(kernel_flock, TRUE);
backing_store = NULL;
ndp = &nd;
if ((error = suser(kauth_cred_get(), 0)))
goto swapoff_bailout;
/*
* Get the vnode for the paging area.
*/
NDINIT(ndp, LOOKUP, OP_LOOKUP, FOLLOW | LOCKLEAF | AUDITVNPATH1,
((IS_64BIT_PROCESS(p)) ? UIO_USERSPACE64 : UIO_USERSPACE32),
(user_addr_t) args->filename, ctx);
if ((error = namei(ndp)))
goto swapoff_bailout;
nameidone(ndp);
vp = ndp->ni_vp;
if (vp->v_type != VREG) {
error = EINVAL;
goto swapoff_bailout;
}
#if CONFIG_MACF
vnode_lock(vp);
error = mac_system_check_swapoff(vfs_context_ucred(ctx), vp);
vnode_unlock(vp);
if (error)
goto swapoff_bailout;
#endif
for(i = 0; i < MAX_BACKING_STORE; i++) {
if(bs_port_table[i].vp == vp) {
break;
}
}
if (i == MAX_BACKING_STORE) {
error = EINVAL;
goto swapoff_bailout;
}
backing_store = (mach_port_t)bs_port_table[i].bs;
orig_iopol_disk = proc_get_task_policy(current_task(), current_thread(),
TASK_POLICY_INTERNAL, TASK_POLICY_IOPOL);
proc_set_task_policy(current_task(), current_thread(), TASK_POLICY_INTERNAL,
TASK_POLICY_IOPOL, IOPOL_THROTTLE);
kr = default_pager_backing_store_delete(backing_store);
proc_set_task_policy(current_task(), current_thread(), TASK_POLICY_INTERNAL,
TASK_POLICY_IOPOL, orig_iopol_disk);
switch (kr) {
case KERN_SUCCESS:
error = 0;
bs_port_table[i].vp = 0;
/* This vnode is no longer used for swapfile */
vnode_lock_spin(vp);
CLR(vp->v_flag, VSWAP);
vnode_unlock(vp);
/* get rid of macx_swapon() "long term" reference */
vnode_rele(vp);
break;
case KERN_FAILURE:
error = EAGAIN;
break;
default:
error = EAGAIN;
break;
}
swapoff_bailout:
/* get rid of macx_swapoff() namei() reference */
if (vp)
vnode_put(vp);
(void) thread_funnel_set(kernel_flock, FALSE);
AUDIT_MACH_SYSCALL_EXIT(error);
if (error)
printf("macx_swapoff FAILED - %d\n", error);
else
printf("macx_swapoff SUCCESS\n");
return(error);
}
