Subversion Repositories c0or1k

/*

 * Test l4_thread_control system call.

 *

 * Copyright (C) 2010 B Labs Ltd.

 *

 * Author: Bahadir Balban

 */

#include <l4lib/lib/thread.h>

#include <stdio.h>

#include <tests.h>

/*

 * A secondary thread that tests

 * various conditions by taking actions

 * told by its parent.

 */

int new_thread_func(void *args)

{

        dbg_printf("New thread running successfully. "

                   "tid=%d\n", self_tid());

        return 0;

}

/*

 * Thread that exits by doing some number of

 * thread switches to ensure parent has a chance

 * to wait on it or attempt to destroy it

 * The purpose is to test parent-wait before self-destroy.

 */

int delayed_exit_func(void *args)

{

        int x = 5;

        l4id_t parent = *((l4id_t *)args);

        dbg_printf("%s: thread running successfully. "

                   "tid=%d\n", __FUNCTION__, self_tid());

        /*

         * Switch to parent a few times to ensure it

         * runs and begins to wait on us

         */

        while (x--)

                l4_thread_switch(parent);

        return 5;

}

/*

 * Thread that exits immediately

 * Purpose is to test parent-wait after self-destroy.

 */

int imm_exit_func(void *args)

{

        return 5;

}

/*

 * We have 3 thread creation scenarios to test.

 */

struct l4_thread *test_thread_create()

{

        struct l4_thread *tptr;

        int err;

        dbg_printf("%s: Creating thread", __FUNCTION__);

        /*

         * Create a thread in the same space

         */

        if ((err = thread_create(new_thread_func, 0,

                                 TC_SHARE_SPACE,

                                 &tptr)) < 0) {

                dbg_printf("Thread create failed. "

                           "err=%d\n", err);

                return PTR_ERR(err);

        }

        dbg_printf("Thread created successfully. "

                   "tid=%d\n", tptr->ids.tid);

        return tptr;

}

/*

 * Test thread run/resume, suspend

 *

 * We don't test recycle as that would delete the current

 * address space

 */

int test_thread_actions(struct l4_thread *thread)

{

        int err;

        dbg_printf("Suspending thread "

                   "tid=%d\n", thread->ids.tid);

        /*

         * Suspend/resume the thread

         */

        if ((err = l4_thread_control(THREAD_SUSPEND, &thread->ids)) < 0) {

                dbg_printf("THREAD_SUSPEND failed. "

                           "err=%d\n", err);

                return err;

        }

        dbg_printf("Suspend OK. Resuming thread "

                   "tid=%d\n", thread->ids.tid);

        if ((err = l4_thread_control(THREAD_RUN, &thread->ids)) < 0) {

                dbg_printf("THREAD_RUN failed. "

                           "err=%d\n", err);

                return err;

        }

        dbg_printf("Resume OK."

                   "tid=%d\n", thread->ids.tid);

        return 0;

}

/*

 * Test thread destruction

 */

int test_thread_destroy(struct l4_thread *thread)

{

        int err;

        l4id_t id_self = self_tid();

        dbg_printf("Destroying thread."

                   "tid=%d\n", thread->ids.tid);

        /*

         * Destroy the thread from parent

         */

        if ((err = thread_destroy(thread)) < 0) {

                dbg_printf("THREAD_DESTROY failed. "

                           "err=%d\n", err);

                return err;

        }

        dbg_printf("%s: Destroy OK\n", __FUNCTION__);

        dbg_printf("%s: Creating new thread\n", __FUNCTION__);

        /*

         * Create a new thread

         * and tell it to destroy itself

         * by adding a delay, then wait on it.

         *

         * Delay ensures we test the case that

         * wait occurs before thread is destroyed.

         */

        if ((err = thread_create(delayed_exit_func, &id_self,

                                 TC_SHARE_SPACE,

                                 &thread)) < 0) {

                dbg_printf("THREAD_CREATE failed. "

                           "err=%d\n", err);

                return err;

        }

        dbg_printf("Thread created successfully. "

                   "tid=%d\n", thread->ids.tid);

        dbg_printf("Waiting on thread, "

                   "tid=%d\n", thread->ids.tid);

        /* Wait on the thread */

        if ((err = thread_wait(thread)) < 0) {

                dbg_printf("THREAD_WAIT failed. "

                           "err=%d\n", err);

                return err;

        } else {

                dbg_printf("Thread %d exited successfully. ret=%d\n",

                           thread->ids.tid, err);

        }

        /*

         * Create a new thread

         * and tell it to destroy itself

         * immediately, add a delay and

         * then wait on it.

         *

         * Delay ensures we test the case that

         * wait occurs after thread is destroyed.

         */

        if ((err = thread_create(imm_exit_func, 0,

                                 TC_SHARE_SPACE,

                                 &thread)) < 0) {

                dbg_printf("THREAD_WAIT failed. "

                           "err=%d\n", err);

                return err;

        }

        /* Wait on the thread */

        if ((err = thread_wait(thread)) < 0) {

                dbg_printf("THREAD_WAIT failed. "

                           "err=%d\n", err);

                return err;

        } else {

                dbg_printf("Thread %d exited successfully. ret=%d\n",

                           thread->ids.tid, err);

        }

        return 0;

}

/*

 * TODO: In order to test null pointers a separate

 * thread who is paged by the main one should attempt

 * to pass a null ptr.

 */

int test_thread_invalid(struct l4_thread *thread)

{

        return 0;

}

int test_api_tctrl(void)

{

        struct l4_thread *thread;

        int err;

        /* Test thread create */

        if (IS_ERR(thread = test_thread_create())) {

                err = (int)thread;

                goto out_err;

        }

        /* Test thread actions */

        if ((err = test_thread_actions(thread)) < 0)

                goto out_err;

        /* Test thread destruction */

        if ((err = test_thread_destroy(thread)) < 0)

                goto out_err;

        /* Test thread invalid input */

        if ((err = test_thread_invalid(thread)) < 0)

                goto out_err;

        printf("THREAD CONTROL:                -- PASSED --\n");

        return 0;

out_err:

        printf("THREAD CONTROL:                -- FAILED --\n");

        return err;

}