---

syscall.c

Go to the documentation of this file.

/*!     \file kernel/syscall.c
 *      \brief System Calls.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update: 2004-01-03
 *      \note Copyright (&copy;) 2003 Andrea Righi
 */

#include <const.h>

#include <arch/i386.h>
#include <arch/mem.h>

#include <kernel/console.h>
#include <kernel/keyboard.h>
#include <kernel/kernel.h>
#include <kernel/speaker.h>
#include <kernel/task.h>
#include <kernel/umalloc.h>

#include <kernel/syscall.h>

//! Total amount of system calls.
#define SYS_CALL_NR     ( sizeof(syscall_table)/sizeof(dword) )

//! System call entry.
typedef struct syscall_t
{
        //! The address of the procedure.
        addr_t address;
        //! How many arguments are passed to the procedure.
        addr_t paramcnt;
} syscall_t;

//! This is the array of the known system calls.
static syscall_t syscall_table[] = {
// ID           Routine Address         # of parameters
/* 0 */ {       (size_t)&auto_kill,     1               },
/* 1 */ {       (size_t)&kgetchar,      0               },
/* 2 */ {       (size_t)&kputchar,      1               },
/* 3 */ {       (size_t)&keyb_read,     0               },
/* 4 */ {       (size_t)&umalloc,       1               },
/* 5 */ {       (size_t)&ufree,         1               },
};

/*! \ingroup Handlers */
//! \brief
//!     This procedure execute every system call invoked by INT 0x80.
//! \param eax
//!     The EAX register of the calling procedure must contains the
//!     syscall id. At the end of the syscall it contains the
//!     returned value.
//! \param ebp
//!     The EBP register of the calling procedure. It must point
//!     to the stack pointer of the calling procedure.
//!
/*!     Copy the stack parameters from the stack pointer of the
 *      calling procedure (pointed by \p ebp) to the current stack
 *      pointer. Then the opportune syscall is invoked.
 */
void syscall_handler(dword *eax, dword *ebp)
{
        // Function pointer.
        size_t (*p)() = (void *)syscall_table[*eax].address;
        // How many parameters.
        int paramcnt = syscall_table[*eax].paramcnt;
        // Start of parameters'address.
        size_t *args = (size_t *)(*ebp);

        register int i;

        // Check if the system call id does not exceed the syscall table.
        // NOTE: sycall id is 0-based!!!
        if ( *eax < SYS_CALL_NR )
        {
                // Pass the parameters to the system call routine.
                for( i=paramcnt; i; --i)
                        __asm__ __volatile__ ("pushl %0" : : "r"(*(args+i-1)));
                // Execute the system call.
                // The result will be returned into the task's eax register.
                *eax = (*p)();
                // Pop elements out of the stack.
                __asm__ __volatile__ ("add %0, %%esp" : : "r"(paramcnt*sizeof(size_t)));
        }
        else
        {
                // Invalid syscall id! => kill the task.
                kprintf("\n\rsyscall: %u", *eax);
                error("Invalid system call");
        }
}

---