Subversion Repositories c0or1k

/*
 * Thread creation userspace helpers
 *
 * Copyright (C) 2009 - 2010 B Labs Ltd.
 *
 * Author: Bahadir Balban
 */
#include <l4lib/lib/thread.h>
#include <l4lib/exregs.h>
#include <l4lib/mutex.h>
#include <l4/api/errno.h>
#include <l4/api/thread.h>
#include <memcache/memcache.h>
 
void *l4_utcb_alloc(void)
{
	return mem_cache_alloc(utcb_cache);
}
 
void l4_utcb_free(void *utcb)
{
	BUG_ON(mem_cache_free(utcb_cache, utcb) < 0);
}
 
void *l4_stack_alloc(void)
{
	void *stack = mem_cache_alloc(stack_cache);
 
	/* Since it will grow downwards */
	stack += (unsigned long)STACK_SIZE;
 
	return stack;
}
 
/*
 * NOTE: may be unaligned
 */
void l4_stack_free(void *stack)
{
	/* Allocation pointer was from beginning of stack */
	stack -= (unsigned long)STACK_SIZE;
	BUG_ON(mem_cache_free(stack_cache, stack) < 0);
}
 
/*
 * Allocate and init a thread struct for same space
 */
struct l4_thread *l4_thread_init(struct l4_thread *thread)
{
	/*
	 * Allocate stack and utcb
	 */
	if (!(thread->utcb = l4_utcb_alloc()))
		return PTR_ERR(-ENOMEM);
	if (!(thread->stack = l4_stack_alloc())) {
		l4_utcb_free(thread->utcb);
		return PTR_ERR(-ENOMEM);
	}
	return thread;
}
 
void l4_thread_free(struct l4_thread *thread)
{
	struct l4_thread_list *tlist = &l4_thread_list;
 
	/* Lock the list */
	l4_mutex_lock(&tlist->lock);
 
	/* Lock the thread */
	l4_mutex_lock(&thread->lock);
 
	/* Remove the thread from its list */
	list_remove(&thread->list);
	tlist->total--;
 
	/* Unlock list */
	l4_mutex_unlock(&tlist->lock);
 
	/* Free thread's stack and utcb if they exist */
	if (thread->stack)
		l4_stack_free(thread->stack);
	if (thread->utcb)
		l4_utcb_free(thread->utcb);
 
	/* Free the thread itself */
	BUG_ON(mem_cache_free(tlist->thread_cache, thread) < 0);
}
 
/*
 * No locking version
 */
void l4_thread_free_nolock(struct l4_thread *thread)
{
	struct l4_thread_list *tlist = &l4_thread_list;
 
	/* Free thread's stack and utcb if they exist */
	if (thread->stack)
		l4_stack_free(thread->stack);
	if (thread->utcb)
		l4_utcb_free(thread->utcb);
 
	/* Free the thread itself */
	BUG_ON(mem_cache_free(tlist->thread_cache, thread) < 0);
}
 
/*
 * Destroys a child thread and reclaims its
 * stack and utcb.
 *
 * NOTE: This function is to be called with caution:
 * The destroyed child must be in a state that will
 * not compromise the system integrity, i.e. not holding
 * any locks, not in the middle of an operation.
 *
 * We usually don't know whether a synchronous destruction
 * would cause the thread to leave structures prematurely
 * (e.g. need to figure out a way of knowing if the thread
 * is holding any locks, busy, has children ...)
 */
int thread_destroy(struct l4_thread *thread)
{
	struct l4_thread_list *tlist = &l4_thread_list;
	int err;
 
	/* Lock the list */
	l4_mutex_lock(&tlist->lock);
 
	/* Lock the thread */
	l4_mutex_lock(&thread->lock);
 
	/* Remove the thread from its list */
	list_remove(&thread->list);
	tlist->total--;
 
	/* Unlock list */
	l4_mutex_unlock(&tlist->lock);
 
	/* Destroy the thread */
	if ((err = l4_thread_control(THREAD_DESTROY, &thread->ids)) < 0)
		return err;
 
	/* Reclaim l4_thread structure */
	l4_thread_free_nolock(thread);
 
	return 0;
}
 
struct l4_thread *l4_thread_alloc_init(void)
{
	struct l4_thread_list *tlist = &l4_thread_list;
	struct l4_thread *thread;
 
	if (!(thread = mem_cache_zalloc(tlist->thread_cache)))
		return PTR_ERR(-ENOMEM);
 
	link_init(&thread->list);
	l4_mutex_init(&thread->lock);
 
	if (IS_ERR(thread = l4_thread_init(thread))) {
		mem_cache_free(tlist->thread_cache, thread);
		return PTR_ERR(thread);
	}
 
	list_insert(&tlist->thread_list, &thread->list);
	tlist->total++;
 
	return thread;
}
 
/*
 * Called during initialization for setting up the
 * existing runnable thread
 */
void l4_parent_thread_init(void)
{
	struct l4_thread *thread;
	struct exregs_data exregs;
	int err;
 
	/* Allocate structures for the first thread */
	thread = l4_thread_alloc_init();
 
	/* Free the allocated stack since its unnecessary */
	l4_stack_free(thread->stack);
 
	/* Read thread ids */
	l4_getid(&thread->ids);
 
	/* Set up utcb via exregs */
	memset(&exregs, 0, sizeof(exregs));
	exregs_set_utcb(&exregs, (unsigned long)thread->utcb);
	if ((err = l4_exchange_registers(&exregs,
					 thread->ids.tid)) < 0) {
		printf("FATAL: Initialization of structures for "
		       "currently runnable thread has failed.\n"
		       "exregs err=%d\n", err);
		l4_thread_free(thread);
	}
}
 
/* For threads to exit on their own without any library maintenance */
void thread_exit(int exit_code)
{
	struct task_ids ids;
 
	/* FIXME: Find this from utcb */
	l4_getid(&ids);
	l4_thread_control(THREAD_DESTROY | exit_code, &ids);
}
 
int thread_wait(struct l4_thread *thread)
{
	int ret;
 
	/* Wait for the thread to exit */
	if ((ret = l4_thread_control(THREAD_WAIT, &thread->ids)) < 0)
		return ret;
 
	/* Claim its library structures */
	l4_thread_free(thread);
 
	/* Return zero or positive thread exit code */
	return ret;
}
 
/*
 * Create a new thread in the same address space as caller
 */
int thread_create(int (*func)(void *), void *args, unsigned int flags,
		  struct l4_thread **tptr)
{
	struct exregs_data exregs;
	struct l4_thread *thread;
	int err;
 
	/* Shared space only */
	if (!(TC_SHARE_SPACE & flags)) {
		printf("%s: Warning - This function allows only "
		       "shared space thread creation.\n",
		       __FUNCTION__);
		return -EINVAL;
	}
 
	/* Allocate a thread struct */
	if (IS_ERR(thread = l4_thread_alloc_init()))
		return (int)thread;
 
	/* Assign own space id since TC_SHARE_SPACE requires it */
	l4_getid(&thread->ids);
 
	/* Create thread in kernel */
	if ((err = l4_thread_control(THREAD_CREATE |
				     flags, &thread->ids)) < 0)
		goto out_err;
 
	/* First word of new stack is arg */
	thread->stack[-1] = (unsigned long)args;
 
	/* Second word of new stack is function address */
	thread->stack[-2] = (unsigned long)func;
 
	/* Setup new thread pc, sp, utcb */
	memset(&exregs, 0, sizeof(exregs));
	exregs_set_stack(&exregs, (unsigned long)thread->stack);
	exregs_set_utcb(&exregs, (unsigned long)thread->utcb);
	exregs_set_pc(&exregs, (unsigned long)setup_new_thread);
 
	if ((err = l4_exchange_registers(&exregs, thread->ids.tid)) < 0)
		goto out_err;
 
	/* Start the new thread, unless specified otherwise */
	if (!(flags & TC_NOSTART))
		if ((err = l4_thread_control(THREAD_RUN,
					     &thread->ids)) < 0)
			goto out_err;
 
	/* Set pointer to thread structure */
	*tptr = thread;
 
	return 0;
 
out_err:
	l4_thread_free(thread);
	return err;
}