sched.c

Go to the documentation of this file.

#include "local.h"

#include <linux/sched.h>

DEFINE_RWLOCK(tasklist_lock);

asmlinkage void preempt_schedule(void)
{
        WARN_UNIMPL;
}


/* Our version of scheduler invocation.
 *
 * Scheduling is performed by Fiasco, so we don't care about it as long as
 * a thread is running. If a task becomes TASK_INTERRUPTIBLE or
 * TASK_UNINTERRUPTIBLE, we make sure that the task does not become
 * scheduled by locking the task's sleep lock.
 */
asmlinkage void schedule(void)
{
        dde26_thread_data *t = lxtask_to_ddethread(current);

        switch (current->state) {
                case TASK_RUNNING:
                        ddekit_thread_schedule();
                        break;
                case TASK_INTERRUPTIBLE:
                case TASK_UNINTERRUPTIBLE:
                        ddekit_sem_down(SLEEP_LOCK(t));
                        break;
                default:
                        panic("current->state = %d --- unknown state\n", current->state);
        }
}


/** yield the current processor to other threads.
 *
 * this is a shortcut for kernel-space yielding - it marks the
 * thread runnable and calls sys_sched_yield().
 */
void __sched yield(void)
{
        set_current_state(TASK_RUNNING);
        ddekit_yield();
}


/***
 * try_to_wake_up - wake up a thread
 * @p: the to-be-woken-up thread
 * @state: the mask of task states that can be woken
 * @sync: do a synchronous wakeup?
 */
int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
{
        Assert(p);
        dde26_thread_data *t = lxtask_to_ddethread(p);

        Assert(t);
        Assert(SLEEP_LOCK(t));

        p->state = TASK_RUNNING;
        ddekit_sem_up(SLEEP_LOCK(t));

        return 0;
}


static void process_timeout(unsigned long data)
{
        wake_up_process((struct task_struct *)data);
}


signed long __sched schedule_timeout(signed long timeout)
{
        struct timer_list timer;
        unsigned long expire = timeout + jiffies;

        setup_timer(&timer, process_timeout, (unsigned long)current);
        timer.expires = expire;

        switch(timeout)
        {
                /*
                 * Hah!
                 *
                 * Specifying a @timeout value of %MAX_SCHEDULE_TIMEOUT will schedule
                 * the CPU away without a bound on the timeout. In this case the return
                 * value will be %MAX_SCHEDULE_TIMEOUT.
                 */
                case MAX_SCHEDULE_TIMEOUT:
                        schedule();
                        break;
                default:
                        add_timer(&timer);
                        schedule();
                        del_timer(&timer);
                        break;
        }

        timeout = expire - jiffies;

        return timeout < 0 ? 0 : timeout;
}


signed long __sched schedule_timeout_interruptible(signed long timeout)
{
        __set_current_state(TASK_INTERRUPTIBLE);
        return schedule_timeout(timeout);
}


signed long __sched schedule_timeout_uninterruptible(signed long timeout)
{
        __set_current_state(TASK_UNINTERRUPTIBLE);
        return schedule_timeout(timeout);
}

/** Tasks may be forced to run only on a certain no. of CPUs. Since
 *  we only emulate a SMP-environment for the sake of having multiple
 *  threads, we do not need to implement this.
 */
int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask)
{
        return 0;
}

void set_user_nice(struct task_struct *p, long nice)
{
        //WARN_UNIMPL;
}

void __sched io_schedule(void)
{
        WARN_UNIMPL;
}

long __sched io_schedule_timeout(long timeout)
{
        WARN_UNIMPL;
        return -1;
}

extern int sched_setscheduler_nocheck(struct task_struct *t, int flags,
                                                                          struct sched_param *p)
{
        WARN_UNIMPL;
        return -1;
}

void ignore_signals(struct task_struct *t) { }

---