sys_signal.c

Go to the documentation of this file.

#include "routix/system.h"
#include "routix/debug.h"
#include "sys/syscalls.h"
#include "routix/syscalls.h"
#include "error.h"
#include "string.h"
#include "routix/task.h"
#include "routix/signal.h"

extern task_struct_t *actual;


int (*syscall_signals[MAX_SYSCALLS]) (void) = {
        (int (*) (void)) sys_kill,
        (int (*) (void)) sys_signal,
        (int (*) (void)) sys_sigaction,
        (int (*) (void)) sys_signal_check,
        (int (*) (void)) sys_sigprocmask

};
int _sys_kill(task_struct_t *proceso, int signo);
 
 
int sys_kill(pid_t pid, int signo)
{       
        if (getvar("__sig")==1)
                kprintf("Recibida la senal: %d para el proceso: %d\n", signo, pid);
        // La señal que se intenta enviar, no existe
        if (signo > SIGMAX) {
                actual->err_no = EINVAL;
                return -1;
        }
        
        task_struct_t *proceso;
        proceso = encontrar_proceso_por_pid(pid);

        return _sys_kill(proceso, signo);
}       


int _sys_kill(task_struct_t *proceso, int signo)
{
        // Si el proceso no existe
        if (!proceso) {
                actual->err_no = ESRCH;
                return -1;
        }

        // Por ahora init solo puede recibir SIGCHLD
        if (proceso==init_task && signo!=SIGCHLD)       {
                actual->err_no = ESRCH;
                return -1;
        }

        // Si la señal no se la está ignorando, marcarla como pendiente
        if (TASK_SIGNAL_HANDLER(proceso, signo) != SIG_IGN) {
                TASK_SIGPENDING(proceso) = TASK_SIGPENDING(proceso)  | (1 << signo);
                // Aqui "encolo" las señales pendientes de un mismo tipo
                TASK_SIGNAL_COUNT(proceso, signo)++;
        }
        return 0;
}


void *sys_signal (int signo, void (*func)()) 
{
        void (*old_func)() = TASK_SIGNAL_HANDLER(actual, signo);
        // Verificar si la función "func" pertenece al espacio de direcciones del usuario
        TASK_SIGNAL_HANDLER(actual, signo) = func;
        if (getvar("__sig")==1)
                kprintf("Direccion de la funcion especificada: 0x%x\n", func);
        return old_func;
}

void sys_signal_correct(void)
{
        //kprintf("SYS_SIGNAL_CORRECT");
        
        struct int_regs_ext *contexto = GET_CONTEXT(actual);
        
        contexto->esp += 4;
        
        //__debug();
}


void sys_signal_check (void)
{
        struct int_regs_ext *context = GET_CONTEXT(actual);

        // Porque es esto ??? Bla bla... no estoy seguro...
        context->esp += 4;

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

        // Obtengo el valor de sigmask valido antes de ejecutar este handler que acaba de finalizar
        TASK_SIGMASK(actual) = *(user_ptr++);

        // Si no hay otras selañes pendientes... reacomodo el stack y retorno
        if (check_sigpending(actual, 0)<1)      {
                context->esp += 4;
//              kprintf("SYS_SIGNAL_CHECK: No hay otras pendientes\n");
        }
        // Si hay otra señal pendiente, pongo el EIP del contexto para que apunte al nuevo handler
        else {
//              kprintf("SYS_SIGNAL_CHECK: HAY !!! pendientes\n");
        }

}

int sys_sigprocmask(int flag, sigset_t *set, sigset_t *old_set)
{
        old_set = (old_set == NULL) ? NULL : convertir_direccion(old_set, actual->cr3_backup);
        set = (set == NULL) ? NULL : (sigset_t *)convertir_direccion(set, actual->cr3_backup);
        
        // Si old_set no es NULL, retorno en el la máscaraa ctual
        if (old_set) {
                *old_set = TASK_SIGMASK(actual);
                if (!set)
                        return 0;
        }

                
        switch (flag) {
                case SIG_BLOCK:
                        TASK_SIGMASK(actual) |= *set;
                        break;
                case SIG_UNBLOCK:
                        TASK_SIGMASK(actual) = TASK_SIGMASK(actual) & (~*set);
                        break;
                case SIG_SETMASK:
                        TASK_SIGMASK(actual) = *set;
                        break;
                default:
                        actual->err_no = EINVAL;
                        return -1;

        }
                        
        //kpanic("sigprocmask");
        return 0;
}

int sys_sigaction (int signo, struct sigaction *act, struct sigaction *oact) 
{
        
        if (signo >= SIGMAX)    {
                actual->err_no = EINVAL;
                return -1;
        }
        
        oact = (oact == NULL) ? NULL : convertir_direccion(oact, actual->cr3_backup);
        act = (act == NULL) ? NULL : convertir_direccion(act, actual->cr3_backup);

        if (oact)
                memcpy (oact, &(TASK_SIGNAL(actual, signo)), sizeof (struct sigaction));
        
        if (act)
                memcpy (&(TASK_SIGNAL(actual, signo)), act, sizeof (struct sigaction));
        
        return 0;
}

---