sched.c

Go to the documentation of this file.

#include <routix/system.h>
#include <routix/segm.h>
#include <routix/paging.h>
#include <routix/kalloc.h>
#include <routix/task.h>
#include <routix/debug.h>
#include <routix/kstdio.h>
#include <error.h>
#include <routix/syscalls.h>
#include <sys/list.h>
#include <string.h>
#include <routix/signal.h>

void idle_task(void);
void tarea_init(void);      //Tarea INIT

// Puntero a la lista enlazada de tareas
task_struct_t *tareas_inicio=NULL;

// Puntero a la tarea actual
task_struct_t *actual=NULL;

// Cantidad de tareas activas
extern volatile int tareas_activas;


task_struct_t *init_task, *pre_init_task;

void start_scheduler(void)
{
        /* Por ahora usamos la memoria fisica directamente, total esta mapeada
         * hasta que reubiquemos el codigo y datos de las tareas a una dirección
         * virtual particular */
        
        // Inicializo el tss con valores nulos
        inicializarTss(&tss, 0, 0, 0, 0, 0 );   
        
        // Tarea fundamental del sistema ! INIT_TASK corre cuando no hay nada para correr
        addr_t INIT_stack = kmalloc_page();
        
        
        init_task=init_new_task(DESC_CODE, DESC_DATA, (dword) &tarea_init, INIT_stack + 4096, 0x202, "init", 50);
        pre_init_task = init_task;


        init_task->pid = 1;
        // Init es padre e hijo (santisima trinidad)... para evitar problemas al hacer init->padre
        init_task->padre = init_task;
//      LIST_INIT(init_task->zombie_header);
 
        // Aloco la estructura de señales de init y la incializo (cuidado !!! esto NO ANDA !!!!!!!)
//      TASK_SIGNALS_ALLOC (init_task);
//      TASK_SIGNALS_INIT (init_task);
 
        // Despertamos la nueva tarea, ya que recordemos init_new_task crea la nueva tarea en estado STOPPED
        despertar_task(init_task);
        
        // La tarea en ejecución será init_task
        actual = tareas_inicio;
 
}


int execve (char *, char **, char **);
void tarea_init()
{
        
  // Inicializamos la fat
        extern dev_fat_t dev_fat[1];            //Estructura para dispositivos con fs FAT

        dev_fat[0].boot_leido = FALSE;          
        dev_fat[0].fat_levantada = FALSE;

        
        if (execve("init.bin", NULL, NULL)==-1)
                kpanic("No se pudo cargar init.bin");

        init_task = encontrar_proceso_por_pid(2);               // Init.bin
        tareas_inicio = init_task;
        sys_renice(2,1);
        
        _reschedule();
        while (1) {
                kprintf("Esto no debe imprimirse ya que esta tarea no se schedulea");
        }
/*      
        TASK_SIGNALS_ALLOC (init_task);
        TASK_SIGNALS_INIT (init_task);
        LIST_INIT (init_task->childs);

        pid_t pid;
        int value;
    kprintf("ejecutando INIT.....\n");
    if ( exec("shell.bin")!=OK )
                perror("exec shell");

        for (value = 0; value<0xffff;value++);

    while(1) {
        do {
                pid = sys_waitpid( -1 , &value, WNOHANG);
                        if (pid>0) 
                                kprintf("INIT: la condicion de salida de %d es: %d\n", pid, value);
        }while(pid!=-1);        
                _reschedule();
        }
*/
}       


/* Pasa los scan codes del buffer en crudo, a los ASCII con combinaciones de ALT, SHIFT y CTRL */
extern void leer_buff_teclado (void);


// Busca la próxima tarea activa
void scheduler()
{
        task_struct_t *tmp;
        
        leer_buff_teclado();
        
        if ( tareas_activas ) {
        
                // Volvemos al principio
                if (  (actual==NULL) || ((tmp = actual->proxima ) == NULL)  ) { tmp = tareas_inicio; }
        
                // Buscamos una tarea para correr
                while ( tmp->estado != TASK_RUNNING ) {
                        if ( (tmp = tmp->proxima) == NULL ) { tmp = tareas_inicio; }
                }
                actual = tmp;
                // Buscar señales pendientes, y ejecutar handler
                check_sigpending(actual, 1); 
        }
        
        else {
                actual=NULL;
                _sti();
                while ( ! tareas_activas ) ;
                _cli();
                scheduler();
        }

}

---