sched.c

Go to the documentation of this file.

/*
 * kernel_super/sched/sched.c
 *
 * Copyright (c) 2003-2004 Lukasz Dembinski <dembol@nasa.com.pl>
 * All Rights Reserved
 * 
 * Date:        2004/01
 * Author:      Lukasz Dembinski
 * Info:        sched.c core file
 * Contact:     mailto: <dembol@nasa.com.pl>
 *
 */

#include <agnix/agnix.h>
#include <agnix/init.h>
#include <agnix/list.h>
#include <agnix/queues.h>
#include <agnix/tasks.h> 
#include <agnix/math64.h>
#include <agnix/console.h>
#include <agnix/memory.h>
#include <agnix/spinlock.h>
#include <asm/irq.h>

struct list_head running_tasks_list;
struct list_head tasks_list;
spinlock_t running_list_lock;
spinlock_t tasks_list_lock;

extern struct task_s *idle_task;

void sched_queue_task(void)
{
}

void sched_activate_task_lock(struct task_s *task)
{
    if (!(task->t_state & TASK_STAT_RUNNING)) { 
        task->t_state |= TASK_STAT_RUNNING;
        list_add(&(task->running_task_list), &running_tasks_list);
    }
}

void sched_activate_task(struct task_s *task)
{
    u32 flags;

    spin_lock_irqsave(&running_list_lock, flags);
    sched_activate_task_lock(task);
    spin_unlock_irqrestore(&running_list_lock, flags);
}

void sched_deactivate_task_lock(struct task_s *task)
{
    if (task->t_state & TASK_STAT_RUNNING) {    
        task->t_state &= ~TASK_STAT_RUNNING;
    }
}

void sched_deactivate_task(struct task_s *task)
{
    u32 flags;

    spin_lock_irqsave(&running_list_lock, flags);
    sched_deactivate_task_lock(task);
    spin_unlock_irqrestore(&running_list_lock, flags);
}

void sched_add_task_lock(struct task_s *task)
{
    list_add(&(task->task_list), &tasks_list);
}

void sched_add_task(struct task_s *task)
{
    u32 flags;

    spin_lock_irqsave(&running_list_lock, flags);
    sched_add_task_lock(task);
    spin_unlock_irqrestore(&running_list_lock, flags);
}

void sched_task_can_resched(int can_resched)
{
    atomic_write(&current_task->t_can_resched, can_resched);
}

/* we have only Round Robin schedule algorithm */
void reschedule_task(struct task_s *task)
{
    list_del(&(task->running_task_list));
    list_add_tail(&(task->running_task_list), &running_tasks_list);
}

void schedule_task(void)
{
    struct task_s *prev, *next;
    struct list_head *head;
    u16 prev_tss_entry;
    u16 next_tss_entry;
    u32 flags;
    int prev_pid;

    spin_lock_irqsave(&running_list_lock, flags);

    prev = current_task;

    if ((prev->t_state & TASK_STAT_KILLED) || (!(prev->t_state & TASK_STAT_RUNNING))) {
        if (prev->t_pid) {
            list_del(&prev->running_task_list);
        }
    }

    if (list_empty(&running_tasks_list)) {
        next = idle_task;
    } else {
        head = running_tasks_list.next;
        next = list_entry(head, struct task_s, running_task_list);
    }

    next->t_state &= ~TASK_STAT_STARTING;
    prev_tss_entry = prev->tss_wrap->tss_entry;
    next_tss_entry = next->tss_wrap->tss_entry;
    prev_pid = prev->t_pid;

    prev->t_resched = 0;
    prev->t_count = INIT_COUNT;

    if (prev->t_state & TASK_STAT_KILLED) {
        put_free_pages((u32)prev, 1);
    }
    
    if (next != idle_task)
        reschedule_task(next);

    if (prev_pid != next->t_pid)
        task_switch(next_tss_entry);    
        
    spin_unlock_irqrestore(&running_list_lock, flags);
}

int __init scheduler_init(void)
{
    INIT_LIST_HEAD(&running_tasks_list);
    INIT_LIST_HEAD(&tasks_list);

    spin_lock_init(&running_list_lock);
    spin_lock_init(&tasks_list_lock);

    return 0;
}

void scheduler_print_tasks(void)
{
    struct list_head *tmp;
    struct task_s *task;
    u32 flags;

    printf("\n");

    spin_lock_irqsave(&running_list_lock, flags);    
    
    list_for_each(tmp, &tasks_list) {
        task = list_entry(tmp, struct task_s, task_list);
        
        printf("%s [pid %d]\n", task->name, task->t_pid);
    }
    
    spin_unlock_irqrestore(&running_list_lock, flags);    
}