Subversion Repositories c0or1k

/*
 * Thread related system calls.
 *
 * Copyright (C) 2007 Bahadir Balban
 */
#include <l4/generic/scheduler.h>
#include <l4/generic/container.h>
#include <l4/api/thread.h>
#include <l4/api/syscall.h>
#include <l4/api/errno.h>
#include <l4/generic/tcb.h>
#include <l4/lib/idpool.h>
#include <l4/lib/mutex.h>
#include <l4/lib/wait.h>
#include <l4/generic/resource.h>
#include <l4/generic/capability.h>
#include INC_ARCH(asm.h)
#include INC_SUBARCH(mm.h)
#include INC_GLUE(mapping.h)
 
int sys_thread_switch(void)
{
	schedule();
	return 0;
}
 
/*
 * This signals a thread so that the thread stops what it is
 * doing, and take action on the signal provided. Currently this
 * may be a suspension or an exit signal.
 */
int thread_signal(struct ktcb *task, unsigned int flags,
		  unsigned int task_state)
{
	int ret = 0;
 
	if (task->state == task_state)
		return 0;
 
	/* Signify we want to suspend the thread */
	task->flags |= flags;
 
	/* Wake it up if it's sleeping */
	wake_up_task(task, WAKEUP_INTERRUPT | WAKEUP_SYNC);
 
	/* Wait until task switches to desired state */
	WAIT_EVENT(&task->wqh_pager,
		   task->state == task_state, ret);
 
	return ret;
}
 
int thread_suspend(struct ktcb *task)
{
	return thread_signal(task, TASK_SUSPENDING, TASK_INACTIVE);
}
 
int thread_exit(struct ktcb *task)
{
	return thread_signal(task, TASK_SUSPENDING, TASK_INACTIVE);
}
 
static inline int task_is_child(struct ktcb *task)
{
	return (((task) != current) &&
		((task)->pagerid == current->tid));
}
 
int thread_destroy_child(struct ktcb *task)
{
	/* Wait until thread exits */
	thread_exit(task);
 
	/* Hint scheduler that an exit occured */
	current->flags |= TASK_EXITED;
 
	/* Now remove it atomically */
	tcb_remove(task);
 
	/* Wake up waiters that arrived before removing */
	wake_up_all(&task->wqh_send, WAKEUP_INTERRUPT);
	wake_up_all(&task->wqh_recv, WAKEUP_INTERRUPT);
 
	BUG_ON(task->wqh_pager.sleepers > 0);
	BUG_ON(task->state != TASK_INACTIVE);
 
	/* Place the task on the zombie queue for its cpu */
	ktcb_list_add(task, &per_cpu_byid(kernel_resources.zombie_list,
					  task->affinity));
 
	return 0;
}
 
int thread_destroy_children(void)
{
	struct ktcb *task, *n;
 
	spin_lock(&curcont->ktcb_list.list_lock);
	list_foreach_removable_struct(task, n,
				      &curcont->ktcb_list.list,
				      task_list) {
		if (task_is_child(task)) {
			spin_unlock(&curcont->ktcb_list.list_lock);
			thread_destroy_child(task);
			spin_lock(&curcont->ktcb_list.list_lock);
		}
	}
	spin_unlock(&curcont->ktcb_list.list_lock);
	return 0;
 
}
 
void thread_destroy_self(unsigned int exit_code)
{
	/* Destroy all children first */
	thread_destroy_children();
 
	/* If self-paged, finish everything except deletion */
	if (current->tid == current->pagerid) {
		/* Remove self safe against ipc */
		tcb_remove(current);
 
		/* Wake up any waiters queued up before removal */
		wake_up_all(&current->wqh_send, WAKEUP_INTERRUPT);
		wake_up_all(&current->wqh_recv, WAKEUP_INTERRUPT);
 
		/* Move capabilities to current cpu idle task */
		cap_list_move(&per_cpu(scheduler).idle_task->cap_list,
			      &current->cap_list);
 
		/* Place self on the per-cpu zombie queue */
		ktcb_list_add(current, &per_cpu(kernel_resources.zombie_list));
	}
 
	/*
	 * Both child and a self-paging would set exit
	 * code and quit the scheduler
	 */
	current->exit_code = exit_code;
 
	/*
	 * Hint scheduler that an exit has occured
	 */
	current->flags |= TASK_EXITED;
	sched_suspend_sync();
}
 
int thread_wait(struct ktcb *task)
{
	unsigned int exit_code;
	int ret;
 
	// printk("%s: (%d) for (%d)\n", __FUNCTION__, current->tid, task->tid);
 
	/* Wait until task switches to desired state */
	WAIT_EVENT(&task->wqh_pager,
		   task->state == TASK_INACTIVE, ret);
 
	/* Return if interrupted by async event */
	if (ret < 0)
		return ret;
 
	/* Now remove it safe against ipc */
	tcb_remove(task);
 
	/* Wake up waiters that arrived before removing */
	wake_up_all(&task->wqh_send, WAKEUP_INTERRUPT);
	wake_up_all(&task->wqh_recv, WAKEUP_INTERRUPT);
 
	BUG_ON(task->wqh_pager.sleepers > 0);
	BUG_ON(task->state != TASK_INACTIVE);
 
	/* Obtain exit code */
	exit_code = (int)task->exit_code;
 
	/* Place it on the zombie queue */
	ktcb_list_add(task,
		      &per_cpu_byid(kernel_resources.zombie_list,
				    task->affinity));
 
	return exit_code;
}
 
int thread_destroy(struct ktcb *task, unsigned int exit_code)
{
	// printk("%s: (%d) for (%d)\n", __FUNCTION__, current->tid, task->tid);
 
	exit_code &= THREAD_EXIT_MASK;
 
	if (task_is_child(task))
		return thread_destroy_child(task);
	else if (task == current)
		thread_destroy_self(exit_code);
	else
		BUG();
 
	return 0;
}
 
int arch_clear_thread(struct ktcb *tcb)
{
	/* Remove from the global list */
	tcb_remove(tcb);
 
	/* Sanity checks */
	BUG_ON(!is_page_aligned(tcb));
	BUG_ON(tcb->wqh_pager.sleepers > 0);
	BUG_ON(tcb->wqh_send.sleepers > 0);
	BUG_ON(tcb->wqh_recv.sleepers > 0);
	BUG_ON(!list_empty(&tcb->task_list));
	BUG_ON(!list_empty(&tcb->rq_list));
	BUG_ON(tcb->rq);
	BUG_ON(tcb->nlocks);
	BUG_ON(tcb->waiting_on);
	BUG_ON(tcb->wq);
 
	/* Reinitialise the context */
	memset(&tcb->context, 0, sizeof(tcb->context));
	tcb->context.spsr = ARM_MODE_USR;
 
	/* Clear the page tables */
	remove_mapping_pgd_all_user(TASK_PGD(tcb));
 
	/* Reinitialize all other fields */
	tcb_init(tcb);
 
	/* Add back to global list */
	tcb_add(tcb);
 
	return 0;
}
 
int thread_recycle(struct ktcb *task)
{
	int ret;
 
	if ((ret = thread_suspend(task)) < 0)
		return ret;
 
	/*
	 * If there are any sleepers on any of the task's
	 * waitqueues, we need to wake those tasks up.
	 */
	wake_up_all(&task->wqh_send, 0);
	wake_up_all(&task->wqh_recv, 0);
 
	/*
	 * The thread cannot have a pager waiting for it
	 * since we ought to be the pager.
	 */
	BUG_ON(task->wqh_pager.sleepers > 0);
 
	/* Clear the task's tcb */
	arch_clear_thread(task);
 
	return 0;
}
 
/* Runs a thread for the first time */
int thread_start(struct ktcb *task)
{
	if (!mutex_trylock(&task->thread_control_lock))
		return -EAGAIN;
 
	/* Notify scheduler of task resume */
	sched_resume_async(task);
 
	/* Release lock and return */
	mutex_unlock(&task->thread_control_lock);
 
	return 0;
}
 
int arch_setup_new_thread(struct ktcb *new, struct ktcb *orig,
			  unsigned int flags)
{
	/* New threads just need their mode set up */
	if (flags & TC_NEW_SPACE) {
		BUG_ON(orig);
		new->context.spsr = ARM_MODE_USR;
		return 0;
	}
 
	BUG_ON(!orig);
 
	/* If original has no syscall context yet, don't copy */
	if (!orig->syscall_regs)
		return 0;
 
	/*
	 * For duplicated threads pre-syscall context is saved on
	 * the kernel stack. We copy this context of original
	 * into the duplicate thread's current context structure,
	 *
	 * No locks needed as the thread is not known to the system yet.
	 */
	BUG_ON(!(new->context.spsr = orig->syscall_regs->spsr)); /* User mode */
	new->context.r0 = orig->syscall_regs->r0;
	new->context.r1 = orig->syscall_regs->r1;
	new->context.r2 = orig->syscall_regs->r2;
	new->context.r3 = orig->syscall_regs->r3;
	new->context.r4 = orig->syscall_regs->r4;
	new->context.r5 = orig->syscall_regs->r5;
	new->context.r6 = orig->syscall_regs->r6;
	new->context.r7 = orig->syscall_regs->r7;
	new->context.r8 = orig->syscall_regs->r8;
	new->context.r9 = orig->syscall_regs->r9;
	new->context.r10 = orig->syscall_regs->r10;
	new->context.r11 = orig->syscall_regs->r11;
	new->context.r12 = orig->syscall_regs->r12;
	new->context.sp = orig->syscall_regs->sp_usr;
	/* Skip lr_svc since it's not going to be used */
	new->context.pc = orig->syscall_regs->lr_usr;
 
	/* Distribute original thread's ticks into two threads */
	new->ticks_left = (orig->ticks_left + 1) >> 1;
	if (!(orig->ticks_left >>= 1))
		orig->ticks_left = 1;
 
	return 0;
}
 
static DECLARE_SPINLOCK(task_select_affinity_lock);
static unsigned int cpu_rr_affinity;
 
/* Select which cpu to place the new task in round-robin fashion */
void thread_setup_affinity(struct ktcb *task)
{
	spin_lock(&task_select_affinity_lock);
	task->affinity = cpu_rr_affinity;
 
	//printk("Set up thread %d affinity=%d\n",
	//       task->tid, task->affinity);
	cpu_rr_affinity++;
	if (cpu_rr_affinity >= CONFIG_NCPU)
		cpu_rr_affinity = 0;
 
	spin_unlock(&task_select_affinity_lock);
}
 
static inline void
thread_setup_new_ids(struct task_ids *ids, unsigned int flags,
		     struct ktcb *new, struct ktcb *orig)
{
	if (flags & TC_SHARE_GROUP)
		new->tgid = orig->tgid;
	else
		new->tgid = new->tid;
 
	/* Update ids to be returned back to caller */
	ids->tid = new->tid;
	ids->tgid = new->tgid;
}
 
int thread_setup_space(struct ktcb *tcb, struct task_ids *ids, unsigned int flags)
{
	struct address_space *space, *new;
	int ret = 0;
 
	if (flags & TC_SHARE_SPACE) {
		mutex_lock(&curcont->space_list.lock);
		if (!(space = address_space_find(ids->spid))) {
			mutex_unlock(&curcont->space_list.lock);
			ret = -ESRCH;
			goto out;
		}
		mutex_lock(&space->lock);
		mutex_unlock(&curcont->space_list.lock);
		address_space_attach(tcb, space);
		mutex_unlock(&space->lock);
	}
	else if (flags & TC_COPY_SPACE) {
		mutex_lock(&curcont->space_list.lock);
		if (!(space = address_space_find(ids->spid))) {
			mutex_unlock(&curcont->space_list.lock);
			ret = -ESRCH;
			goto out;
		}
		mutex_lock(&space->lock);
		if (IS_ERR(new = address_space_create(space))) {
			mutex_unlock(&curcont->space_list.lock);
			mutex_unlock(&space->lock);
			ret = (int)new;
			goto out;
		}
		mutex_unlock(&space->lock);
		ids->spid = new->spid; 	/* Return newid to caller */
		address_space_attach(tcb, new);
		address_space_add(new);
		mutex_unlock(&curcont->space_list.lock);
	}
	else if (flags & TC_NEW_SPACE) {
		if (IS_ERR(new = address_space_create(0))) {
			ret = (int)new;
			goto out;
		}
		/* New space id to be returned back to caller */
		ids->spid = new->spid;
		address_space_attach(tcb, new);
		mutex_lock(&curcont->space_list.lock);
		address_space_add(new);
		mutex_unlock(&curcont->space_list.lock);
	}
 
out:
	return ret;
}
 
int thread_create(struct task_ids *ids, unsigned int flags)
{
	struct ktcb *new;
	struct ktcb *orig = 0;
	int err;
 
	/* Clear flags to just include creation flags */
	flags &= THREAD_CREATE_MASK;
 
	/* Can't have multiple space directives in flags */
	if ((flags & TC_SHARE_SPACE
	     & TC_COPY_SPACE & TC_NEW_SPACE) || !flags)
		return -EINVAL;
 
	/* Must have one space flag */
	if ((flags & THREAD_SPACE_MASK) == 0)
		return -EINVAL;
 
	/* Can't request shared utcb or tgid without shared space */
	if (!(flags & TC_SHARE_SPACE)) {
		if ((flags & TC_SHARE_UTCB) ||
		    (flags & TC_SHARE_GROUP)) {
			return -EINVAL;
		}
	}
 
	if (!(new = tcb_alloc_init(curcont->cid)))
		return -ENOMEM;
 
	/* Set up new thread space by using space id and flags */
	if ((err = thread_setup_space(new, ids, flags)) < 0)
		goto out_err;
 
	/* Obtain parent thread if there is one */
	if (flags & TC_SHARE_SPACE || flags & TC_COPY_SPACE) {
		if (!(orig = tcb_find(ids->tid))) {
			err = -EINVAL;
			goto out_err;
		}
	}
 
	/* Set creator as pager */
	new->pagerid = current->tid;
 
	/* Setup container-generic fields from current task */
	new->container = current->container;
 
	/*
	 * Set up cpu affinity.
	 *
	 * This is the default setting, it may be changed
	 * by a subsequent exchange_registers call
	 */
	thread_setup_affinity(new);
 
	/* Set up new thread context by using parent ids and flags */
	thread_setup_new_ids(ids, flags, new, orig);
 
	arch_setup_new_thread(new, orig, flags);
 
	tcb_add(new);
 
	//printk("%s: %d created: %d, %d, %d \n",
	//       __FUNCTION__, current->tid, ids->tid,
	//       ids->tgid, ids->spid);
 
	return 0;
 
out_err:
	/* Pre-mature tcb needs freeing by free_ktcb */
	free_ktcb(new, current);
	return err;
}
 
/*
 * Creates, destroys and modifies threads. Also implicitly creates an address
 * space for a thread that doesn't already have one, or destroys it if the last
 * thread that uses it is destroyed.
 */
int sys_thread_control(unsigned int flags, struct task_ids *ids)
{
	struct ktcb *task = 0;
	int err, ret = 0;
 
	if ((err = check_access((unsigned long)ids, sizeof(*ids),
				MAP_USR_RW, 1)) < 0)
		return err;
 
	if ((flags & THREAD_ACTION_MASK) != THREAD_CREATE) {
		if (!(task = tcb_find(ids->tid)))
			return -ESRCH;
 
		/*
		 * Tasks may only operate on their children. They may
		 * also destroy themselves or any children.
		 */
		if ((flags & THREAD_ACTION_MASK) == THREAD_DESTROY &&
		    !task_is_child(task) && task != current)
			return -EPERM;
		if ((flags & THREAD_ACTION_MASK) != THREAD_DESTROY
		    && !task_is_child(task))
			return -EPERM;
	}
 
	if ((err = cap_thread_check(task, flags, ids)) < 0)
		return err;
 
	switch (flags & THREAD_ACTION_MASK) {
	case THREAD_CREATE:
		ret = thread_create(ids, flags);
		break;
	case THREAD_RUN:
		ret = thread_start(task);
		break;
	case THREAD_SUSPEND:
		ret = thread_suspend(task);
		break;
	case THREAD_DESTROY:
		ret = thread_destroy(task, flags);
		break;
	case THREAD_RECYCLE:
		ret = thread_recycle(task);
		break;
	case THREAD_WAIT:
		ret = thread_wait(task);
		break;
 
	default:
		ret = -EINVAL;
	}
 
	return ret;
}