Main Page | Directories | File List | Globals

sched.c File Reference

#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>

Include dependency graph for sched.c:

Go to the source code of this file.

Functions

void sched_queue_task (void)
void sched_activate_task_lock (struct task_s *task)
void sched_activate_task (struct task_s *task)
void sched_deactivate_task_lock (struct task_s *task)
void sched_deactivate_task (struct task_s *task)
void sched_add_task_lock (struct task_s *task)
void sched_add_task (struct task_s *task)
void sched_task_can_resched (int can_resched)
void reschedule_task (struct task_s *task)
void schedule_task (void)
int __init scheduler_init (void)
void scheduler_print_tasks (void)

Variables

list_head running_tasks_list
list_head tasks_list
spinlock_t running_list_lock
spinlock_t tasks_list_lock
task_s * idle_task


Function Documentation

void reschedule_task struct task_s *  task  ) 
 

Definition at line 89 of file sched.c.

References running_tasks_list.

Referenced by schedule_task().

00090 {
00091     list_del(&(task->running_task_list));
00092     list_add_tail(&(task->running_task_list), &running_tasks_list);
00093 }

void sched_activate_task struct task_s *  task  ) 
 

Definition at line 44 of file sched.c.

References flags, running_list_lock, and sched_activate_task_lock().

Referenced by arp_request_wake_up(), arp_timeout(), do_sys_fork(), fastirq_queue(), sleep_timer_expire(), and wait_list_wake_up().

00045 {
00046     u32 flags;
00047 
00048     spin_lock_irqsave(&running_list_lock, flags);
00049     sched_activate_task_lock(task);
00050     spin_unlock_irqrestore(&running_list_lock, flags);
00051 }

Here is the call graph for this function:

void sched_activate_task_lock struct task_s *  task  ) 
 

Definition at line 36 of file sched.c.

References running_tasks_list.

Referenced by sched_activate_task().

00037 {
00038     if (!(task->t_state & TASK_STAT_RUNNING)) { 
00039         task->t_state |= TASK_STAT_RUNNING;
00040         list_add(&(task->running_task_list), &running_tasks_list);
00041     }
00042 }

void sched_add_task struct task_s *  task  ) 
 

Definition at line 74 of file sched.c.

References flags, running_list_lock, and sched_add_task_lock().

Referenced by do_sys_fork().

00075 {
00076     u32 flags;
00077 
00078     spin_lock_irqsave(&running_list_lock, flags);
00079     sched_add_task_lock(task);
00080     spin_unlock_irqrestore(&running_list_lock, flags);
00081 }

Here is the call graph for this function:

void sched_add_task_lock struct task_s *  task  ) 
 

Definition at line 69 of file sched.c.

References tasks_list.

Referenced by sched_add_task().

00070 {
00071     list_add(&(task->task_list), &tasks_list);
00072 }

void sched_deactivate_task struct task_s *  task  ) 
 

Definition at line 60 of file sched.c.

References flags, running_list_lock, and sched_deactivate_task_lock().

Referenced by arp_resolve(), fastirq_thread(), sleep_timeout(), and wait_list_sleep_on().

00061 {
00062     u32 flags;
00063 
00064     spin_lock_irqsave(&running_list_lock, flags);
00065     sched_deactivate_task_lock(task);
00066     spin_unlock_irqrestore(&running_list_lock, flags);
00067 }

Here is the call graph for this function:

void sched_deactivate_task_lock struct task_s *  task  ) 
 

Definition at line 53 of file sched.c.

Referenced by sched_deactivate_task().

00054 {
00055     if (task->t_state & TASK_STAT_RUNNING) {    
00056         task->t_state &= ~TASK_STAT_RUNNING;
00057     }
00058 }

void sched_queue_task void   ) 
 

Definition at line 32 of file sched.c.

00033 {
00034 }

void sched_task_can_resched int  can_resched  ) 
 

Definition at line 83 of file sched.c.

00084 {
00085     atomic_write(&current_task->t_can_resched, can_resched);
00086 }

void schedule_task void   ) 
 

Definition at line 95 of file sched.c.

References flags, idle_task, put_free_pages(), reschedule_task(), running_list_lock, running_tasks_list, and task_switch().

Referenced by arp_resolve(), execute_irq(), fastirq_thread(), sleep_timeout(), and wait_list_sleep_on().

00096 {
00097     struct task_s *prev, *next;
00098     struct list_head *head;
00099     u16 prev_tss_entry;
00100     u16 next_tss_entry;
00101     u32 flags;
00102     int prev_pid;
00103 
00104     spin_lock_irqsave(&running_list_lock, flags);
00105 
00106     prev = current_task;
00107 
00108     if ((prev->t_state & TASK_STAT_KILLED) || (!(prev->t_state & TASK_STAT_RUNNING))) {
00109         if (prev->t_pid) {
00110             list_del(&prev->running_task_list);
00111         }
00112     }
00113 
00114     if (list_empty(&running_tasks_list)) {
00115         next = idle_task;
00116     } else {
00117         head = running_tasks_list.next;
00118         next = list_entry(head, struct task_s, running_task_list);
00119     }
00120 
00121     next->t_state &= ~TASK_STAT_STARTING;
00122     prev_tss_entry = prev->tss_wrap->tss_entry;
00123     next_tss_entry = next->tss_wrap->tss_entry;
00124     prev_pid = prev->t_pid;
00125 
00126     prev->t_resched = 0;
00127     prev->t_count = INIT_COUNT;
00128 
00129     if (prev->t_state & TASK_STAT_KILLED) {
00130         put_free_pages((u32)prev, 1);
00131     }
00132     
00133     if (next != idle_task)
00134         reschedule_task(next);
00135 
00136     if (prev_pid != next->t_pid)
00137         task_switch(next_tss_entry);    
00138         
00139     spin_unlock_irqrestore(&running_list_lock, flags);
00140 }

Here is the call graph for this function:

int __init scheduler_init void   ) 
 

Definition at line 142 of file sched.c.

References running_list_lock, running_tasks_list, tasks_list, and tasks_list_lock.

Referenced by start_kernel().

00143 {
00144     INIT_LIST_HEAD(&running_tasks_list);
00145     INIT_LIST_HEAD(&tasks_list);
00146 
00147     spin_lock_init(&running_list_lock);
00148     spin_lock_init(&tasks_list_lock);
00149 
00150     return 0;
00151 }

void scheduler_print_tasks void   ) 
 

Definition at line 153 of file sched.c.

References flags, printf(), running_list_lock, and tasks_list.

Referenced by agnix_console_ps().

00154 {
00155     struct list_head *tmp;
00156     struct task_s *task;
00157     u32 flags;
00158 
00159     printf("\n");
00160 
00161     spin_lock_irqsave(&running_list_lock, flags);    
00162     
00163     list_for_each(tmp, &tasks_list) {
00164         task = list_entry(tmp, struct task_s, task_list);
00165         
00166         printf("%s [pid %d]\n", task->name, task->t_pid);
00167     }
00168     
00169     spin_unlock_irqrestore(&running_list_lock, flags);    
00170 }

Here is the call graph for this function:


Variable Documentation

struct task_s* idle_task
 

Definition at line 28 of file init_task.c.

Referenced by schedule_task().

spinlock_t running_list_lock
 

Definition at line 27 of file sched.c.

Referenced by do_task_exit(), sched_activate_task(), sched_add_task(), sched_deactivate_task(), schedule_task(), scheduler_init(), and scheduler_print_tasks().

struct list_head running_tasks_list
 

Definition at line 25 of file sched.c.

Referenced by reschedule_task(), sched_activate_task_lock(), schedule_task(), and scheduler_init().

struct list_head tasks_list
 

Definition at line 26 of file sched.c.

Referenced by sched_add_task_lock(), scheduler_init(), and scheduler_print_tasks().

spinlock_t tasks_list_lock
 

Definition at line 28 of file sched.c.

Referenced by scheduler_init().

Dokumentacje wygenerowano programem Doxygen 1.4.2 dla projektu Agnix