[apple/xnu.git] / bsd / kern / sys_coalition.c

#include <kern/kern_types.h>
#include <kern/thread_group.h>
#include <mach/mach_types.h>
#include <mach/boolean.h>

#include <kern/coalition.h>

#include <sys/coalition.h>
#include <sys/errno.h>
#include <sys/kernel.h>
#include <sys/sysproto.h>
#include <sys/systm.h>

/* Coalitions syscalls */

/*
 * Create a new, empty coalition and return its ID.
 *
 * Returns:
 * EINVAL	Flags parameter was invalid
 * ENOMEM	Unable to allocate kernel resources for a new coalition
 * EFAULT	cidp parameter pointed to invalid memory.
 *
 * Returns with reference held for userspace caller.
 */
static
int
coalition_create_syscall(user_addr_t cidp, uint32_t flags)
{
	int error = 0;
	kern_return_t kr;
	uint64_t cid;
	coalition_t coal;
	int type = COALITION_CREATE_FLAGS_GET_TYPE(flags);
	int role = COALITION_CREATE_FLAGS_GET_ROLE(flags);
	boolean_t privileged = !!(flags & COALITION_CREATE_FLAGS_PRIVILEGED);

	if ((flags & (~COALITION_CREATE_FLAGS_MASK)) != 0)
		return EINVAL;
	if (type < 0 || type > COALITION_TYPE_MAX)
		return EINVAL;

	kr = coalition_create_internal(type, role, privileged, &coal);
	if (kr != KERN_SUCCESS) {
		/* for now, the only kr is KERN_RESOURCE_SHORTAGE */
		error = ENOMEM;
		goto out;
	}

	cid = coalition_id(coal);

	coal_dbg("(addr, %u) -> %llu", flags, cid);
	error = copyout(&cid, cidp, sizeof(cid));
out:
	return error;
}

/*
 * Request to terminate the coalition identified by ID.
 * Attempts to spawn into this coalition using the posix_spawnattr will begin
 * failing. Processes already within the coalition may still fork.
 * Arms the 'coalition is empty' notification when the coalition's active
 * count reaches zero.
 *
 * Returns:
 * ESRCH	No coalition with that ID could be found.
 * EALREADY	The coalition with that ID has already been terminated.
 * EFAULT	cidp parameter pointed to invalid memory.
 * EPERM	Caller doesn't have permission to terminate that coalition.
 */
static
int
coalition_request_terminate_syscall(user_addr_t cidp, uint32_t flags)
{
	kern_return_t kr;
	int error = 0;
	uint64_t cid;
	coalition_t coal;

	if (flags != 0) {
		return EINVAL;
	}

	error = copyin(cidp, &cid, sizeof(cid));
	if (error) {
		return error;
	}

	coal = coalition_find_by_id(cid);
	if (coal == COALITION_NULL) {
		return ESRCH;
	}

	kr = coalition_request_terminate_internal(coal);
	coalition_release(coal);

	switch (kr) {
	case KERN_SUCCESS:
		break;
	case KERN_DEFAULT_SET:
		error = EPERM;
		break;
	case KERN_TERMINATED:
		error = EALREADY;
		break;
	case KERN_INVALID_NAME:
		error = ESRCH;
		break;
	default:
		error = EIO;
		break;
	}

	coal_dbg("(%llu, %u) -> %d", cid, flags, error);

	return error;
}

/*
 * Request the kernel to deallocate the coalition identified by ID, which
 * must be both terminated and empty. This balances the reference taken
 * in coalition_create.
 * The memory containing the coalition object may not be freed just yet, if
 * other kernel operations still hold references to it.
 *
 * Returns:
 * EINVAL	Flags parameter was invalid
 * ESRCH	Coalition ID refers to a coalition that doesn't exist.
 * EBUSY	Coalition has not yet been terminated.
 * EBUSY	Coalition is still active.
 * EFAULT	cidp parameter pointed to invalid memory.
 * EPERM	Caller doesn't have permission to terminate that coalition.
 * Consumes one reference, "held" by caller since coalition_create
 */
static
int
coalition_reap_syscall(user_addr_t cidp, uint32_t flags)
{
	kern_return_t kr;
	int error = 0;
	uint64_t cid;
	coalition_t coal;

	if (flags != 0) {
		return EINVAL;
	}

	error = copyin(cidp, &cid, sizeof(cid));
	if (error) {
		return error;
	}

	coal = coalition_find_by_id(cid);
	if (coal == COALITION_NULL) {
		return ESRCH;
	}

	kr = coalition_reap_internal(coal);
	coalition_release(coal);

	switch (kr) {
	case KERN_SUCCESS:
		break;
	case KERN_DEFAULT_SET:
		error = EPERM;
		break;
	case KERN_TERMINATED:
		error = ESRCH;
		break;
	case KERN_FAILURE:
		error = EBUSY;
		break;
	default:
		error = EIO;
		break;
	}

	coal_dbg("(%llu, %u) -> %d", cid, flags, error);

	return error;
}

/* Syscall demux.
 * Returns EPERM if the calling process is not privileged to make this call.
 */
int coalition(proc_t p, struct coalition_args *cap, __unused int32_t *retval)
{
	uint32_t operation = cap->operation;
	user_addr_t cidp = cap->cid;
	uint32_t flags = cap->flags;
	int error = 0;
	int type = COALITION_CREATE_FLAGS_GET_TYPE(flags);

	if (!task_is_in_privileged_coalition(p->task, type)) {
		return EPERM;
	}

	switch (operation) {
	case COALITION_OP_CREATE:
		error = coalition_create_syscall(cidp, flags);
		break;
	case COALITION_OP_REAP:
		error = coalition_reap_syscall(cidp, flags);
		break;
	case COALITION_OP_TERMINATE:
		error = coalition_request_terminate_syscall(cidp, flags);
		break;
	default:
		error = ENOSYS;
	}
	return error;
}

/* This is a temporary interface, likely to be changed by 15385642. */
static int __attribute__ ((noinline))
coalition_info_resource_usage(coalition_t coal, user_addr_t buffer, user_size_t bufsize)
{
	kern_return_t kr;
	struct coalition_resource_usage cru = {};

	kr = coalition_resource_usage_internal(coal, &cru);

	switch (kr) {
	case KERN_INVALID_ARGUMENT:
		return EINVAL;
	case KERN_RESOURCE_SHORTAGE:
		return ENOMEM;
	case KERN_SUCCESS:
		break;
	default:
		return EIO; /* shrug */
	}

	return copyout(&cru, buffer, MIN(bufsize, sizeof(cru)));
}

#define coalition_info_set_name_internal(...) 0

static int
coalition_info_efficiency(coalition_t coal, user_addr_t buffer, user_size_t bufsize)
{
	int error = 0;
	if (coalition_type(coal) != COALITION_TYPE_JETSAM)
		return EINVAL;
	uint64_t flags = 0;	
	error = copyin(buffer, &flags, MIN(bufsize, sizeof(flags)));
	if (error)
		return error;
	if ((flags & COALITION_EFFICIENCY_VALID_FLAGS) == 0)
		return EINVAL;
	if (flags & COALITION_FLAGS_EFFICIENT) {
	    coalition_set_efficient(coal);
	}
	return error;
}

int coalition_info(proc_t p, struct coalition_info_args *uap, __unused int32_t *retval)
{
	user_addr_t cidp = uap->cid;
	user_addr_t buffer = uap->buffer;
	user_addr_t bufsizep = uap->bufsize;
	user_size_t bufsize;
	uint32_t flavor = uap->flavor;
	int error;
	uint64_t cid;
	coalition_t coal;

	error = copyin(cidp, &cid, sizeof(cid));
	if (error) {
		return error;
	}

	coal = coalition_find_by_id(cid);
	if (coal == COALITION_NULL) {
		return ESRCH;
	}
	/* TODO: priv check? EPERM or ESRCH? */

	if (IS_64BIT_PROCESS(p)) {
		user64_size_t size64;
		error = copyin(bufsizep, &size64, sizeof(size64));
		bufsize = (user_size_t)size64;
	} else {
		user32_size_t size32;
		error = copyin(bufsizep, &size32, sizeof(size32));
		bufsize = (user_size_t)size32;
	}
	if (error) {
		goto bad;
	}

	switch (flavor) {
	case COALITION_INFO_RESOURCE_USAGE:
		error = coalition_info_resource_usage(coal, buffer, bufsize);
		break;
	case COALITION_INFO_SET_NAME:
		error = coalition_info_set_name_internal(coal, buffer, bufsize);
		break;
	case COALITION_INFO_SET_EFFICIENCY:
		error = coalition_info_efficiency(coal, buffer, bufsize);
		break;
	default:
		error = EINVAL;
	}

bad:
	coalition_release(coal);
	return error;
}

#if DEVELOPMENT || DEBUG
static int sysctl_coalition_get_ids SYSCTL_HANDLER_ARGS
{
#pragma unused(oidp, arg1, arg2)
	int error, pid;
	proc_t tproc;
	uint64_t value;
	uint64_t ids[COALITION_NUM_TYPES];


	error = SYSCTL_IN(req, &value, sizeof(value));
	if (error)
		return error;
	if (!req->newptr)
		pid = req->p->p_pid;
	else
		pid = (int)value;

	coal_dbg("looking up coalitions for pid:%d", pid);
	tproc = proc_find(pid);
	if (tproc == NULL) {
		coal_dbg("ERROR: Couldn't find pid:%d", pid);
		return ESRCH;
	}

	task_coalition_ids(tproc->task, ids);
	proc_rele(tproc);

	return SYSCTL_OUT(req, ids, sizeof(ids));
}

SYSCTL_PROC(_kern, OID_AUTO, coalitions, CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
	    0, 0, sysctl_coalition_get_ids, "Q", "coalition ids of a given process");


static int sysctl_coalition_get_roles SYSCTL_HANDLER_ARGS
{
#pragma unused(oidp, arg1, arg2)
	int error, pid;
	proc_t tproc;
	int value;
	int roles[COALITION_NUM_TYPES];


	error = SYSCTL_IN(req, &value, sizeof(value));
	if (error)
		return error;
	if (!req->newptr)
		pid = req->p->p_pid;
	else
		pid = (int)value;

	coal_dbg("looking up coalitions for pid:%d", pid);
	tproc = proc_find(pid);
	if (tproc == NULL) {
		coal_dbg("ERROR: Couldn't find pid:%d", pid);
		return ESRCH;
	}

	task_coalition_roles(tproc->task, roles);
	proc_rele(tproc);

	return SYSCTL_OUT(req, roles, sizeof(roles));
}

SYSCTL_PROC(_kern, OID_AUTO, coalition_roles, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
	    0, 0, sysctl_coalition_get_roles, "I", "coalition roles of a given process");


static int sysctl_coalition_get_page_count SYSCTL_HANDLER_ARGS
{
#pragma unused(oidp, arg1, arg2)
	int error, pid;
	proc_t tproc;
	coalition_t coal;
	uint64_t value;
	uint64_t pgcount[COALITION_NUM_TYPES];


	error = SYSCTL_IN(req, &value, sizeof(value));
	if (error)
		return error;
	if (!req->newptr)
		pid = req->p->p_pid;
	else
		pid = (int)value;

	coal_dbg("looking up coalitions for pid:%d", pid);
	tproc = proc_find(pid);
	if (tproc == NULL) {
		coal_dbg("ERROR: Couldn't find pid:%d", pid);
		return ESRCH;
	}

	memset(pgcount, 0, sizeof(pgcount));

	for (int t = 0; t < COALITION_NUM_TYPES; t++) {
		coal = COALITION_NULL;
		coalition_is_leader(tproc->task, t, &coal);
		if (coal != COALITION_NULL) {
			int ntasks = 0;
			pgcount[t] = coalition_get_page_count(coal, &ntasks);
			coal_dbg("PID:%d, Coalition:%lld, type:%d, pgcount:%lld",
				 pid, coalition_id(coal), t, pgcount[t]);
		}
	}

	proc_rele(tproc);

	return SYSCTL_OUT(req, pgcount, sizeof(pgcount));
}

SYSCTL_PROC(_kern, OID_AUTO, coalition_page_count, CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
	    0, 0, sysctl_coalition_get_page_count, "Q", "coalition page count of a specified process");


static int sysctl_coalition_get_pid_list SYSCTL_HANDLER_ARGS
{
#pragma unused(oidp, arg1, arg2)
	int error, type, sort_order, pid;
	int value[3];
	int has_pid = 1;

	coalition_t coal = COALITION_NULL;
	proc_t tproc = PROC_NULL;
	int npids = 0;
	int pidlist[100] = { 0, };


	error = SYSCTL_IN(req, &value, sizeof(value));
	if (error) {
		has_pid = 0;
		error = SYSCTL_IN(req, &value, sizeof(value) - sizeof(value[0]));
	}
	if (error)
		return error;
	if (!req->newptr) {
		type = COALITION_TYPE_RESOURCE;
		sort_order = COALITION_SORT_DEFAULT;
		pid = req->p->p_pid;
	} else {
		type = value[0];
		sort_order = value[1];
		if (has_pid)
			pid = value[2];
		else
			pid = req->p->p_pid;
	}

	if (type < 0 || type >= COALITION_NUM_TYPES)
		return EINVAL;

	coal_dbg("getting constituent PIDS for coalition of type %d "
		 "containing pid:%d (sort:%d)", type, pid, sort_order);
	tproc = proc_find(pid);
	if (tproc == NULL) {
		coal_dbg("ERROR: Couldn't find pid:%d", pid);
		return ESRCH;
	}

	(void)coalition_is_leader(tproc->task, type, &coal);
	if (coal == COALITION_NULL) {
		goto out;
	}

	npids = coalition_get_pid_list(coal, COALITION_ROLEMASK_ALLROLES, sort_order,
				       pidlist, sizeof(pidlist) / sizeof(pidlist[0]));
	if (npids > (int)(sizeof(pidlist) / sizeof(pidlist[0]))) {
		coal_dbg("Too many members in coalition %llu (from pid:%d): %d!",
			 coalition_id(coal), pid, npids);
		npids = sizeof(pidlist) / sizeof(pidlist[0]);
	}

out:
	proc_rele(tproc);

	if (npids < 0) {
		/* npids is a negative errno */
		return -npids;
	}

	if (npids == 0)
		return ENOENT;

	return SYSCTL_OUT(req, pidlist, sizeof(pidlist[0]) * npids);
}

SYSCTL_PROC(_kern, OID_AUTO, coalition_pid_list, CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_LOCKED,
	    0, 0, sysctl_coalition_get_pid_list, "I", "list of PIDS which are members of the coalition of the current process");

#if DEVELOPMENT
static int sysctl_coalition_notify SYSCTL_HANDLER_ARGS
{
#pragma unused(oidp, arg1, arg2)
	int error, should_set;
	coalition_t coal;
	uint64_t value[2];

	should_set = 1;
	error = SYSCTL_IN(req, value, sizeof(value));
	if (error) {
		error = SYSCTL_IN(req, value, sizeof(value) - sizeof(value[0]));
		if (error)
			return error;
		should_set = 0;
	}
	if (!req->newptr)
		return error;

	coal = coalition_find_by_id(value[0]);
	if (coal == COALITION_NULL) {
		coal_dbg("Can't find coalition with ID:%lld", value[0]);
		return ESRCH;
	}

	if (should_set)
		coalition_set_notify(coal, (int)value[1]);

	value[0] = (uint64_t)coalition_should_notify(coal);

	coalition_release(coal);

	return SYSCTL_OUT(req, value, sizeof(value[0]));
}

SYSCTL_PROC(_kern, OID_AUTO, coalition_notify, CTLTYPE_QUAD | CTLFLAG_RW | CTLFLAG_LOCKED,
	    0, 0, sysctl_coalition_notify, "Q", "get/set coalition notification flag");

extern int unrestrict_coalition_syscalls;
SYSCTL_INT(_kern, OID_AUTO, unrestrict_coalitions,
	   CTLFLAG_RW, &unrestrict_coalition_syscalls, 0,
	   "unrestrict the coalition interface");

#endif /* DEVELOPMENT */

#endif /* DEVELOPMENT || DEBUG */
Commit	Line	Data
fe8ab488	1	#include <kern/kern_types.h>
5ba3f43e	2	#include <kern/thread_group.h>
fe8ab488 A	3	#include <mach/mach_types.h>
	4	#include <mach/boolean.h>
	5
	6	#include <kern/coalition.h>
	7
	8	#include <sys/coalition.h>
	9	#include <sys/errno.h>
	10	#include <sys/kernel.h>
	11	#include <sys/sysproto.h>
	12	#include <sys/systm.h>
	13
	14	/* Coalitions syscalls */
	15
	16	/*
	17	* Create a new, empty coalition and return its ID.
	18	*
	19	* Returns:
	20	* EINVAL Flags parameter was invalid
	21	* ENOMEM Unable to allocate kernel resources for a new coalition
	22	* EFAULT cidp parameter pointed to invalid memory.
	23	*
	24	* Returns with reference held for userspace caller.
	25	*/
	26	static
	27	int
	28	coalition_create_syscall(user_addr_t cidp, uint32_t flags)
	29	{
	30	int error = 0;
	31	kern_return_t kr;
	32	uint64_t cid;
	33	coalition_t coal;
3e170ce0	34	int type = COALITION_CREATE_FLAGS_GET_TYPE(flags);
5ba3f43e	35	int role = COALITION_CREATE_FLAGS_GET_ROLE(flags);
3e170ce0	36	boolean_t privileged = !!(flags & COALITION_CREATE_FLAGS_PRIVILEGED);
fe8ab488	37
3e170ce0 A	38	if ((flags & (~COALITION_CREATE_FLAGS_MASK)) != 0)
	39	return EINVAL;
	40	if (type < 0 \|\| type > COALITION_TYPE_MAX)
fe8ab488	41	return EINVAL;
fe8ab488	42
5ba3f43e	43	kr = coalition_create_internal(type, role, privileged, &coal);
fe8ab488 A	44	if (kr != KERN_SUCCESS) {
	45	/* for now, the only kr is KERN_RESOURCE_SHORTAGE */
	46	error = ENOMEM;
	47	goto out;
	48	}
	49
	50	cid = coalition_id(coal);
	51
3e170ce0	52	coal_dbg("(addr, %u) -> %llu", flags, cid);
fe8ab488 A	53	error = copyout(&cid, cidp, sizeof(cid));
	54	out:
	55	return error;
	56	}
	57
	58	/*
	59	* Request to terminate the coalition identified by ID.
	60	* Attempts to spawn into this coalition using the posix_spawnattr will begin
	61	* failing. Processes already within the coalition may still fork.
	62	* Arms the 'coalition is empty' notification when the coalition's active
	63	* count reaches zero.
	64	*
	65	* Returns:
	66	* ESRCH No coalition with that ID could be found.
	67	* EALREADY The coalition with that ID has already been terminated.
	68	* EFAULT cidp parameter pointed to invalid memory.
	69	* EPERM Caller doesn't have permission to terminate that coalition.
	70	*/
	71	static
	72	int
	73	coalition_request_terminate_syscall(user_addr_t cidp, uint32_t flags)
	74	{
	75	kern_return_t kr;
	76	int error = 0;
	77	uint64_t cid;
	78	coalition_t coal;
	79
	80	if (flags != 0) {
	81	return EINVAL;
	82	}
	83
	84	error = copyin(cidp, &cid, sizeof(cid));
	85	if (error) {
	86	return error;
	87	}
	88
	89	coal = coalition_find_by_id(cid);
	90	if (coal == COALITION_NULL) {
	91	return ESRCH;
	92	}
	93
	94	kr = coalition_request_terminate_internal(coal);
	95	coalition_release(coal);
	96
	97	switch (kr) {
	98	case KERN_SUCCESS:
	99	break;
	100	case KERN_DEFAULT_SET:
	101	error = EPERM;
3e170ce0	102	break;
fe8ab488 A	103	case KERN_TERMINATED:
fe8ab488 A	104	error = EALREADY;
3e170ce0	105	break;
fe8ab488 A	106	case KERN_INVALID_NAME:
fe8ab488 A	107	error = ESRCH;
3e170ce0	108	break;
fe8ab488 A	109	default:
fe8ab488 A	110	error = EIO;
3e170ce0	111	break;
fe8ab488 A	112	}
fe8ab488 A	113
3e170ce0	114	coal_dbg("(%llu, %u) -> %d", cid, flags, error);
fe8ab488 A	115
	116	return error;
	117	}
	118
	119	/*
	120	* Request the kernel to deallocate the coalition identified by ID, which
	121	* must be both terminated and empty. This balances the reference taken
	122	* in coalition_create.
5ba3f43e	123	* The memory containing the coalition object may not be freed just yet, if
fe8ab488 A	124	* other kernel operations still hold references to it.
	125	*
	126	* Returns:
	127	* EINVAL Flags parameter was invalid
	128	* ESRCH Coalition ID refers to a coalition that doesn't exist.
	129	* EBUSY Coalition has not yet been terminated.
	130	* EBUSY Coalition is still active.
	131	* EFAULT cidp parameter pointed to invalid memory.
	132	* EPERM Caller doesn't have permission to terminate that coalition.
	133	* Consumes one reference, "held" by caller since coalition_create
	134	*/
	135	static
	136	int
	137	coalition_reap_syscall(user_addr_t cidp, uint32_t flags)
	138	{
	139	kern_return_t kr;
	140	int error = 0;
	141	uint64_t cid;
	142	coalition_t coal;
	143
	144	if (flags != 0) {
	145	return EINVAL;
	146	}
	147
	148	error = copyin(cidp, &cid, sizeof(cid));
	149	if (error) {
	150	return error;
	151	}
	152
	153	coal = coalition_find_by_id(cid);
	154	if (coal == COALITION_NULL) {
	155	return ESRCH;
	156	}
	157
	158	kr = coalition_reap_internal(coal);
	159	coalition_release(coal);
	160
	161	switch (kr) {
	162	case KERN_SUCCESS:
	163	break;
	164	case KERN_DEFAULT_SET:
	165	error = EPERM;
3e170ce0	166	break;
fe8ab488 A	167	case KERN_TERMINATED:
fe8ab488 A	168	error = ESRCH;
3e170ce0	169	break;
fe8ab488 A	170	case KERN_FAILURE:
fe8ab488 A	171	error = EBUSY;
3e170ce0	172	break;
fe8ab488 A	173	default:
fe8ab488 A	174	error = EIO;
3e170ce0	175	break;
fe8ab488 A	176	}
fe8ab488 A	177
3e170ce0	178	coal_dbg("(%llu, %u) -> %d", cid, flags, error);
fe8ab488 A	179
	180	return error;
	181	}
	182
	183	/* Syscall demux.
	184	* Returns EPERM if the calling process is not privileged to make this call.
	185	*/
	186	int coalition(proc_t p, struct coalition_args cap, __unused int32_t retval)
	187	{
	188	uint32_t operation = cap->operation;
	189	user_addr_t cidp = cap->cid;
	190	uint32_t flags = cap->flags;
	191	int error = 0;
3e170ce0	192	int type = COALITION_CREATE_FLAGS_GET_TYPE(flags);
fe8ab488	193
3e170ce0	194	if (!task_is_in_privileged_coalition(p->task, type)) {
fe8ab488 A	195	return EPERM;
	196	}
	197
	198	switch (operation) {
	199	case COALITION_OP_CREATE:
	200	error = coalition_create_syscall(cidp, flags);
	201	break;
	202	case COALITION_OP_REAP:
	203	error = coalition_reap_syscall(cidp, flags);
	204	break;
	205	case COALITION_OP_TERMINATE:
	206	error = coalition_request_terminate_syscall(cidp, flags);
	207	break;
	208	default:
	209	error = ENOSYS;
	210	}
	211	return error;
	212	}
	213
	214	/* This is a temporary interface, likely to be changed by 15385642. */
	215	static int __attribute__ ((noinline))
	216	coalition_info_resource_usage(coalition_t coal, user_addr_t buffer, user_size_t bufsize)
	217	{
	218	kern_return_t kr;
527f9951	219	struct coalition_resource_usage cru = {};
fe8ab488	220
fe8ab488 A	221	kr = coalition_resource_usage_internal(coal, &cru);
	222
	223	switch (kr) {
	224	case KERN_INVALID_ARGUMENT:
	225	return EINVAL;
	226	case KERN_RESOURCE_SHORTAGE:
	227	return ENOMEM;
	228	case KERN_SUCCESS:
	229	break;
	230	default:
	231	return EIO; /* shrug */
	232	}
	233
4bd07ac2	234	return copyout(&cru, buffer, MIN(bufsize, sizeof(cru)));
fe8ab488 A	235	}
fe8ab488 A	236
5ba3f43e A	237	#define coalition_info_set_name_internal(...) 0
	238
	239	static int
	240	coalition_info_efficiency(coalition_t coal, user_addr_t buffer, user_size_t bufsize)
	241	{
	242	int error = 0;
	243	if (coalition_type(coal) != COALITION_TYPE_JETSAM)
	244	return EINVAL;
	245	uint64_t flags = 0;
	246	error = copyin(buffer, &flags, MIN(bufsize, sizeof(flags)));
	247	if (error)
	248	return error;
	249	if ((flags & COALITION_EFFICIENCY_VALID_FLAGS) == 0)
	250	return EINVAL;
	251	if (flags & COALITION_FLAGS_EFFICIENT) {
	252	coalition_set_efficient(coal);
	253	}
	254	return error;
	255	}
	256
fe8ab488 A	257	int coalition_info(proc_t p, struct coalition_info_args uap, __unused int32_t retval)
	258	{
	259	user_addr_t cidp = uap->cid;
	260	user_addr_t buffer = uap->buffer;
	261	user_addr_t bufsizep = uap->bufsize;
	262	user_size_t bufsize;
	263	uint32_t flavor = uap->flavor;
	264	int error;
	265	uint64_t cid;
	266	coalition_t coal;
	267
	268	error = copyin(cidp, &cid, sizeof(cid));
	269	if (error) {
	270	return error;
	271	}
	272
	273	coal = coalition_find_by_id(cid);
	274	if (coal == COALITION_NULL) {
	275	return ESRCH;
	276	}
	277	/* TODO: priv check? EPERM or ESRCH? */
	278
	279	if (IS_64BIT_PROCESS(p)) {
	280	user64_size_t size64;
	281	error = copyin(bufsizep, &size64, sizeof(size64));
	282	bufsize = (user_size_t)size64;
	283	} else {
	284	user32_size_t size32;
	285	error = copyin(bufsizep, &size32, sizeof(size32));
	286	bufsize = (user_size_t)size32;
	287	}
	288	if (error) {
	289	goto bad;
	290	}
	291
	292	switch (flavor) {
	293	case COALITION_INFO_RESOURCE_USAGE:
	294	error = coalition_info_resource_usage(coal, buffer, bufsize);
	295	break;
5ba3f43e A	296	case COALITION_INFO_SET_NAME:
	297	error = coalition_info_set_name_internal(coal, buffer, bufsize);
	298	break;
	299	case COALITION_INFO_SET_EFFICIENCY:
	300	error = coalition_info_efficiency(coal, buffer, bufsize);
	301	break;
fe8ab488 A	302	default:
	303	error = EINVAL;
	304	}
	305
	306	bad:
	307	coalition_release(coal);
	308	return error;
	309	}
3e170ce0	310
5ba3f43e	311	#if DEVELOPMENT \|\| DEBUG
3e170ce0 A	312	static int sysctl_coalition_get_ids SYSCTL_HANDLER_ARGS
	313	{
	314	#pragma unused(oidp, arg1, arg2)
	315	int error, pid;
	316	proc_t tproc;
	317	uint64_t value;
	318	uint64_t ids[COALITION_NUM_TYPES];
	319
	320
	321	error = SYSCTL_IN(req, &value, sizeof(value));
	322	if (error)
	323	return error;
	324	if (!req->newptr)
	325	pid = req->p->p_pid;
	326	else
	327	pid = (int)value;
	328
	329	coal_dbg("looking up coalitions for pid:%d", pid);
	330	tproc = proc_find(pid);
	331	if (tproc == NULL) {
	332	coal_dbg("ERROR: Couldn't find pid:%d", pid);
	333	return ESRCH;
	334	}
	335
	336	task_coalition_ids(tproc->task, ids);
	337	proc_rele(tproc);
	338
	339	return SYSCTL_OUT(req, ids, sizeof(ids));
	340	}
	341
	342	SYSCTL_PROC(_kern, OID_AUTO, coalitions, CTLTYPE_QUAD \| CTLFLAG_RW \| CTLFLAG_LOCKED,
	343	0, 0, sysctl_coalition_get_ids, "Q", "coalition ids of a given process");
	344
	345
	346	static int sysctl_coalition_get_roles SYSCTL_HANDLER_ARGS
	347	{
	348	#pragma unused(oidp, arg1, arg2)
	349	int error, pid;
	350	proc_t tproc;
	351	int value;
	352	int roles[COALITION_NUM_TYPES];
	353
	354
	355	error = SYSCTL_IN(req, &value, sizeof(value));
	356	if (error)
	357	return error;
	358	if (!req->newptr)
	359	pid = req->p->p_pid;
	360	else
	361	pid = (int)value;
	362
	363	coal_dbg("looking up coalitions for pid:%d", pid);
	364	tproc = proc_find(pid);
	365	if (tproc == NULL) {
	366	coal_dbg("ERROR: Couldn't find pid:%d", pid);
	367	return ESRCH;
	368	}
	369
	370	task_coalition_roles(tproc->task, roles);
	371	proc_rele(tproc);
	372
	373	return SYSCTL_OUT(req, roles, sizeof(roles));
	374	}
	375
376	SYSCTL_PROC(_kern, OID_AUTO, coalition_roles, CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_LOCKED,
377	0, 0, sysctl_coalition_get_roles, "I", "coalition roles of a given process");
378
379
380	static int sysctl_coalition_get_page_count SYSCTL_HANDLER_ARGS
381	{
382	#pragma unused(oidp, arg1, arg2)
383	int error, pid;
384	proc_t tproc;
385	coalition_t coal;
386	uint64_t value;
387	uint64_t pgcount[COALITION_NUM_TYPES];
388
389
390	error = SYSCTL_IN(req, &value, sizeof(value));
391	if (error)
392	return error;
393	if (!req->newptr)
394	pid = req->p->p_pid;
395	else
396	pid = (int)value;
397
398	coal_dbg("looking up coalitions for pid:%d", pid);
399	tproc = proc_find(pid);
400	if (tproc == NULL) {
401	coal_dbg("ERROR: Couldn't find pid:%d", pid);
402	return ESRCH;
403	}
404
405	memset(pgcount, 0, sizeof(pgcount));
406
407	for (int t = 0; t < COALITION_NUM_TYPES; t++) {
408	coal = COALITION_NULL;
409	coalition_is_leader(tproc->task, t, &coal);
410	if (coal != COALITION_NULL) {
411	int ntasks = 0;
412	pgcount[t] = coalition_get_page_count(coal, &ntasks);
413	coal_dbg("PID:%d, Coalition:%lld, type:%d, pgcount:%lld",
414	pid, coalition_id(coal), t, pgcount[t]);
415	}
416	}
417
418	proc_rele(tproc);
419
420	return SYSCTL_OUT(req, pgcount, sizeof(pgcount));
421	}
422
423	SYSCTL_PROC(_kern, OID_AUTO, coalition_page_count, CTLTYPE_QUAD \| CTLFLAG_RW \| CTLFLAG_LOCKED,
424	0, 0, sysctl_coalition_get_page_count, "Q", "coalition page count of a specified process");
425
426
427	static int sysctl_coalition_get_pid_list SYSCTL_HANDLER_ARGS
428	{
429	#pragma unused(oidp, arg1, arg2)
430	int error, type, sort_order, pid;
431	int value[3];
432	int has_pid = 1;
433
434	coalition_t coal = COALITION_NULL;
435	proc_t tproc = PROC_NULL;
436	int npids = 0;
437	int pidlist[100] = { 0, };
438
439
440	error = SYSCTL_IN(req, &value, sizeof(value));
441	if (error) {
442	has_pid = 0;
443	error = SYSCTL_IN(req, &value, sizeof(value) - sizeof(value[0]));
444	}
445	if (error)
446	return error;
447	if (!req->newptr) {
448	type = COALITION_TYPE_RESOURCE;
449	sort_order = COALITION_SORT_DEFAULT;
450	pid = req->p->p_pid;
451	} else {
452	type = value[0];
453	sort_order = value[1];
454	if (has_pid)
455	pid = value[2];
456	else
457	pid = req->p->p_pid;
458	}
459
460	if (type < 0 \|\| type >= COALITION_NUM_TYPES)
461	return EINVAL;
462
463	coal_dbg("getting constituent PIDS for coalition of type %d "
464	"containing pid:%d (sort:%d)", type, pid, sort_order);
465	tproc = proc_find(pid);
466	if (tproc == NULL) {
467	coal_dbg("ERROR: Couldn't find pid:%d", pid);
468	return ESRCH;
469	}
470
471	(void)coalition_is_leader(tproc->task, type, &coal);
472	if (coal == COALITION_NULL) {
473	goto out;
474	}
475
476	npids = coalition_get_pid_list(coal, COALITION_ROLEMASK_ALLROLES, sort_order,
477	pidlist, sizeof(pidlist) / sizeof(pidlist[0]));
478	if (npids > (int)(sizeof(pidlist) / sizeof(pidlist[0]))) {
479	coal_dbg("Too many members in coalition %llu (from pid:%d): %d!",
480	coalition_id(coal), pid, npids);
481	npids = sizeof(pidlist) / sizeof(pidlist[0]);
482	}
483
484	out:
485	proc_rele(tproc);
486
5c9f4661 A	487	if (npids < 0) {
	488	/* npids is a negative errno */
	489	return -npids;
	490	}
	491
3e170ce0 A	492	if (npids == 0)
	493	return ENOENT;
	494
	495	return SYSCTL_OUT(req, pidlist, sizeof(pidlist[0]) * npids);
	496	}
	497
	498	SYSCTL_PROC(_kern, OID_AUTO, coalition_pid_list, CTLTYPE_INT \| CTLFLAG_RW \| CTLFLAG_LOCKED,
	499	0, 0, sysctl_coalition_get_pid_list, "I", "list of PIDS which are members of the coalition of the current process");
	500
	501	#if DEVELOPMENT
	502	static int sysctl_coalition_notify SYSCTL_HANDLER_ARGS
	503	{
	504	#pragma unused(oidp, arg1, arg2)
	505	int error, should_set;
	506	coalition_t coal;
	507	uint64_t value[2];
	508
	509	should_set = 1;
	510	error = SYSCTL_IN(req, value, sizeof(value));
	511	if (error) {
	512	error = SYSCTL_IN(req, value, sizeof(value) - sizeof(value[0]));
	513	if (error)
	514	return error;
	515	should_set = 0;
	516	}
	517	if (!req->newptr)
	518	return error;
	519
	520	coal = coalition_find_by_id(value[0]);
	521	if (coal == COALITION_NULL) {
	522	coal_dbg("Can't find coalition with ID:%lld", value[0]);
	523	return ESRCH;
	524	}
	525
	526	if (should_set)
	527	coalition_set_notify(coal, (int)value[1]);
	528
	529	value[0] = (uint64_t)coalition_should_notify(coal);
	530
	531	coalition_release(coal);
	532
	533	return SYSCTL_OUT(req, value, sizeof(value[0]));
	534	}
	535
	536	SYSCTL_PROC(_kern, OID_AUTO, coalition_notify, CTLTYPE_QUAD \| CTLFLAG_RW \| CTLFLAG_LOCKED,
	537	0, 0, sysctl_coalition_notify, "Q", "get/set coalition notification flag");
	538
	539	extern int unrestrict_coalition_syscalls;
	540	SYSCTL_INT(_kern, OID_AUTO, unrestrict_coalitions,
	541	CTLFLAG_RW, &unrestrict_coalition_syscalls, 0,
	542	"unrestrict the coalition interface");
	543
	544	#endif /* DEVELOPMENT */
	545
	546	#endif /* DEVELOPMENT \|\| DEBUG */