diff --git a/include/mango/sched.h b/include/mango/sched.h
index 632c19e..9363251 100644
--- a/include/mango/sched.h
+++ b/include/mango/sched.h
@@ -76,13 +76,16 @@ struct task {
 	struct object t_base;
 
 	struct task *t_parent;
-	unsigned int t_id;
+	long t_id;
 	enum task_state t_state;
 	char t_name[TASK_NAME_MAX];
 
 	pmap_t t_pmap;
 
 	struct btree_node t_tasklist;
+	struct queue_entry t_child_entry;
+
+	size_t t_next_thread_id;
 	struct queue t_threads;
 	struct queue t_children;
 };
@@ -105,7 +108,7 @@ struct thread {
 
 	struct runqueue *tr_rq;
 
-	struct queue_entry tr_threads;
+	struct queue_entry tr_parent_entry;
 	struct queue_entry tr_rqentry;
 
 	struct vm_page *tr_kstack;
@@ -182,7 +185,7 @@ static inline struct task *task_ref(struct task *task)
 }
 static inline void task_unref(struct task *task)
 {
-	object_deref(&task->t_base);
+	object_unref(&task->t_base);
 }
 extern struct task *task_from_pid(unsigned int pid);
 extern struct task *kernel_task(void);
@@ -199,17 +202,7 @@ extern void schedule_thread_on_cpu(struct thread *thr);
 extern void start_charge_period(void);
 extern void end_charge_period(void);
 
-static inline void task_lock_irqsave(struct task *task, unsigned long *flags)
-{
-	object_lock_irqsave(&task->t_base, flags);
-}
-
-static inline void task_unlock_irqrestore(
-	struct task *task,
-	unsigned long flags)
-{
-	object_unlock_irqrestore(&task->t_base, flags);
-}
+DEFINE_OBJECT_LOCK_FUNCTION(task, t_base)
 
 extern struct thread *thread_alloc(void);
 extern kern_status_t thread_init(struct thread *thr, uintptr_t ip);
diff --git a/sched/core.c b/sched/core.c
index e29a652..f20b96d 100644
--- a/sched/core.c
+++ b/sched/core.c
@@ -39,11 +39,11 @@ kern_status_t sched_init(void)
 
 	struct thread *this_thread = QUEUE_CONTAINER(
 		struct thread,
-		tr_threads,
+		tr_parent_entry,
 		queue_first(&kernel_task()->t_threads));
 	struct thread *idle_thread = QUEUE_CONTAINER(
 		struct thread,
-		tr_threads,
+		tr_parent_entry,
 		queue_first(&idle_task()->t_threads));
 
 	struct cpu_data *this_cpu = get_this_cpu();
diff --git a/sched/task.c b/sched/task.c
index 4cd26a5..cad2a19 100644
--- a/sched/task.c
+++ b/sched/task.c
@@ -80,9 +80,9 @@ kern_status_t setup_kernel_task(void)
 		return KERN_NO_MEMORY;
 	}
 
-	__kernel_task->t_id = 0;
-	__kernel_task->t_pmap = get_kernel_pmap();
+	__kernel_task->t_id = -1;
 	__kernel_task->t_state = TASK_RUNNING;
+	__kernel_task->t_pmap = get_kernel_pmap();
 
 	snprintf(
 		__kernel_task->t_name,
@@ -100,7 +100,7 @@ kern_status_t setup_kernel_task(void)
 	task_lock_irqsave(__kernel_task, &flags);
 	queue_push_back(
 		&__kernel_task->t_threads,
-		&kernel_thread->tr_threads);
+		&kernel_thread->tr_parent_entry);
 	task_unlock_irqrestore(__kernel_task, flags);
 
 	spin_lock_irqsave(&task_list_lock, &flags);
@@ -120,15 +120,15 @@ kern_status_t setup_idle_task(void)
 	unsigned long flags;
 	task_lock_irqsave(__idle_task, &flags);
 
-	__idle_task->t_id = (unsigned int)-1;
-	__idle_task->t_pmap = get_kernel_pmap();
+	__idle_task->t_id = -2;
 	__idle_task->t_state = TASK_RUNNING;
+	__idle_task->t_pmap = get_kernel_pmap();
 
 	snprintf(__idle_task->t_name, sizeof __idle_task->t_name, "idle");
 
 	struct thread *idle_thread = thread_alloc();
 	if (!idle_thread) {
-		task_deref(__idle_task);
+		task_unref(__idle_task);
 		__idle_task = NULL;
 		return KERN_NO_MEMORY;
 	}
@@ -137,7 +137,7 @@ kern_status_t setup_idle_task(void)
 	idle_thread->tr_parent = __idle_task;
 	thread_init(idle_thread, (uintptr_t)idle);
 
-	queue_push_back(&__idle_task->t_threads, &idle_thread->tr_threads);
+	queue_push_back(&__idle_task->t_threads, &idle_thread->tr_parent_entry);
 
 	task_unlock_irqrestore(__idle_task, flags);
 
@@ -157,7 +157,6 @@ struct task *task_alloc(void)
 	}
 
 	struct task *t = TASK_CAST(task_obj);
-	memset(t, 0x00, sizeof *t);
 	return t;
 }
 
diff --git a/sched/thread.c b/sched/thread.c
index 251423f..2486e9e 100644
--- a/sched/thread.c
+++ b/sched/thread.c
@@ -93,7 +93,7 @@ struct thread *create_kernel_thread(void (*fn)(void))
 
 	unsigned long flags;
 	task_lock_irqsave(kernel, &flags);
-	queue_push_back(&kernel->t_threads, &thr->tr_threads);
+	queue_push_back(&kernel->t_threads, &thr->tr_parent_entry);
 	task_unlock_irqrestore(kernel, flags);
 
 	schedule_thread_on_cpu(thr);
@@ -115,7 +115,7 @@ struct thread *create_idle_thread(void)
 
 	unsigned long flags;
 	task_lock_irqsave(idle, &flags);
-	queue_push_back(&idle->t_threads, &thr->tr_threads);
+	queue_push_back(&idle->t_threads, &thr->tr_parent_entry);
 	task_unlock_irqrestore(idle, flags);
 
 	return thr;