[apple/xnu.git] / tests / task_policy.c

#include <darwintest.h>
#include <signal.h>
#include <spawn.h>
#include <unistd.h>

#include <mach/mach.h>
#include <mach/mach_types.h>
#include <mach/task.h>
#include <mach/task_policy.h>

extern char **environ;

int task_inspect_for_pid(mach_port_name_t target_tport, int pid, mach_port_name_t *t);
int task_for_pid(mach_port_name_t target_tport, int pid, mach_port_name_t *t);
int task_name_for_pid(mach_port_name_t target_tport, int pid, mach_port_name_t *t);

T_GLOBAL_META(T_META_RUN_CONCURRENTLY(true));

#if defined(UNENTITLED)

T_DECL(task_policy_set_task_name, "task_policy_set with task name (not entitled)")
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};
	task_name_t task_name = TASK_NAME_NULL;

	T_SETUPBEGIN;
	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(),
	    &task_name), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_ERROR(task_policy_set(task_name,
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    KERN_INVALID_ARGUMENT, NULL);
}

T_DECL(task_policy_set_task, "task_policy_set with task (not entitled)")
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};

	T_ASSERT_MACH_SUCCESS(task_policy_set(mach_task_self(),
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    NULL);
}

T_DECL(task_policy_set_inspect, "task_policy_set with task inspect (not entitled)")
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};
	task_inspect_t task_inspect = TASK_INSPECT_NULL;

	T_SETUPBEGIN;
	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(),
	    &task_inspect), NULL);
	T_SETUPEND;


	T_ASSERT_MACH_ERROR(task_policy_set(task_inspect,
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    KERN_INVALID_ARGUMENT, NULL);
}

T_DECL(task_policy_set_foreign_task, "task_policy_set for foreign task (not entitled)", T_META_ASROOT(true))
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};
	task_t task = TASK_NULL;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid,
	    &task), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_set(task,
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

T_DECL(task_policy_set_foreign_task_name, "task_policy_set for foreign task name (not entitled)", T_META_ASROOT(true))
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};
	task_name_t task_name = TASK_NAME_NULL;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid,
	    &task_name), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_ERROR(task_policy_set(task_name,
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    KERN_INVALID_ARGUMENT, NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

T_DECL(task_policy_set_foreign_task_inspect, "task_policy_set for foreign task inspect (not entitled)", T_META_ASROOT(true))
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};
	task_inspect_t task_inspect = TASK_INSPECT_NULL;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid,
	    &task_inspect), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_ERROR(task_policy_set(task_inspect,
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    KERN_INVALID_ARGUMENT, NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

T_DECL(task_policy_get_name, "task_policy_get with task name (not entitled)")
{
	task_name_t task_name = TASK_NAME_NULL;
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;

	T_SETUPBEGIN;
	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(),
	    &task_name), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_ERROR(task_policy_get(task_name,
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    KERN_INVALID_ARGUMENT, NULL);
}

T_DECL(task_policy_get_task, "task_policy_get with task (not entitled)")
{
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;

	T_ASSERT_MACH_SUCCESS(task_policy_get(mach_task_self(),
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    NULL);
}

T_DECL(task_policy_get_inspect, "task_policy_get with task inspect (not entitled)")
{
	task_inspect_t task_inspect = TASK_INSPECT_NULL;
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;

	T_SETUPBEGIN;
	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(),
	    &task_inspect), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect,
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    NULL);
}

T_DECL(task_policy_get_foreign_task_inspect, "task_policy_get for foreign task inspect (not entitled)", T_META_ASROOT(true))
{
	task_inspect_t task_inspect = TASK_INSPECT_NULL;
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid,
	    &task_inspect), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect,
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

T_DECL(task_policy_get_foreign_task, "task_policy_get for foreign task (not entitled)", T_META_ASROOT(true))
{
	task_t task = TASK_NULL;
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid,
	    &task), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_get(task,
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

T_DECL(task_policy_get_foreign_task_name, "task_policy_get for foreign task name (not entitled)")
{
	task_name_t task_name = TASK_NAME_NULL;
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid,
	    &task_name), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_ERROR(task_policy_get(task_name,
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    KERN_INVALID_ARGUMENT, NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

#else /* ENTITLED */

T_DECL(task_policy_set_task_name_entitled, "task_policy_set with task name (entitled)", T_META_ASROOT(true), T_META_ASROOT(true))
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};
	task_name_t task_name = TASK_NAME_NULL;

	T_SETUPBEGIN;
	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(),
	    &task_name), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_set(task_name,
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    NULL);
}

T_DECL(task_policy_set_task_entitled, "task_policy_set with task (entitled)")
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};

	T_ASSERT_MACH_SUCCESS(task_policy_set(mach_task_self(),
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    NULL);
}

T_DECL(task_policy_set_inspect_entitled, "task_policy_set with task inspect (entitled)")
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};
	task_inspect_t task_inspect = TASK_INSPECT_NULL;

	T_SETUPBEGIN;
	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(),
	    &task_inspect), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_set(task_inspect,
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    NULL);
}

T_DECL(task_policy_set_foreign_task_entitled, "task_policy_set for foreign task (entitled)", T_META_ASROOT(true))
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};
	task_t task = TASK_NULL;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid,
	    &task), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_set(task,
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

T_DECL(task_policy_set_foreign_task_name_entitled, "task_policy_set for foreign task name (entitled)", T_META_ASROOT(true), T_META_ASROOT(true))
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};
	task_name_t task_name = TASK_NAME_NULL;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid,
	    &task_name), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_set(task_name,
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

T_DECL(task_policy_set_foreign_task_inspect_entitled, "task_policy_set for foreign task inspect (entitled)", T_META_ASROOT(true))
{
	struct task_qos_policy qosinfo = {
		.task_latency_qos_tier = LATENCY_QOS_TIER_0,
		.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	};
	task_inspect_t task_inspect = TASK_INSPECT_NULL;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid,
	    &task_inspect), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_set(task_inspect,
	    TASK_BASE_QOS_POLICY,
	    (task_policy_t)&qosinfo,
	    TASK_QOS_POLICY_COUNT),
	    NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

T_DECL(task_policy_get_name_entitled, "task_policy_get with task name (entitled)", T_META_ASROOT(true))
{
	task_name_t task_name = TASK_NAME_NULL;
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;

	T_SETUPBEGIN;
	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(),
	    &task_name), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_get(task_name,
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    NULL);
}

T_DECL(task_policy_get_task_entitled, "task_policy_get with task (entitled)")
{
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;

	T_ASSERT_MACH_SUCCESS(task_policy_get(mach_task_self(),
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    NULL);
}

T_DECL(task_policy_get_inspect_entitled, "task_policy_get with task inspect (entitled)")
{
	task_inspect_t task_inspect = TASK_INSPECT_NULL;
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;

	T_SETUPBEGIN;
	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(),
	    &task_inspect), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect,
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    NULL);
}

T_DECL(task_policy_get_foreign_task_inspect_entitled, "task_policy_get for foreign task inspect (entitled)", T_META_ASROOT(true))
{
	task_inspect_t task_inspect = TASK_INSPECT_NULL;
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid,
	    &task_inspect), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect,
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

T_DECL(task_policy_get_foreign_task_entitled, "task_policy_get for foreign task (entitled)", T_META_ASROOT(true))
{
	task_t task = TASK_NULL;
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid,
	    &task), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_get(task,
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

T_DECL(task_policy_get_foreign_task_name_entitled, "task_policy_get for foreign task name (entitled)", T_META_ASROOT(true))
{
	task_name_t task_name = TASK_NAME_NULL;
	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
	boolean_t get_default = FALSE;
	kern_return_t ret = KERN_FAILURE;
	char *args[] = { "sleep", "10", NULL };
	pid_t pid = 0;

	T_SETUPBEGIN;

	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");

	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid,
	    &task_name), NULL);
	T_SETUPEND;

	T_ASSERT_MACH_SUCCESS(task_policy_get(task_name,
	    TASK_CATEGORY_POLICY,
	    (task_policy_t)role,
	    &count,
	    &get_default),
	    NULL);

	ret = kill(pid, SIGTERM);
	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
}

#endif /* UNENTITLED */
Commit	Line	Data
f427ee49 A	1	#include <darwintest.h>
	2	#include <signal.h>
	3	#include <spawn.h>
	4	#include <unistd.h>
	5
	6	#include <mach/mach.h>
	7	#include <mach/mach_types.h>
	8	#include <mach/task.h>
	9	#include <mach/task_policy.h>
	10
	11	extern char **environ;
	12
	13	int task_inspect_for_pid(mach_port_name_t target_tport, int pid, mach_port_name_t *t);
	14	int task_for_pid(mach_port_name_t target_tport, int pid, mach_port_name_t *t);
	15	int task_name_for_pid(mach_port_name_t target_tport, int pid, mach_port_name_t *t);
	16
	17	T_GLOBAL_META(T_META_RUN_CONCURRENTLY(true));
	18
	19	#if defined(UNENTITLED)
	20
	21	T_DECL(task_policy_set_task_name, "task_policy_set with task name (not entitled)")
	22	{
	23	struct task_qos_policy qosinfo = {
	24	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
	25	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	26	};
	27	task_name_t task_name = TASK_NAME_NULL;
	28
	29	T_SETUPBEGIN;
	30	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(),
	31	&task_name), NULL);
	32	T_SETUPEND;
	33
	34	T_ASSERT_MACH_ERROR(task_policy_set(task_name,
	35	TASK_BASE_QOS_POLICY,
	36	(task_policy_t)&qosinfo,
	37	TASK_QOS_POLICY_COUNT),
	38	KERN_INVALID_ARGUMENT, NULL);
	39	}
	40
	41	T_DECL(task_policy_set_task, "task_policy_set with task (not entitled)")
	42	{
	43	struct task_qos_policy qosinfo = {
	44	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
	45	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	46	};
	47
	48	T_ASSERT_MACH_SUCCESS(task_policy_set(mach_task_self(),
	49	TASK_BASE_QOS_POLICY,
	50	(task_policy_t)&qosinfo,
	51	TASK_QOS_POLICY_COUNT),
	52	NULL);
	53	}
	54
	55	T_DECL(task_policy_set_inspect, "task_policy_set with task inspect (not entitled)")
	56	{
	57	struct task_qos_policy qosinfo = {
	58	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
	59	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
	60	};
	61	task_inspect_t task_inspect = TASK_INSPECT_NULL;
	62
	63	T_SETUPBEGIN;
	64	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(),
65	&task_inspect), NULL);
66	T_SETUPEND;
67
68
69	T_ASSERT_MACH_ERROR(task_policy_set(task_inspect,
70	TASK_BASE_QOS_POLICY,
71	(task_policy_t)&qosinfo,
72	TASK_QOS_POLICY_COUNT),
73	KERN_INVALID_ARGUMENT, NULL);
74	}
75
76	T_DECL(task_policy_set_foreign_task, "task_policy_set for foreign task (not entitled)", T_META_ASROOT(true))
77	{
78	struct task_qos_policy qosinfo = {
79	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
80	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
81	};
82	task_t task = TASK_NULL;
83	kern_return_t ret = KERN_FAILURE;
84	char *args[] = { "sleep", "10", NULL };
85	pid_t pid = 0;
86
87	T_SETUPBEGIN;
88
89	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
90	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
91
92	T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid,
93	&task), NULL);
94	T_SETUPEND;
95
96	T_ASSERT_MACH_SUCCESS(task_policy_set(task,
97	TASK_BASE_QOS_POLICY,
98	(task_policy_t)&qosinfo,
99	TASK_QOS_POLICY_COUNT),
100	NULL);
101
102	ret = kill(pid, SIGTERM);
103	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
104	}
105
106	T_DECL(task_policy_set_foreign_task_name, "task_policy_set for foreign task name (not entitled)", T_META_ASROOT(true))
107	{
108	struct task_qos_policy qosinfo = {
109	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
110	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
111	};
112	task_name_t task_name = TASK_NAME_NULL;
113	kern_return_t ret = KERN_FAILURE;
114	char *args[] = { "sleep", "10", NULL };
115	pid_t pid = 0;
116
117	T_SETUPBEGIN;
118
119	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
120	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
121
122	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid,
123	&task_name), NULL);
124	T_SETUPEND;
125
126	T_ASSERT_MACH_ERROR(task_policy_set(task_name,
127	TASK_BASE_QOS_POLICY,
128	(task_policy_t)&qosinfo,
129	TASK_QOS_POLICY_COUNT),
130	KERN_INVALID_ARGUMENT, NULL);
131
132	ret = kill(pid, SIGTERM);
133	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
134	}
135
136	T_DECL(task_policy_set_foreign_task_inspect, "task_policy_set for foreign task inspect (not entitled)", T_META_ASROOT(true))
137	{
138	struct task_qos_policy qosinfo = {
139	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
140	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
141	};
142	task_inspect_t task_inspect = TASK_INSPECT_NULL;
143	kern_return_t ret = KERN_FAILURE;
144	char *args[] = { "sleep", "10", NULL };
145	pid_t pid = 0;
146
147	T_SETUPBEGIN;
148
149	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
150	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
151
152	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid,
153	&task_inspect), NULL);
154	T_SETUPEND;
155
156	T_ASSERT_MACH_ERROR(task_policy_set(task_inspect,
157	TASK_BASE_QOS_POLICY,
158	(task_policy_t)&qosinfo,
159	TASK_QOS_POLICY_COUNT),
160	KERN_INVALID_ARGUMENT, NULL);
161
162	ret = kill(pid, SIGTERM);
163	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
164	}
165
166	T_DECL(task_policy_get_name, "task_policy_get with task name (not entitled)")
167	{
168	task_name_t task_name = TASK_NAME_NULL;
169	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
170	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
171	boolean_t get_default = FALSE;
172
173	T_SETUPBEGIN;
174	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(),
175	&task_name), NULL);
176	T_SETUPEND;
177
178	T_ASSERT_MACH_ERROR(task_policy_get(task_name,
179	TASK_CATEGORY_POLICY,
180	(task_policy_t)role,
181	&count,
182	&get_default),
183	KERN_INVALID_ARGUMENT, NULL);
184	}
185
186	T_DECL(task_policy_get_task, "task_policy_get with task (not entitled)")
187	{
188	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
189	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
190	boolean_t get_default = FALSE;
191
192	T_ASSERT_MACH_SUCCESS(task_policy_get(mach_task_self(),
193	TASK_CATEGORY_POLICY,
194	(task_policy_t)role,
195	&count,
196	&get_default),
197	NULL);
198	}
199
200	T_DECL(task_policy_get_inspect, "task_policy_get with task inspect (not entitled)")
201	{
202	task_inspect_t task_inspect = TASK_INSPECT_NULL;
203	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
204	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
205	boolean_t get_default = FALSE;
206
207	T_SETUPBEGIN;
208	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(),
209	&task_inspect), NULL);
210	T_SETUPEND;
211
212	T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect,
213	TASK_CATEGORY_POLICY,
214	(task_policy_t)role,
215	&count,
216	&get_default),
217	NULL);
218	}
219
220	T_DECL(task_policy_get_foreign_task_inspect, "task_policy_get for foreign task inspect (not entitled)", T_META_ASROOT(true))
221	{
222	task_inspect_t task_inspect = TASK_INSPECT_NULL;
223	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
224	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
225	boolean_t get_default = FALSE;
226	kern_return_t ret = KERN_FAILURE;
227	char *args[] = { "sleep", "10", NULL };
228	pid_t pid = 0;
229
230	T_SETUPBEGIN;
231
232	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
233	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
234
235	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid,
236	&task_inspect), NULL);
237	T_SETUPEND;
238
239	T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect,
240	TASK_CATEGORY_POLICY,
241	(task_policy_t)role,
242	&count,
243	&get_default),
244	NULL);
245
246	ret = kill(pid, SIGTERM);
247	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
248	}
249
250	T_DECL(task_policy_get_foreign_task, "task_policy_get for foreign task (not entitled)", T_META_ASROOT(true))
251	{
252	task_t task = TASK_NULL;
253	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
254	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
255	boolean_t get_default = FALSE;
256	kern_return_t ret = KERN_FAILURE;
257	char *args[] = { "sleep", "10", NULL };
258	pid_t pid = 0;
259
260	T_SETUPBEGIN;
261
262	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
263	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
264
265	T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid,
266	&task), NULL);
267	T_SETUPEND;
268
269	T_ASSERT_MACH_SUCCESS(task_policy_get(task,
270	TASK_CATEGORY_POLICY,
271	(task_policy_t)role,
272	&count,
273	&get_default),
274	NULL);
275
276	ret = kill(pid, SIGTERM);
277	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
278	}
279
280	T_DECL(task_policy_get_foreign_task_name, "task_policy_get for foreign task name (not entitled)")
281	{
282	task_name_t task_name = TASK_NAME_NULL;
283	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
284	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
285	boolean_t get_default = FALSE;
286	kern_return_t ret = KERN_FAILURE;
287	char *args[] = { "sleep", "10", NULL };
288	pid_t pid = 0;
289
290	T_SETUPBEGIN;
291
292	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
293	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
294
295	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid,
296	&task_name), NULL);
297	T_SETUPEND;
298
299	T_ASSERT_MACH_ERROR(task_policy_get(task_name,
300	TASK_CATEGORY_POLICY,
301	(task_policy_t)role,
302	&count,
303	&get_default),
304	KERN_INVALID_ARGUMENT, NULL);
305
306	ret = kill(pid, SIGTERM);
307	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
308	}
309
310	#else /* ENTITLED */
311
312	T_DECL(task_policy_set_task_name_entitled, "task_policy_set with task name (entitled)", T_META_ASROOT(true), T_META_ASROOT(true))
313	{
314	struct task_qos_policy qosinfo = {
315	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
316	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
317	};
318	task_name_t task_name = TASK_NAME_NULL;
319
320	T_SETUPBEGIN;
321	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(),
322	&task_name), NULL);
323	T_SETUPEND;
324
325	T_ASSERT_MACH_SUCCESS(task_policy_set(task_name,
326	TASK_BASE_QOS_POLICY,
327	(task_policy_t)&qosinfo,
328	TASK_QOS_POLICY_COUNT),
329	NULL);
330	}
331
332	T_DECL(task_policy_set_task_entitled, "task_policy_set with task (entitled)")
333	{
334	struct task_qos_policy qosinfo = {
335	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
336	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
337	};
338
339	T_ASSERT_MACH_SUCCESS(task_policy_set(mach_task_self(),
340	TASK_BASE_QOS_POLICY,
341	(task_policy_t)&qosinfo,
342	TASK_QOS_POLICY_COUNT),
343	NULL);
344	}
345
346	T_DECL(task_policy_set_inspect_entitled, "task_policy_set with task inspect (entitled)")
347	{
348	struct task_qos_policy qosinfo = {
349	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
350	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
351	};
352	task_inspect_t task_inspect = TASK_INSPECT_NULL;
353
354	T_SETUPBEGIN;
355	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(),
356	&task_inspect), NULL);
357	T_SETUPEND;
358
359	T_ASSERT_MACH_SUCCESS(task_policy_set(task_inspect,
360	TASK_BASE_QOS_POLICY,
361	(task_policy_t)&qosinfo,
362	TASK_QOS_POLICY_COUNT),
363	NULL);
364	}
365
366	T_DECL(task_policy_set_foreign_task_entitled, "task_policy_set for foreign task (entitled)", T_META_ASROOT(true))
367	{
368	struct task_qos_policy qosinfo = {
369	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
370	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
371	};
372	task_t task = TASK_NULL;
373	kern_return_t ret = KERN_FAILURE;
374	char *args[] = { "sleep", "10", NULL };
375	pid_t pid = 0;
376
377	T_SETUPBEGIN;
378
379	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
380	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
381
382	T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid,
383	&task), NULL);
384	T_SETUPEND;
385
386	T_ASSERT_MACH_SUCCESS(task_policy_set(task,
387	TASK_BASE_QOS_POLICY,
388	(task_policy_t)&qosinfo,
389	TASK_QOS_POLICY_COUNT),
390	NULL);
391
392	ret = kill(pid, SIGTERM);
393	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
394	}
395
396	T_DECL(task_policy_set_foreign_task_name_entitled, "task_policy_set for foreign task name (entitled)", T_META_ASROOT(true), T_META_ASROOT(true))
397	{
398	struct task_qos_policy qosinfo = {
399	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
400	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
401	};
402	task_name_t task_name = TASK_NAME_NULL;
403	kern_return_t ret = KERN_FAILURE;
404	char *args[] = { "sleep", "10", NULL };
405	pid_t pid = 0;
406
407	T_SETUPBEGIN;
408
409	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
410	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
411
412	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid,
413	&task_name), NULL);
414	T_SETUPEND;
415
416	T_ASSERT_MACH_SUCCESS(task_policy_set(task_name,
417	TASK_BASE_QOS_POLICY,
418	(task_policy_t)&qosinfo,
419	TASK_QOS_POLICY_COUNT),
420	NULL);
421
422	ret = kill(pid, SIGTERM);
423	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
424	}
425
426	T_DECL(task_policy_set_foreign_task_inspect_entitled, "task_policy_set for foreign task inspect (entitled)", T_META_ASROOT(true))
427	{
428	struct task_qos_policy qosinfo = {
429	.task_latency_qos_tier = LATENCY_QOS_TIER_0,
430	.task_throughput_qos_tier = THROUGHPUT_QOS_TIER_0,
431	};
432	task_inspect_t task_inspect = TASK_INSPECT_NULL;
433	kern_return_t ret = KERN_FAILURE;
434	char *args[] = { "sleep", "10", NULL };
435	pid_t pid = 0;
436
437	T_SETUPBEGIN;
438
439	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
440	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
441
442	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid,
443	&task_inspect), NULL);
444	T_SETUPEND;
445
446	T_ASSERT_MACH_SUCCESS(task_policy_set(task_inspect,
447	TASK_BASE_QOS_POLICY,
448	(task_policy_t)&qosinfo,
449	TASK_QOS_POLICY_COUNT),
450	NULL);
451
452	ret = kill(pid, SIGTERM);
453	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
454	}
455
456	T_DECL(task_policy_get_name_entitled, "task_policy_get with task name (entitled)", T_META_ASROOT(true))
457	{
458	task_name_t task_name = TASK_NAME_NULL;
459	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
460	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
461	boolean_t get_default = FALSE;
462
463	T_SETUPBEGIN;
464	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), getpid(),
465	&task_name), NULL);
466	T_SETUPEND;
467
468	T_ASSERT_MACH_SUCCESS(task_policy_get(task_name,
469	TASK_CATEGORY_POLICY,
470	(task_policy_t)role,
471	&count,
472	&get_default),
473	NULL);
474	}
475
476	T_DECL(task_policy_get_task_entitled, "task_policy_get with task (entitled)")
477	{
478	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
479	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
480	boolean_t get_default = FALSE;
481
482	T_ASSERT_MACH_SUCCESS(task_policy_get(mach_task_self(),
483	TASK_CATEGORY_POLICY,
484	(task_policy_t)role,
485	&count,
486	&get_default),
487	NULL);
488	}
489
490	T_DECL(task_policy_get_inspect_entitled, "task_policy_get with task inspect (entitled)")
491	{
492	task_inspect_t task_inspect = TASK_INSPECT_NULL;
493	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
494	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
495	boolean_t get_default = FALSE;
496
497	T_SETUPBEGIN;
498	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), getpid(),
499	&task_inspect), NULL);
500	T_SETUPEND;
501
502	T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect,
503	TASK_CATEGORY_POLICY,
504	(task_policy_t)role,
505	&count,
506	&get_default),
507	NULL);
508	}
509
510	T_DECL(task_policy_get_foreign_task_inspect_entitled, "task_policy_get for foreign task inspect (entitled)", T_META_ASROOT(true))
511	{
512	task_inspect_t task_inspect = TASK_INSPECT_NULL;
513	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
514	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
515	boolean_t get_default = FALSE;
516	kern_return_t ret = KERN_FAILURE;
517	char *args[] = { "sleep", "10", NULL };
518	pid_t pid = 0;
519
520	T_SETUPBEGIN;
521
522	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
523	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
524
525	T_ASSERT_MACH_SUCCESS(task_inspect_for_pid(mach_task_self(), pid,
526	&task_inspect), NULL);
527	T_SETUPEND;
528
529	T_ASSERT_MACH_SUCCESS(task_policy_get(task_inspect,
530	TASK_CATEGORY_POLICY,
531	(task_policy_t)role,
532	&count,
533	&get_default),
534	NULL);
535
536	ret = kill(pid, SIGTERM);
537	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
538	}
539
540	T_DECL(task_policy_get_foreign_task_entitled, "task_policy_get for foreign task (entitled)", T_META_ASROOT(true))
541	{
542	task_t task = TASK_NULL;
543	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
544	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
545	boolean_t get_default = FALSE;
546	kern_return_t ret = KERN_FAILURE;
547	char *args[] = { "sleep", "10", NULL };
548	pid_t pid = 0;
549
550	T_SETUPBEGIN;
551
552	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
553	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
554
555	T_ASSERT_MACH_SUCCESS(task_for_pid(mach_task_self(), pid,
556	&task), NULL);
557	T_SETUPEND;
558
559	T_ASSERT_MACH_SUCCESS(task_policy_get(task,
560	TASK_CATEGORY_POLICY,
561	(task_policy_t)role,
562	&count,
563	&get_default),
564	NULL);
565
566	ret = kill(pid, SIGTERM);
567	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
568	}
569
570	T_DECL(task_policy_get_foreign_task_name_entitled, "task_policy_get for foreign task name (entitled)", T_META_ASROOT(true))
571	{
572	task_name_t task_name = TASK_NAME_NULL;
573	struct task_category_policy role[TASK_CATEGORY_POLICY_COUNT];
574	mach_msg_type_number_t count = TASK_CATEGORY_POLICY_COUNT;
575	boolean_t get_default = FALSE;
576	kern_return_t ret = KERN_FAILURE;
577	char *args[] = { "sleep", "10", NULL };
578	pid_t pid = 0;
579
580	T_SETUPBEGIN;
581
582	ret = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
583	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "spawning sleep 10");
584
585	T_ASSERT_MACH_SUCCESS(task_name_for_pid(mach_task_self(), pid,
586	&task_name), NULL);
587	T_SETUPEND;
588
589	T_ASSERT_MACH_SUCCESS(task_policy_get(task_name,
590	TASK_CATEGORY_POLICY,
591	(task_policy_t)role,
592	&count,
593	&get_default),
594	NULL);
595
596	ret = kill(pid, SIGTERM);
597	T_QUIET; T_ASSERT_POSIX_ZERO(ret, "killing sleep");
598	}
599
600	#endif /* UNENTITLED */