Routix/src/sched/sched.c

   1 /*!  \addtogroup Scheduler
   2         \page sched.c
   3         Contiene la base del scheduler y la tarea Init
   4 */
   5
   6 #include <routix/system.h>
   7 #include <routix/segm.h>
   8 #include <routix/paging.h>
   9 #include <routix/kalloc.h>
  10 #include <routix/task.h>
  11 #include <routix/debug.h>
  12 #include <routix/kstdio.h>
  13 #include <error.h>
  14 #include <routix/syscalls.h>
  15 #include <sys/list.h>
  16 #include <string.h>
  17 #include <routix/signal.h>
  18
  19 void idle_task(void);
  20 void tarea_init(void);      //Tarea INIT
  21
  22 int TASK_STACK_SIZE = 1;
  23
  24 // Puntero a la lista enlazada de tareas
  25 task_struct_t *tareas_inicio=NULL;
  26
  27 // Puntero a la tarea actual
  28 task_struct_t *actual=NULL;
  29
  30 // Cantidad de tareas activas
  31 extern volatile int tareas_activas;
  32
  33
  34 task_struct_t *init_task, *pre_init_task;
  35
  36 void start_scheduler(void)
  37 {
  38         /* Por ahora usamos la memoria fisica directamente, total esta mapeada
  39          * hasta que reubiquemos el codigo y datos de las tareas a una dirección
  40          * virtual particular */
  41
  42         // Inicializo el tss con valores nulos
  43         inicializarTss(&tss, 0, 0, 0, 0, 0 );
  44
  45         // Tarea fundamental del sistema ! INIT_TASK corre cuando no hay nada para correr
  46         addr_t INIT_stack = kmalloc_page();
  47
  48
  49         init_task=init_new_task(DESC_CODE, DESC_DATA, (dword) &tarea_init, INIT_stack + 4096, 0x202, "init", 50);
  50         pre_init_task = init_task;
  51
  52
  53         init_task->pid = 1;
  54         // Init es padre e hijo (santisima trinidad)... para evitar problemas al hacer init->padre
  55         init_task->padre = init_task;
  56 //      LIST_INIT(init_task->zombie_header);
  57
  58         // Aloco la estructura de señales de init y la incializo (cuidado !!! esto NO ANDA !!!!!!!)
  59 //      TASK_SIGNALS_ALLOC (init_task);
  60 //      TASK_SIGNALS_INIT (init_task);
  61
  62         // Despertamos la nueva tarea, ya que recordemos init_new_task crea la nueva tarea en estado STOPPED
  63         despertar_task(init_task);
  64
  65         // La tarea en ejecución será init_task
  66         actual = tareas_inicio;
  67
  68 }
  69
  70
  71 int execve (char *, char **, char **);
  72 void tarea_init()
  73 {
  74
  75   // Inicializamos la fat
  76         extern dev_fat_t dev_fat[1];            //Estructura para dispositivos con fs FAT
  77
  78         dev_fat[0].boot_leido = FALSE;
  79         dev_fat[0].fat_levantada = FALSE;
  80
  81         TASK_STACK_SIZE = 1;
  82         if (execve("init.bin", NULL, NULL)==-1)
  83                 kpanic("No se pudo cargar init.bin");
  84
  85
  86         init_task = encontrar_proceso_por_pid(2);               // Init.bin
  87         tareas_inicio = init_task;
  88         sys_renice(2,1);
  89         TASK_PID(init_task) = 1;
  90
  91         _reschedule();
  92         while (1) {
  93                 kprintf("Esto no debe imprimirse ya que esta tarea no se schedulea");
  94         }
  95
  96 }
  97
  98
  99 /* Pasa los scan codes del buffer en crudo, a los ASCII con combinaciones de ALT, SHIFT y CTRL */
 100 extern void leer_buff_teclado (void);
 101
 102
 103 // Busca la próxima tarea activa
 104 void scheduler()
 105 {
 106         task_struct_t *tmp;
 107
 108         leer_buff_teclado();
 109
 110         if ( tareas_activas ) {
 111
 112                 // Volvemos al principio
 113                 if (  (actual==NULL) || ((tmp = actual->proxima ) == NULL)  ) { tmp = tareas_inicio; }
 114
 115                 // Buscamos una tarea para correr
 116                 while ( tmp->estado != TASK_RUNNING ) {
 117                         if ( (tmp = tmp->proxima) == NULL ) { tmp = tareas_inicio; }
 118                 }
 119                 actual = tmp;
 120
 121                 // Si esta seteada la variable de entorno signals en 1 no verificar señales
 122                 if (getvar("signals")!=1) {
 123                         // Buscar señales pendientes, y ejecutar handler
 124                         check_sigpending(actual, 1);
 125                 }
 126         }
 127
 128         else {
 129                 actual=NULL;
 130                 _sti();
 131                 while ( ! tareas_activas ) ;
 132                 _cli();
 133                 scheduler();
 134         }
 135
 136 }
 137