Subversion Repositories c0or1k

/*
 * Some minimal tests for SMP functionality
 *
 * Copyright (C) 2010 B Labs Ltd.
 *
 * Author: Bahadir Balban
 */
#include <l4lib/exregs.h>
#include <l4lib/lib/thread.h>
#include <stdio.h>
#include <string.h>
#include <tests.h>
 
static int new_thread_func(void *args)
{
	struct exregs_data exregs;
	struct task_ids ids;
	int err;
 
	l4_getid(&ids);
 
#if 0
	memset(&exregs, 0, sizeof(exregs));
	exregs_set_read(&exregs);
	if ((err = l4_exchange_registers(&exregs,
					 ids.tid)) < 0) {
		printf("SMP test: Exregs call failed on %s\n",
		       __FUNCTION__);
	}
 
	dbg_printf("New thread running successfully on cpu %d "
		   "tid=%d. Exiting...\n", self_tid(),
		   exregs.cpu_affinity);
#endif
 
	dbg_printf("SMP:New thread running successfully"
		   "tid=%d. Exiting...\n", self_tid());
 
	return 0;
}
 
/*
 * Create 2 threads on different cpus and run them.
 *
 * Parent then destroys the child. Parent and child
 * are on different cpus.
 */
int test_smp_two_threads(void)
{
	struct exregs_data exregs;
	struct l4_thread *thread;
	int err, err2;
 
	dbg_printf("%s: Creating a new thread\n", __FUNCTION__);
	/*
	 * Create new thread but don't start it
	 */
	if ((err = thread_create(new_thread_func, 0,
				 TC_SHARE_SPACE | TC_NOSTART,
				 &thread)) < 0) {
		dbg_printf("THREAD_CREATE failed. "
			   "err=%d\n", err);
		return err;
	}
#if 0
	dbg_printf("%s: Setting child affinity to %d\n", __FUNCTION__, 1);
	/*
	 * Set its cpu affinity to cpu = 1
	 */
	memset(&exregs, 0, sizeof(exregs));
	exregs_set_affinity(&exregs, 1);
 
	/* Write to affinity field */
	if ((err = l4_exchange_registers(&exregs,
					 thread->ids.tid)) < 0) {
		printf("%s: Exregs on setting cpu affinity "
		       "failed on newly created thread. err=%d\n",
		       __FUNCTION__, err);
		goto out_err;
	}
 
	dbg_printf("%s: Running child on other cpu\n", __FUNCTION__);
#endif
	/* Start the thread */
	l4_thread_control(THREAD_RUN, &thread->ids);
 
	dbg_printf("%s: Waiting on child\n", __FUNCTION__);
	/* Wait on the thread */
	if ((err = thread_wait(thread)) < 0) {
		dbg_printf("THREAD_WAIT failed. "
			   "err=%d\n", err);
		goto out_err;
	} else {
		dbg_printf("Thread %d exited successfully. ret=%d\n",
			   thread->ids.tid, err);
	}
 
	dbg_printf("%s: Child destroyed successfully\n", __FUNCTION__);
	return 0;
 
out_err:
	/*
	 * Destroy the thread from parent
	 */
	if ((err2 = thread_destroy(thread)) < 0) {
		dbg_printf("THREAD_DESTROY failed. "
			   "err=%d\n", err2);
		return err2;
	}
	return err;
}
 
int test_smp_two_spaces(void)
{
	return 0;
}
 
int test_smp_ipc(void)
{
	return 0;
}
 
#if defined (CONFIG_SMP)
int test_smp(void)
{
	int err;
 
	if ((err = test_smp_two_threads()) < 0)
		return err;
 
	if ((err = test_smp_two_spaces()) < 0)
		return err;
 
	if ((err = test_smp_ipc()) < 0)
		return err;
 
	return 0;
}
#else /* Not CONFIG_SMP */
 
int test_smp(void)
{
	return 0;
}
#endif /* Endif */