signal.c

Go to the documentation of this file.

#include <routix/system.h>
#include <routix/task.h>
#include <signal.h>
#include <routix/signal.h>
#include <sys/types.h>
#include <routix/kstdio.h>
#include <error.h>
#include <routix/debug.h>
#include <routix/syscalls.h> 
 
void exec_sig_default (task_struct_t *task, int signo);
void sig_kill(task_struct_t *task);

// Variables que contienen cuantos malloc y cuantos frees realizó el kernel para alocar estructuras de
// señales (sólo con propósitos de debug)
unsigned int task_signals_alloc = 0;
unsigned int task_signals_free = 0;



int check_sigpending(task_struct_t *task, int save_context)
{
        // No verificar ningún tipo de señales para init (al menos por ahora)
        if (actual==pre_init_task)
                return -1;

        if (getvar("pepe")==1)
                return 0;

        // Si no hay señales pendientes... me voy
        if (TASK_SIGPENDING(task)==0)   {
                return 0;
        }

        int signo = 0;
        unsigned long sig = TASK_SIGPENDING(task);

        while (signo < SIGMAX) {
                // Si la señal está pendiente y no está inhibida (o enmascarada) ...
                if ( (sig & 1) && !IS_MASKED(task,signo)) {
                        exec_sigpending(task, signo, save_context);
                        TASK_SIGNAL_COUNT(task, signo)--;
                        if (TASK_SIGNAL_COUNT(task, signo)<1)
                                // Borro el bit que indica que la señal está pendiente
                                TASK_SIGPENDING(task) = TASK_SIGPENDING(task) ^ (1<<signo);
                        // Me voy avisando que encontre al menos una señal pendiente
                        return 1;
                }
                // No importa la máscara para SIGKILL
                else if ( (sig & 1) && ((signo==SIGKILL) || (signo==SIGSTOP)) )
                        sig_kill(actual);
                sig = sig >> 1;
                signo++;
        }

        return 0;

/*
        // Barrer todas las posibles señales
        for (signo=0 ; (sig & 1)==0 ; signo++)
                sig = sig >> 1;

        exec_sigpending(task, signo, save_context);
        task->sigpending = task->sigpending ^ (1<<signo);

        // Si llegué al final y no hay más pendientes
        if (signo > SIGMAX) {
                kprintf("No hay más pendientes ???\n");
                return 0;
        }


        // Retorno al scheduler, diciendo que había la menos una señal pendiente
        return 1;
*/
}



void exec_sigpending(task_struct_t *task, int signo, int save_context)
{
        if (TASK_SIGNAL_HANDLER(task, signo) == SIG_DFL) {
                exec_sig_default(task, signo);
                return;
        }
        
        // Debo inhibir la posibilidad que me conmute la tarea, ya que si lo hace con el stack desbalanceado
        // puede pasar cualquier cosa
        cli();
        
        // Obtener el contexto de la tarea
        struct int_regs_ext *context = GET_CONTEXT(task);

        unsigned long *user_ptr = (unsigned long *) context->esp;
        // Obtener la dirección física del stack de la tarea
        user_ptr = convertir_direccion( user_ptr, actual->cr3_backup);

        // Sólo debo "pushear" el EIP de la tarea y los registros para la primer señal pendiente
        // verificando con first_signal
        if (save_context == 1) {
//              kprintf("EXEC: signo first: %d\n", signo);
                *(--user_ptr) = context->eip;
//              kprintf("Pusheando al stack el EIP: 0x%x\n", context->eip);
                context->esp -= 4;
                *(--user_ptr) = context->eax;
                *(--user_ptr) = context->ebx;
                *(--user_ptr) = context->ecx;
                *(--user_ptr) = context->edx;
                *(--user_ptr) = context->edi;
                *(--user_ptr) = context->esi;
                context->esp -= (6 * sizeof(dword));
                
                *(--user_ptr) = TASK_SIGMASK(task);
                context->esp -= 4;
//              kprintf("Pusheando MASCARA: 0x%x\n", task->sigmask);
                
                
                // Paso como argumento el número de señal
                *(--user_ptr) = signo;
                // Y como dirección de retorno el wrapper "sigcheck" que popea los registros (EAX - ESI)
                *(--user_ptr) = TASK_SIGADDR(task);
                context->esp -= 8;
                context->eip = (dword) TASK_SIGNAL_HANDLER(task, signo);
        }
        else {
                // Paso como argumento el número de señal (no muevo el stack porque quedo 4 bytes desplazado)
                *(user_ptr) = TASK_SIGMASK(task);
//              kprintf("Pusheando MASCARA: 0x%x\n", task->sigmask);
                context->esp -= 4;
                *(--user_ptr) = signo;
                *(--user_ptr) = TASK_SIGADDR(task);
                // Y pusheo en el stack la dirección del handler (cuando termine el otro handler, se ejecutará este)
                context->eip = (dword) TASK_SIGNAL_HANDLER(task, signo);
                context->esp -= 4;
                //kprintf("EXEC: signo no first: %d\n", signo);
        }
        
        // Coloco como máscara, la máscara del proceso (seteada con sigaction)
        TASK_SIGMASK(task) = TASK_SIGNAL_MASK(task, signo);
        sti();

}

void exec_sig_default (task_struct_t *task, int signo)
{
        if (signo==9)
                sig_kill(actual);
        else kprintf("Proceso PID: %d\tSIG_DFL para la senal: %d no implementado \n", task->pid, signo);
}


void sig_kill(task_struct_t *task)
{
        sys_exit(0);
}

---