Subversion Repositories c0or1k

/*
 * Some ktcb related data
 *
 * Copyright (C) 2007 - 2009 Bahadir Balban
 */
#include <l4/generic/tcb.h>
#include <l4/generic/space.h>
#include <l4/generic/scheduler.h>
#include <l4/generic/container.h>
#include <l4/generic/preempt.h>
#include <l4/generic/space.h>
#include <l4/lib/idpool.h>
#include <l4/api/ipc.h>
#include <l4/api/kip.h>
#include <l4/api/errno.h>
#include INC_ARCH(exception.h)
#include INC_SUBARCH(mm.h)
#include INC_GLUE(memory.h)
#include INC_GLUE(mapping.h)
#include INC_SUBARCH(mmu_ops.h)
 
void init_ktcb_list(struct ktcb_list *ktcb_list)
{
	memset(ktcb_list, 0, sizeof(*ktcb_list));
	spin_lock_init(&ktcb_list->list_lock);
	link_init(&ktcb_list->list);
}
 
void tcb_init(struct ktcb *new)
{
 
	link_init(&new->task_list);
	mutex_init(&new->thread_control_lock);
 
	spin_lock_init(&new->thread_lock);
 
	cap_list_init(&new->cap_list);
 
	/* Initialise task's scheduling state and parameters. */
	sched_init_task(new, TASK_PRIO_NORMAL);
 
	/* Initialise ipc waitqueues */
	spin_lock_init(&new->waitlock);
	waitqueue_head_init(&new->wqh_send);
	waitqueue_head_init(&new->wqh_recv);
	waitqueue_head_init(&new->wqh_pager);
}
 
struct ktcb *tcb_alloc_init(l4id_t cid)
{
	struct ktcb *tcb;
	struct task_ids ids;
 
	if (!(tcb = alloc_ktcb()))
		return 0;
 
	ids.tid = id_new(&kernel_resources.ktcb_ids);
	ids.tid |= TASK_CID_MASK & (cid << TASK_CID_SHIFT);
	ids.tgid = L4_NILTHREAD;
	ids.spid = L4_NILTHREAD;
 
	set_task_ids(tcb, &ids);
 
	tcb_init(tcb);
 
	return tcb;
}
 
void tcb_delete(struct ktcb *tcb)
{
	struct ktcb *pager, *acc_task;
 
	/* Sanity checks first */
	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(tcb->affinity != current->affinity);
	BUG_ON(tcb->state != TASK_INACTIVE);
	BUG_ON(!list_empty(&tcb->rq_list));
	BUG_ON(tcb->rq);
	BUG_ON(tcb == current);
	BUG_ON(tcb->nlocks);
	BUG_ON(tcb->waiting_on);
	BUG_ON(tcb->wq);
 
	/* Remove from zombie list */
	list_remove(&tcb->task_list);
 
	/* Determine task to account deletions */
	if (!(pager = tcb_find(tcb->pagerid)))
		acc_task = current;
	else
		acc_task = pager;
 
	/*
	 * NOTE: This protects single threaded space
	 * deletion against space modification.
	 *
	 * If space deletion were multi-threaded, list
	 * traversal would be needed to ensure list is
	 * still there.
	 */
	mutex_lock(&tcb->container->space_list.lock);
	mutex_lock(&tcb->space->lock);
	BUG_ON(--tcb->space->ktcb_refs < 0);
 
	/* No refs left for the space, delete it */
	if (tcb->space->ktcb_refs == 0) {
		address_space_remove(tcb->space, tcb->container);
		mutex_unlock(&tcb->space->lock);
		address_space_delete(tcb->space, acc_task);
		mutex_unlock(&tcb->container->space_list.lock);
	} else {
		mutex_unlock(&tcb->space->lock);
		mutex_unlock(&tcb->container->space_list.lock);
	}
 
	/* Clear container id part */
	tcb->tid &= ~TASK_CID_MASK;
 
	/* Deallocate tcb ids */
	id_del(&kernel_resources.ktcb_ids, tcb->tid);
 
	/* Free the tcb */
	free_ktcb(tcb, acc_task);
}
 
struct ktcb *tcb_find_by_space(l4id_t spid)
{
	struct ktcb *task;
 
	spin_lock(&curcont->ktcb_list.list_lock);
	list_foreach_struct(task, &curcont->ktcb_list.list, task_list) {
		if (task->space->spid == spid) {
			spin_unlock(&curcont->ktcb_list.list_lock);
			return task;
		}
	}
	spin_unlock(&curcont->ktcb_list.list_lock);
	return 0;
}
 
struct ktcb *container_find_tcb(struct container *c, l4id_t tid)
{
	struct ktcb *task;
 
	spin_lock(&c->ktcb_list.list_lock);
	list_foreach_struct(task, &c->ktcb_list.list, task_list) {
		if (task->tid == tid) {
			spin_unlock(&c->ktcb_list.list_lock);
			return task;
		}
	}
	spin_unlock(&c->ktcb_list.list_lock);
	return 0;
}
 
struct ktcb *container_find_lock_tcb(struct container *c, l4id_t tid)
{
	struct ktcb *task;
 
	spin_lock(&c->ktcb_list.list_lock);
	list_foreach_struct(task, &c->ktcb_list.list, task_list) {
		if (task->tid == tid) {
			spin_lock(&task->thread_lock);
			spin_unlock(&c->ktcb_list.list_lock);
			return task;
		}
	}
	spin_unlock(&c->ktcb_list.list_lock);
	return 0;
}
 
/*
 * Threads are the only resource where inter-container searches are
 * allowed. This is because on other containers, only threads can be
 * targeted for operations. E.g. ipc, sharing memory. Currently you
 * can't reach a space, a mutex, or any other resouce on another
 * container.
 */
struct ktcb *tcb_find(l4id_t tid)
{
	struct container *c;
 
	if (current->tid == tid)
		return current;
 
	if (tid_to_cid(tid) == curcont->cid) {
		return container_find_tcb(curcont, tid);
	} else {
	       	if (!(c = container_find(&kernel_resources,
					 tid_to_cid(tid))))
			return 0;
		else
			return container_find_tcb(c, tid);
	}
}
 
struct ktcb *tcb_find_lock(l4id_t tid)
{
	struct container *c;
 
	if (current->tid == tid) {
		spin_lock(&current->thread_lock);
		return current;
	}
 
	if (tid_to_cid(tid) == curcont->cid) {
		return container_find_lock_tcb(curcont, tid);
	} else {
	       	if (!(c = container_find(&kernel_resources,
					 tid_to_cid(tid))))
			return 0;
		else
			return container_find_lock_tcb(c, tid);
	}
}
 
void ktcb_list_add(struct ktcb *new, struct ktcb_list *ktcb_list)
{
	spin_lock(&ktcb_list->list_lock);
	BUG_ON(!list_empty(&new->task_list));
	BUG_ON(!++ktcb_list->count);
	list_insert(&new->task_list, &ktcb_list->list);
	spin_unlock(&ktcb_list->list_lock);
}
 
void tcb_add(struct ktcb *new)
{
	struct container *c = new->container;
 
	spin_lock(&c->ktcb_list.list_lock);
	BUG_ON(!list_empty(&new->task_list));
	BUG_ON(!++c->ktcb_list.count);
	list_insert(&new->task_list, &c->ktcb_list.list);
	spin_unlock(&c->ktcb_list.list_lock);
}
 
/*
 * Its important that this is per-cpu. This is
 * because it must be guaranteed that the task
 * is not runnable. Idle task on that cpu guarantees it.
 */
void tcb_delete_zombies(void)
{
	struct ktcb *zombie, *n;
	struct ktcb_list *ktcb_list =
		&per_cpu(kernel_resources.zombie_list);
 
	/* Traverse the per-cpu zombie list */
	spin_lock(&ktcb_list->list_lock);
	list_foreach_removable_struct(zombie, n,
				      &ktcb_list->list,
				      task_list)
		/* Delete all zombies one by one */
		tcb_delete(zombie);
	spin_unlock(&ktcb_list->list_lock);
}
 
 
/*
 * It's enough to lock list and thread without
 * traversing the list, because we're only
 * protecting against thread modification.
 * Deletion is a single-threaded operation
 */
void tcb_remove(struct ktcb *task)
{
	/* Lock list */
	spin_lock(&curcont->ktcb_list.list_lock);
	BUG_ON(list_empty(&task->task_list));
	BUG_ON(--curcont->ktcb_list.count < 0);
	spin_lock(&task->thread_lock);
 
	list_remove_init(&task->task_list);
	spin_unlock(&curcont->ktcb_list.list_lock);
	spin_unlock(&task->thread_lock);
}
 
void ktcb_list_remove(struct ktcb *new, struct ktcb_list *ktcb_list)
{
	spin_lock(&ktcb_list->list_lock);
	BUG_ON(list_empty(&new->task_list));
	BUG_ON(--ktcb_list->count < 0);
	list_remove(&new->task_list);
	spin_unlock(&ktcb_list->list_lock);
}
 
/* Offsets for ktcb fields that are accessed from assembler */
unsigned int need_resched_offset = offsetof(struct ktcb, ts_need_resched);
unsigned int syscall_regs_offset = offsetof(struct ktcb, syscall_regs);
 
/*
 * Every thread has a unique utcb region that is mapped to its address
 * space as its context is loaded. The utcb region is a function of
 * this mapping and its offset that is reached via the KIP UTCB pointer
 */
void task_update_utcb(struct ktcb *task)
{
	arch_update_utcb(task->utcb_address);
}
 
/*
 * Checks whether a task's utcb is currently accessible by the kernel.
 * Returns an error if its not paged in yet, maps a non-current task's
 * utcb to current task for kernel-only access if it is unmapped.
 *
 * UTCB Mappings: The design is that each task maps its utcb with user
 * access, and any other utcb is mapped with kernel-only access privileges
 * upon an ipc that requires the kernel to access that utcb, in other
 * words foreign utcbs are mapped lazily.
 */
int tcb_check_and_lazy_map_utcb(struct ktcb *task, int page_in)
{
	unsigned int phys;
	int ret;
 
	if (!task->utcb_address)
		return -ENOUTCB;
 
	/*
	 * If task == current && not mapped && page_in,
	 * 	page-in, if not return -EFAULT
	 * If task == current && not mapped && !page_in,
	 * 	return -EFAULT
	 * If task != current && not mapped,
	 * 	return -EFAULT since can't page-in on behalf of it.
	 * If task != current && task mapped,
	 * 	but mapped != current mapped, map it, return 0
	 * If task != current && task mapped,
	 * 	but mapped == current mapped, return 0
	 */
 
	/* FIXME:
	 *
	 * Do the check_access part without distinguishing current/non-current
	 * Do the rest (i.e. mapping the value to the current table) only if the utcb is non-current
	 */
 
	if (current == task) {
		/* Check own utcb, if not there, page it in */
		if ((ret = check_access(task->utcb_address, UTCB_SIZE,
					MAP_KERN_RW, page_in)) < 0)
			return -EFAULT;
		else
			return 0;
	} else {
		/* Check another's utcb, but don't try to map in */
		if ((ret = check_access_task(task->utcb_address,
					     UTCB_SIZE,
					     MAP_KERN_RW, 0,
					     task)) < 0) {
			return -EFAULT;
		} else {
			/*
			 * Task has it mapped, map it to self
			 * unless they're identical
			 */
			if ((phys =
			     virt_to_phys_by_pgd(TASK_PGD(task),
						 task->utcb_address)) !=
			     virt_to_phys_by_pgd(TASK_PGD(current),
						 task->utcb_address)) {
				/*
				 * We have none or an old reference.
				 * Update it with privileged flags,
				 * so that only kernel can access.
				 */
				add_mapping_pgd(phys, page_align(task->utcb_address),
						page_align_up(UTCB_SIZE),
						MAP_KERN_RW,
						TASK_PGD(current));
			}
			BUG_ON(!phys);
		}
	}
	return 0;
}