[PATCH gnumach v2 2/6] add max_priority to task object

From: Diego Nieto Cid <[email protected]>

  * inlcude/man/mach_host.def: add task_max_prioity RPC.
  * kern/task.h: add max_priority to task struct.
  * kern/task.c: implement task_max_priority RPC and inherit
                 max_priority from parent task (or default
                 processor set).
  * kern/thread.c: initialize new threads' max_priority from
                   the task creating the thread.
---
 include/mach/mach_host.defs |  21 +++++++
 kern/task.c                 | 109 ++++++++++++++++++++++++++++++++++++
 kern/task.h                 |   1 +
 kern/thread.c               |   1 +
 4 files changed, 132 insertions(+)

diff --git a/include/mach/mach_host.defs b/include/mach/mach_host.defs
index 70a2e866..01fc3758 100644
--- a/include/mach/mach_host.defs
+++ b/include/mach/mach_host.defs
@@ -400,3 +400,24 @@ routine	host_get_uptime64(
 routine processor_set_processors(
 		set_name	: processor_set_name_t;
 	out	processors_list	: processor_name_array_t);
+
+/*
+ *	Set the task max priority to max_priority.
+ *
+ *	If set_priority is TRUE, the task priority is
+ *	also set to follow max_priority.
+ *
+ *	Regardless the value of set_priority, if the
+ *	max_priority is lower than the current priority
+ *	then the task priority is lowered to max_priority.
+ *
+ *	If change_threads is TRUE, the resulting parameters
+ *	of the task, max_priority and priority, are propagated
+ *	to the current threads of the task.
+ */
+routine task_max_priority(
+		host		: mach_port_t;
+		task		: task_t;
+		max_priority	: int;
+		set_priority	: boolean_t;
+		change_threads	: boolean_t);
diff --git a/kern/task.c b/kern/task.c
index 061a8fa4..61a30502 100644
--- a/kern/task.c
+++ b/kern/task.c
@@ -40,6 +40,7 @@
 #include <mach_debug/mach_debug_types.h>
 #include <ipc/ipc_space.h>
 #include <ipc/ipc_types.h>
+#include <kern/assert.h>
 #include <kern/debug.h>
 #include <kern/task.h>
 #include <kern/thread.h>
@@ -171,12 +172,18 @@ task_create_kernel(
 			pset = &default_pset;
 		pset_reference(pset);
 		new_task->priority = parent_task->priority;
+		new_task->max_priority = parent_task->max_priority;
+		/* at this point max_priority/priority must be valid */
+		assert(new_task->priority >= new_task->max_priority);
 		task_unlock(parent_task);
 	}
 	else {
 		pset = &default_pset;
 		pset_reference(pset);
 		new_task->priority = BASEPRI_USER;
+		new_task->max_priority = pset->max_priority;
+		if (new_task->max_priority > new_task->priority)
+			new_task->priority = new_task->max_priority;
 	}
 	pset_lock(pset);
 	pset_add_task(pset, new_task);
@@ -1375,3 +1382,105 @@ register_new_task_notification(
 	new_task_notification = notification;
 	return KERN_SUCCESS;
 }
+
+/*
+ *	thread_override_max_priority:
+ *
+ *	Sets the max priority of the given threead.
+ *	Will adjust priority if necessary or requested.
+ *
+ *	However, it will not rise above the processor set
+ *	max priority.
+ */
+static kern_return_t
+thread_override_max_priority(
+	thread_t	thread,
+	int		max_priority,
+	boolean_t	set_priority)
+{
+	spl_t	s;
+
+	s = splsched();
+	thread_lock(thread);
+
+	thread->max_priority = max_priority;
+	if (thread->processor_set->max_priority > max_priority)
+		thread->max_priority = thread->processor_set->max_priority;
+	if ((thread->max_priority > thread->priority) || (set_priority == TRUE))
+		thread->priority = thread->max_priority;
+
+	compute_priority(thread, TRUE);
+
+	thread_unlock(thread);
+	(void) splx(s);
+
+	return KERN_SUCCESS;
+}
+
+static
+ipc_kobject_type_t extract_host_type(const ipc_port_t port)
+{
+	ipc_kobject_type_t ikot = IKOT_NONE;
+
+	if (!IP_VALID(port))
+		return IKOT_NONE;
+
+	ip_lock(port);
+	if (ip_active(port))
+		ikot = ip_kotype(port);
+	ip_unlock(port);
+
+	if (ikot != IKOT_HOST && ikot != IKOT_HOST_PRIV)
+		ikot = IKOT_NONE;
+
+	return ikot;
+}
+
+/*
+ *	task_max_priority:
+ *
+ *	Reset the max priority for a task.
+ */
+kern_return_t
+task_max_priority(
+	const ipc_port_t	host,
+	task_t			task,
+	int			max_priority,
+	boolean_t		set_priority,
+	boolean_t		change_threads)
+{
+	kern_return_t ret = KERN_SUCCESS;
+	ipc_kobject_type_t ikot_host = extract_host_type(host);
+
+	if ((ikot_host == IKOT_NONE) || (task == TASK_NULL) ||
+			invalid_pri(max_priority))
+		return KERN_INVALID_ARGUMENT;
+
+	task_lock(task);
+
+	if ((max_priority < task->max_priority) &&
+			(ikot_host != IKOT_HOST_PRIV)) {
+		task_unlock(task);
+		return KERN_NO_ACCESS;
+	}
+
+	task->max_priority = max_priority;
+	if ((max_priority > task->priority) || (set_priority == TRUE))
+		task->priority = max_priority;
+
+	if (change_threads == TRUE) {
+		thread_t	thread;
+		queue_head_t	*list;
+
+		list = &task->thread_list;
+		queue_iterate(list, thread, thread_t, thread_list) {
+			if (thread_override_max_priority(
+					thread, max_priority,
+					set_priority) != KERN_SUCCESS)
+				ret = KERN_FAILURE;
+		}
+	}
+
+	task_unlock(task);
+	return ret;
+}
diff --git a/kern/task.h b/kern/task.h
index 9521e953..a23c2d93 100644
--- a/kern/task.h
+++ b/kern/task.h
@@ -80,6 +80,7 @@ struct task {
 	/* User-visible scheduling information */
 	int		user_stop_count;	/* outstanding stops */
 	int		priority;		/* for new threads */
+	int		max_priority;		/* for task iheritance and new thrads */
 
 	/* Statistics */
 	time_value64_t	total_user_time;
diff --git a/kern/thread.c b/kern/thread.c
index 5a0989ae..739b3087 100644
--- a/kern/thread.c
+++ b/kern/thread.c
@@ -503,6 +503,7 @@ kern_return_t thread_create(
 	 */
 
 	new_thread->priority = parent_task->priority;
+	new_thread->max_priority = parent_task->max_priority;
 	if (pset->max_priority > new_thread->max_priority)
 		new_thread->max_priority = pset->max_priority;
 	if (new_thread->max_priority > new_thread->priority)
-- 
2.53.0