---

task.c

Go to the documentation of this file.

/*!     \file kernel/task.c
 *      \brief Task Management.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update:\n
 *              2003-12-15 Andrea Righi:
 *                      Added temporary memory operators to get and
 *                      free the temporary mapped pages.\n
 *              2003-12-16 Andrea Righi:
 *                      Fixed mutual exclusion bug in kill() and
 *                      waitpid()\n
 *      \note Copyright (&copy;) 2003 Andrea Righi
 */

#include <const.h>
#include <stdlib.h>
#include <string.h>

#include <arch/i386.h>
#include <arch/interrupt.h>
#include <arch/mem.h>
#include <arch/paging.h>
#include <arch/v86.h>

#include <kernel/console.h>
#include <kernel/clock.h>
#include <kernel/elf32.h>
#include <kernel/fat.h>
#include <kernel/kmalloc.h>
#include <kernel/queue.h>
#include <kernel/semaphore.h>
#include <kernel/shell.h>
#include <kernel/umalloc.h>

#include <kernel/task.h>

extern size_t K_PDBR[PAGE_SIZE/sizeof(size_t)];

/** \ingroup Multitasking
 *  \defgroup MTQueue Task Queues
 *  Queues for the tasks life-cycle.
 *  @{
 */

//! Ready-queue: tasks are ready for the CPU.
queue_t *ready_queue = NULL;
//! Wait-queue: tasks are waiting for I/O.
queue_t *wait_queue = NULL;
//! Zombie-queue: tasks are dying.
queue_t *zombie_queue = NULL;

/** @} */ // end of MTQueue

// --- System tasks & threads ------------------------------------------//

/** \ingroup Multitasking
 *  \defgroup MTSystem System Tasks and Threads
 *  Here are some systems tasks and threads.
 *  @{
 */

 //! Current running task.
task_t  *curr_task = NULL;
//! IDLE task structure. Initialized in init_multitasking().
task_t *idle_task = NULL;
//! KPager daemon.
task_t *kpagd = NULL;

//! \brief Simply do nothing...
/*!
 *      This is the default thread to execute when the system has to
 *      do nothing.
 */
void do_idle()
{
        while(TRUE)
        {
                enable();
                idle();
        }
}

//! \brief
//!     This special kernel thread provides to free the memory space and
//!     resources owned by the zombie tasks.
void kpager()
{
        task_t *t;
        dword addr, PDBR;

        while( TRUE )
        {
                sched_enter_critical_region();

                // Look into the zombie queue.
                t = pick_queue(&zombie_queue);
                if ( t==NULL )
                {
                        // No task in the zombie queue => IDLE! //
                        sched_leave_critical_region();

                        sleep_task( curr_task );
                        enable();
                        idle();
                        continue;
                }

                // Zombie task found.
                if ( t->type==KTHREAD_T )
                {
                        // Free the pl0-stack //
                        if( t->pl0_stack!=NULL )
                                kfree((void *)((dword)(t->pl0_stack)+sizeof(uint32_t)-STACK_SIZE));

                        // Destroy the TSS //
                        remove_GDT_entry(t->tss_sel);

                        // The task is dead //
                        rem_queue(&zombie_queue, t);

                        // Free the task structure //
                        kfree((void *)t);
                }
                else
                {
                        PDBR = t->tss.cr3;

                        // Temporary switch to the task address space //
                        __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(t->tss.cr3));

                        // Free the user address space //
                        for(addr=0; addr<K_VIR_START; addr+=PAGE_SIZE)
                        {
                                if (*ADDR_TO_PDE(addr) != NULL)
                                        delete_page(addr);
                                else
                                        addr=PAGE_DIR_ALIGN_UP(addr);
                        }

                        // Restore the kpager address space //
                        __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(curr_task->tss.cr3));

                        // Free the pl0-stack //
                        kfree((void *)((dword)(t->pl0_stack)+sizeof(uint32_t)-STACK_SIZE));

                        // Destroy the TSS //
                        remove_GDT_entry(t->tss_sel);

                        // The task is dead //
                        rem_queue(&zombie_queue, t);

                        // Free the task structure //
                        kfree((void *)t);

                        // Free the task page directory //
                        push_frame(PDBR/PAGE_SIZE);
                }
                sched_leave_critical_region();
        }
}
/** @} */ // end of MTSystem

// --- PID operators ---------------------------------------------------//

/** \ingroup Multitasking
 *  \defgroup MTPid PID Operators
 *  Operators to manage the pids for the tasks.
 *  @{
 */

//! Last used pid.
atomic_t last_pid;

//! \brief Create a new pid.
//! \return The new pid created.
/*!
 *      This routine generate a pid using an atomic increment.
 */
pid_t new_pid()
{
        atomic_inc(&last_pid);
        return(atomic_read(&last_pid));
}

//! \brief Return the current task pid if there is a curr_task.
//! \return The current task pid.
pid_t get_pid()
{
        if ( !curr_task ) return( NULL );
        return( curr_task->pid );
}
/** @} */ // end of MTPid

// --- Process info ----------------------------------------------------//

/** \ingroup Multitasking
 *  \defgroup MTProcessInfo Process Informations
 *  Operators to get some processes informations.
 *  @{
 */

//! \brief Get the current task.
//! \return The current task structure pointer.
task_t *get_curr_task()
{
        return( curr_task );
}

//! \brief Return the current task name if there is a curr_task.
//! \return The current task name.
char *get_pname()
{
        if ( !curr_task ) return( NULL );
        return( curr_task->name );
}
/** @} */ // end of MTProcessInfo

// --- Task's routines -------------------------------------------------//

/** \ingroup Multitasking
 *  \defgroup MTTaskRoutines Generic Routines
 *  The generic routines for task management.
 *  @{
 */

//! \brief Create a new kernel thread.
//! \param address The address of the starting point for the thread.
//! \param pname The name of the new thread.
//! \return A pointer to the new-created task structure.
//! \exception NULL If an error occurs (in particular out-of-memory).
/*!
 *      This routine initialize a new kernel thread structure and
 *      add this thread to the ready queue.
 */
task_t *create_kthread(void *address, char *pname)
{
        task_t *new_task;
        byte *pl0_stack;

        sched_enter_critical_region();

        // --- Create the task structure -------------------------------//
        //!
        //! IA-32 Intel(R) Architecture Software Developer's Manual
        //! Volume 3: System Programming Guide - Chapter 6 - reports:
        //!
        //! "If paging is used, care should be taken to avoid placing a
        //! page boundary within the part of the TSS that the processor
        //! reads during a task switch (the first 104 bytes). If a page
        //! boundary is placed within this part of the TSS, the pages on
        //! either side of the boundary must be present at the same time
        //! and contiguous in physical memory.
        //!
        //! The reason for this restriction is that when accessing a TSS
        //! during a task switch, the processor reads and writes into
        //! the first 104 bytes of each TSS from contiguous physical
        //! addresses beginning with the physical address of the first
        //! byte of the TSS. It may not perform address translation at a
        //! page boundary if one occurs within this area. So, after the
        //! TSS access begins, if a part of the 104 bytes is not both
        //! present and physically contiguous, the processor will access
        //! incorrect TSS information, without generating a page-fault
        //! exception. The reading of this incorrect information will
        //! generally lead to an unrecoverable exception later in the
        //! task switch process..."
        new_task = kmemalign(PAGE_SIZE, sizeof(task_t));
        if (new_task == NULL)
        {
                // Out of virtual memory!!! //
                set_color(LIGHT_RED);
                kprintf("\n\rOut of virtual memory!!! Cannot create task [%s]\n\r", pname);
                set_color(DEFAULT_COLOR);

                sched_leave_critical_region();
                return(NULL);
        }
        memset(new_task, 0, sizeof(task_t));

        // --- Create the pl0-stack --- //
        pl0_stack = kmalloc(STACK_SIZE);
        if (pl0_stack == NULL)
        {
                // Out of virtual memory!!! //
                set_color(LIGHT_RED);
                kprintf("\n\rOut of virtual memory!!! Cannot create task [%s]\n\r", pname);
                set_color(DEFAULT_COLOR);
                // Free the previous allocated space //
                kfree((void *)new_task);

                sched_leave_critical_region();
                return(NULL);
        }
        // Null the stack to enforce the page mapping //
        memset(pl0_stack, 0, STACK_SIZE);
        // Setup the pl0-stack //
        new_task->tss.ss0 = new_task->tss.ss = KERNEL_STACK;
        new_task->tss.esp0 = new_task->tss.esp = new_task->pl0_stack = (dword)(pl0_stack+STACK_SIZE-sizeof(uint32_t));

        // --- Setup the TSS --- //
        new_task->tss_sel = setup_GDT_entry(sizeof(tss_IO_t), (dword)&(new_task->tss), TSS_SEG, 0);

        // Setup the task PDBR => get the kernel PDBR //
        new_task->tss.cr3 = GET_PDBR();

        // Setup the IO port mapping //
        new_task->tss.io_map_addr = sizeof(tss_t);

        // Setup general registers //
        new_task->tss.ds = new_task->tss.es = KERNEL_DATA;
        new_task->tss.fs = new_task->tss.gs = KERNEL_DATA;
        new_task->tss.eflags = EFLAGS_IF | 0x02;

        // Initialize general purpose registers //
        new_task->tss.eax = new_task->tss.ebx =
        new_task->tss.ecx = new_task->tss.edx =
        new_task->tss.esi = new_task->tss.edi = 0;

        // Initialize LDTR (Local Descriptor Table Register) //
        // No LDTs for now...
        new_task->tss.ldtr = 0;

        // Initialize debug trap //
        // If set to 1 the processor generate a debug exception when a task switch to this task occurs...
        new_task->tss.trace = 0;

        // Setup starting address //
        new_task->tss.cs = KERNEL_CODE;
        new_task->tss.eip = (dword)address;

        // --- Get a pid --- //
        new_task->pid = new_pid();

        // --- Store the name --- //
        // The last character must be ever '\0' (end of string) //
        strncpy(new_task->name, pname, sizeof(new_task->name)-2);

        // --- Set the type --- //
        new_task->type = KTHREAD_T;

        // --- Set the parent process --- //
        new_task->father = curr_task;

        // --- Set the console --- //
        new_task->console = curr_task->console;

        // --- Insert the task into the ready queue --- //
        new_task->state = READY;
        add_queue(&ready_queue, new_task);

        sched_leave_critical_region();

        return (new_task);
}

//! \brief Create a new process.
//! \param address
//!     The address of the starting point for the thread.
//! \param buffer
//!     An address to a buffer where is placed the executable code.
//! \param size
//!     The size of the executable code buffer.
//! \param pname
//!     The name of the new task.
//! \param privilege
//!     The privilege level of the new task:
//!             \li #KERNEL_PRIVILEGE
//!             \li #USER_PRIVILEGE
//! \return A pointer to the new-created task structure.
//! \exception NULL If an error occurs (in particular out-of-memory).
/*!
 *      This routine initializes the new task structure, copies
 *      the content of the \a buffer to the entry point \a address and
 *      then add the new task to the ready queue.
 */
task_t *create_process(void *address, void *buffer, size_t size, char *pname, int privilege)
{
        task_t *new_task;
        byte *pl0_stack;
        dword *PDBR;
        dword PDBR_frame, i;
        register dword cr3;

        sched_enter_critical_region();

        // --- Create the task structure -------------------------------//
        //!
        //! IA-32 Intel(R) Architecture Software Developer's Manual
        //! Volume 3: System Programming Guide - Chapter 6 - reports:
        //!
        //! "If paging is used, care should be taken to avoid placing a
        //! page boundary within the part of the TSS that the processor
        //! reads during a task switch (the first 104 bytes). If a page
        //! boundary is placed within this part of the TSS, the pages on
        //! either side of the boundary must be present at the same time
        //! and contiguous in physical memory.
        //!
        //! The reason for this restriction is that when accessing a TSS
        //! during a task switch, the processor reads and writes into
        //! the first 104 bytes of each TSS from contiguous physical
        //! addresses beginning with the physical address of the first
        //! byte of the TSS. It may not perform address translation at a
        //! page boundary if one occurs within this area. So, after the
        //! TSS access begins, if a part of the 104 bytes is not both
        //! present and physically contiguous, the processor will access
        //! incorrect TSS information, without generating a page-fault
        //! exception. The reading of this incorrect information will
        //! generally lead to an unrecoverable exception later in the
        //! task switch process..."
        new_task = kmemalign(PAGE_SIZE, sizeof(task_t));
        if (new_task == NULL)
        {
                // Out of virtual memory!!! //
                set_color(LIGHT_RED);
                kprintf("\n\rOut of virtual memory!!! Cannot create task [%s]\n\r", pname);
                set_color(DEFAULT_COLOR);

                sched_leave_critical_region();
                return(NULL);
        }
        memset(new_task, 0, sizeof(task_t));

        // --- Create the pl0-stack --- //
        pl0_stack = kmalloc(STACK_SIZE);
        if (pl0_stack == NULL)
        {
                // Out of virtual memory!!! //
                set_color(LIGHT_RED);
                kprintf("\n\rOut of virtual memory!!! Cannot create task [%s]\n\r", pname);
                set_color(DEFAULT_COLOR);
                // Free the previous allocated space //
                kfree((void *)new_task);

                sched_leave_critical_region();
                return(NULL);
        }
        // Null the stack to enforce the page mapping //
        memset(pl0_stack, 0, STACK_SIZE);
        // Setup the pl0-stack //
        new_task->tss.ss0 = KERNEL_STACK;
        new_task->tss.esp0 = new_task->pl0_stack = (dword)(pl0_stack+STACK_SIZE-sizeof(uint32_t));

        // --- Setup the TSS --- //
        new_task->tss_sel = setup_GDT_entry(sizeof(tss_IO_t), (dword)&(new_task->tss), TSS_SEG, 0);

        // --- Create the virtual space of the task ------------------- //
        PDBR = (dword *)get_temp_page();
        if ( PDBR == NULL )
        {
                // Out of memory!!! Free the previous allocated memory. //
                set_color(LIGHT_RED);
                kprintf("\n\rOut memory!!! Cannot create task [%s]\n\r", pname);
                set_color(DEFAULT_COLOR);
                // Free the previous allocated space //
                kfree((void *)(pl0_stack));
                kfree((void *)new_task);
                // Destroy the TSS //
                remove_GDT_entry(new_task->tss_sel);
                // Free the

                sched_leave_critical_region();
                return(NULL);
        }
        PDBR_frame = vir_to_phys( (dword)PDBR );

        // Initialize PDBR //
        memset(PDBR, 0, PAGE_SIZE);
        for (i=K_VIR_START/(PAGE_SIZE*1024); i<1024; i++)
                PDBR[i] = K_PDBR[i];

        // Map page directory into itself //
        PDBR[1023] = PDBR_frame | P_PRESENT | P_WRITE;

        // Unmap the temporary page, without free the physical frame    //
        free_temp_page(PDBR, FALSE);

        // Temporary switch to the new address space                    //
        //                                                              //
        // QUESTION: cr3 is in the stack... if I switch into the new    //
        // address space can I ever see the old cr3 value???            //
        //                                                              //
        // RE: Yes, but only if cr3 is stored into a register...        //
        // And if the value should be stored into the stack, here we    //
        // are at CPL0, so we're using the 0-privileged stack, so,      //
        // since the 0-privileged stack space is shared between every   //
        // task and also the kernel, we're ever able to see the stored  //
        // cr3 value...                                                 //
        __asm__ __volatile__ ("movl %%cr3, %0" : "=r"(cr3) : );
        __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(PDBR_frame));

        // --- Create the user space --- //

        // Create the task stack //
        new_task->tss.ss = (privilege == KERNEL_PRIVILEGE) ? KERNEL_STACK : USER_STACK | 3;
        if ( privilege == KERNEL_PRIVILEGE )
                new_task->tss.esp = new_task->pl0_stack;
        else
                new_task->tss.esp = (dword)(TASK_STACK_START-sizeof(size_t));

        // Map the user code and data space.                            //
        // ("address" is the virtual task space, "buffer" is the        //
        // kernel space where the task-code is located).                //
        if (address != buffer)
        {
                memcpy(address, buffer, size);
        }

        // Restore the old address space //
        __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(cr3));

        // Setup the task PDBR //
        new_task->tss.cr3 = PDBR_frame;

        // Setup the IO port mapping //
        new_task->tss.io_map_addr = sizeof(tss_t);

        // Setup general registers //
        if ( privilege == KERNEL_PRIVILEGE )
                new_task->tss.ds = new_task->tss.es =
                new_task->tss.fs = new_task->tss.gs = KERNEL_DATA;
        else
                new_task->tss.ds = new_task->tss.es =
                new_task->tss.fs = new_task->tss.gs = USER_DATA | 3;

        new_task->tss.eflags = EFLAGS_IF | 0x02;
        if ( privilege == USER_PRIVILEGE )
                // User tasks must have the I/O privilege level         //
                // at the lower level                                   //
                new_task->tss.eflags |= EFLAGS_IOPL3;

        // Initialize general purpose registers //
        new_task->tss.eax = new_task->tss.ebx =
        new_task->tss.ecx = new_task->tss.edx =
        new_task->tss.esi = new_task->tss.edi = 0;

        // Initialize LDTR (Local Descriptor Table Register) //
        // No LDTs for now...
        new_task->tss.ldtr = 0;

        // Initialize debug trap //
        // If set to 1 the processor generates a debug exception when a //
        // task switch to this task occurs...                           //
        new_task->tss.trace = 0;

        // Setup starting address //
        new_task->tss.cs = (privilege == KERNEL_PRIVILEGE) ? KERNEL_CODE : USER_CODE | 3;
        new_task->tss.eip = (dword)address;

        // --- Get a pid --- //
        new_task->pid = new_pid();

        // --- Store the name --- //
        // The last character must be ever '\0' (end of string) //
        strncpy(new_task->name, pname, sizeof(new_task->name)-2);

        // --- Set the type --- //
        new_task->type = PROCESS_T;

        // --- Set the parent process --- //
        new_task->father = curr_task;

        // --- Set the console --- //
        if( curr_task )
                new_task->console = curr_task->console;

        // --- Insert the task into the ready queue --- //
        new_task->state = READY;
        add_queue(&ready_queue, new_task);

        sched_leave_critical_region();
        return (new_task);
}

// --- Task execution module ------------------------------------------ //

//! \brief Create a new virtual space.
//! \return
//!     The physical address of the page directory for the new
//!     virtual space.
//! \exception NULL If an error occurs (in particular out-of-memory).
size_t new_vspace()
{
        size_t PDBR_frame;
        uint32_t *PDBR;
        int i;

        // Create the virtual space of the task                         //
        PDBR = (uint32_t *)get_temp_page();
        if (PDBR == NULL)
        {
                // Out of memory!!!                                     //
                return( NULL );
        }
        PDBR_frame = vir_to_phys( (dword)PDBR );

        // Initialize PDBR                                              //
        memset(PDBR, 0, PAGE_SIZE);
        for (i=K_VIR_START/(PAGE_SIZE*1024); i<1024; i++)
                PDBR[i] = K_PDBR[i];
        // Map page directory into itself                               //
        PDBR[1023] = PDBR_frame | P_PRESENT | P_WRITE;

        // Free the page, but doesn't destroy the physical frame        //
        free_temp_page( PDBR, FALSE );

        return( PDBR_frame );
}

//! \brief Initialize the stack for a new process.
//! \param argc
//!     The number of arguments passed to the new process.
//! \param argv
//!     A pointer to the argument strings.
//!     <b>NOTE: The content of \p argv may be changed!!!</b>
//! \param stack_start
//!     Where the stack is placed in memory.
//! \param stack_size
//!     The size of the stack in bytes.
//! \param privilege
//!     The privilege of the task.
//! \return The starting stack pointer after initialization.
uint32_t *task_setup_stack(int argc, char **argv, addr_t stack_start, size_t stack_size, int privilege)
{
        static uint8_t __i386_quit[] = {
                0xb8, 0x00, 0x00, 0x00, 0x00,   // mov $0x0, %eax
                0x89, 0xe5,                     // mov %esp, %ebp
                0xcd, 0x80,                     // int $0x80
        };
        size_t *stack = (uint32_t *)( (stack_start - sizeof(size_t)) -
                                        ALIGN_UP(sizeof(size_t), sizeof(__i386_quit)) -
                                        sizeof(size_t) );
        size_t *exit_point = stack;
        size_t *user_argv;
        int i;

        // We have not to null the stack to enforce page mapping for a  //
        // user-mode task, because a stack fault is managed like a      //
        // normal page fault.                                           //
        // But In kernel mode a stack fault can cause a system reboot   //
        // so we must enforce the page mapping in this case.            //
        if ( privilege == KERNEL_PRIVILEGE )
                memset((void *)(stack_start-stack_size), 0, stack_size/sizeof(size_t));

        // Copy the exit code into the stack, because if we are in      //
        // user-mode we cannot access to the kernel space without       //
        // causing a page level protection fault.                       //
        memcpy((void *)stack, __i386_quit, sizeof(__i386_quit));

        // Copy external parameters strings                             //
        for( i=0; i<argc; i++ )
        {
                stack = (size_t *)((size_t)stack - strlen(argv[i]) - 1);
                strcpy((char *)stack, argv[i]);
                argv[i] = (char *)stack;
        }

        // Round down the stack pointer to the stack boundaries         //
        stack = (size_t *)( TRUNC((size_t)stack, sizeof(size_t)) );

        // Copy parameter string pointers                               //
        for( i=0; i<argc; i++ )
        {
                *(--stack) = (size_t)(argv[argc-i-1]);
        }

        // Set the process argv pointer                                 //
        user_argv = stack;
        *(--stack) = (size_t)user_argv;
        // Copy number of parameters value                              //
        *(--stack) = argc;
        // Copy the exit point address                                  //
        *(--stack) = (size_t)(exit_point);

        // Return the initial stack pointer                             //
        return( stack );
}

//! \brief Execute a file creating a new task.
//! \param filename
//!     The name of the file to execute.
//! \param argc
//!     The number of arguments passed to the new process.
//! \param argv
//!     The arguments passed to the new process.
//! \param argv
//!     A pointer to the argument strings.
//! \param privilege
//!     The privilege level of the new task:
//!             \li #KERNEL_PRIVILEGE
//!             \li #USER_PRIVILEGE
//! \return A pointer to the new-created task structure.
//! \exception NULL If an error occurs (in particular out-of-memory).
/*!
 *      This routine can execute only ELF32 files. The file is loaded
 *      in a temporary buffer, then the sections are copied into memory
 *      and the task structure is initialized. At the end of this the
 *      new task is putted into the ready queue.
 */
task_t *new_task(char *filename, int argc, char **argv, int privilege)
{
        uint32_t temp_PDBR;
        task_t  *task;
        byte    *pl0_stack;
        size_t  PDBR, entry;
        void    *filebuffer;
        int     filesize = get_file_size(filename);

        if ( filesize < 0 )
                return(NULL);

        // Load the ELF32 file into the buffer //
        filebuffer = kmalloc(filesize);
        if ( elf32_load_file(filename, filebuffer)<0 )
        {
                kfree(filebuffer);
                return(NULL);
        }

        sched_enter_critical_region();

        // Create the task structure //
        task = kmemalign(PAGE_SIZE, sizeof(task_t));
        if ( task == NULL )
        {
                sched_leave_critical_region();
                kfree(filebuffer);
                return(NULL);
        }
        memset(task, 0, sizeof(task_t));

        // Create the PL0-stack //
        pl0_stack = kmalloc(STACK_SIZE);
        if (pl0_stack == NULL)
        {
                // Out of virtual memory!!! //
                // Free the previous allocated space //
                kfree((void *)task);
                kfree(filebuffer);

                sched_leave_critical_region();
                return(NULL);
        }
        // Null the stack to enforce the page mapping //
        memset(pl0_stack, 0, STACK_SIZE);

        // Setup the PL0-stack //
        task->tss.ss0 = KERNEL_STACK;
        task->tss.esp0 = task->pl0_stack = (dword)(pl0_stack+STACK_SIZE-sizeof(uint32_t));

        // Setup the TSS //
        task->tss_sel = setup_GDT_entry(sizeof(tss_IO_t), (dword)&(task->tss), TSS_SEG, 0);

        // Create the new virtual space //
        PDBR = new_vspace();
        if ( PDBR == NULL )
        {
                // Out of memory !!! //

                // Destroy the TSS //
                remove_GDT_entry(task->tss_sel);
                // Free the previous allocated space //
                kfree((void *)(pl0_stack));
                kfree((void *)task);
                kfree(filebuffer);

                sched_leave_critical_region();
                return(NULL);
        }

        // Temporary switch to the new address space //
        __asm__ __volatile__ ("movl %%cr3, %0" : "=r"(temp_PDBR) : );
        __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(PDBR));

        // Copy the file sections into memory //
        entry = elf32_copy_sections(filebuffer);
        if ( entry == NULL )
        {
                // Restore the old address space //
                __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(temp_PDBR));

                // Free the PDBR frame //
                push_frame(PDBR/PAGE_SIZE);
                // Destroy the TSS //
                remove_GDT_entry(task->tss_sel);
                // Free the previous allocated space //
                kfree((void *)(pl0_stack));
                kfree((void *)task);
                kfree(filebuffer);

                sched_leave_critical_region();
                return(NULL);
        }

        // Create the task stack.
        task->tss.ss = (privilege == KERNEL_PRIVILEGE) ? KERNEL_STACK : USER_STACK | 3;
        if ( privilege == KERNEL_PRIVILEGE )
                task->tss.esp = (uint32_t)task_setup_stack(argc, argv, task->pl0_stack, STACK_SIZE, privilege);
        else
                task->tss.esp = (uint32_t)task_setup_stack(argc, argv, TASK_STACK_START, STACK_SIZE, privilege);

        // Initialize the user heap.
        umalloc_init( TASK_HEAP_START, TASK_HEAP_DEFAULT_SIZE );

        // Restore the old address space //
        __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(temp_PDBR));

        // Setup the task PDBR //
        task->tss.cr3 = PDBR;

        // Setup the IO port mapping //
        task->tss.io_map_addr = sizeof(tss_t);

        // Setup general registers //
        if ( privilege == KERNEL_PRIVILEGE )
                task->tss.ds = task->tss.es =
                task->tss.fs = task->tss.gs = KERNEL_DATA;
        else
                task->tss.ds = task->tss.es =
                task->tss.fs = task->tss.gs = USER_DATA | 3;

        task->tss.eflags = EFLAGS_IF | 0x02;
        if ( privilege == USER_PRIVILEGE )
                // User privilege must be the I/O privilege set to the  //
                // lower level                                          //
                task->tss.eflags |= EFLAGS_IOPL3;

        // Initialize general purpose registers //
        task->tss.eax = task->tss.ebx =
        task->tss.ecx = task->tss.edx =
        task->tss.esi = task->tss.edi = 0;

        // Initialize LDTR (Local Descriptor Table Register) //
        // No LDTs for now...
        task->tss.ldtr = 0;

        // Initialize debug trap //
        // If set to 1 the processor generate a debug exception when a task switch to this task occurs...
        task->tss.trace = 0;

        // Setup starting address //
        task->tss.cs = (privilege == KERNEL_PRIVILEGE) ? KERNEL_CODE : USER_CODE | 3;
        task->tss.eip = entry;

        // Get a pid //
        task->pid = new_pid();

        // Store the name //
        // The last character must be ever '\0' (end of string) //
        strncpy(task->name, filename, sizeof(task->name)-2);

        // Set the type //
        task->type = PROCESS_T;

        // Set the parent process //
        task->father = curr_task;

        // Set the console //
        task->console = curr_task->console;

        // Insert the task into the ready queue //
        task->state = READY;
        add_queue(&ready_queue, task);

        // Well done! //
        kfree(filebuffer);
        sched_leave_critical_region();

        return( task );
}

// --- END of Task execution module ----------------------------------- //

//! \brief Kill a task by the pid.
//! \param pid The process id.
//! \return
//!     \li #TRUE if the task has been successfully killed
//!     \li #FALSE if the task cannot be killed.
/*!
 *      This routine move the task having the \a pid from the ready queue
 *      to the zombie queue. Then the kpager() daemon should provide
 *      to free the memory and resources owned by this task.
 */
bool kill(pid_t pid)
{
        // Queues where to search the processes                         //
        static queue_t **q[] = { &ready_queue, &wait_queue };
        task_t *p = curr_task;
        bool retval = FALSE;
        register int i, j, n;

        // No running processes(???) => quit!                           //
        if ( p==NULL )
                return(FALSE);

        sched_enter_critical_region();

        // Explore every task queue                                     //
        for ( i=0; i<_countof(q); i++)
                for ( j=0, n=count_queue(q[i]); j<n; j++ )
                {
                        // Get the next task in the queue               //
                        p = pick_queue( q[i] );

                        if ( p->pid == pid )
                        {
                                // Move the task from the queue to the  //
                                // zombie queue                         //
                                if ( rem_queue(q[i], p) )
                                {
                                        add_queue(&zombie_queue, p);
                                        p->state = ZOMBIE;
                                        // Wake-up the kpager daemon    //
                                        wakeup_task( kpagd );
                                        // Wake-up the father           //
                                        if ( p->father != NULL )
                                                wakeup_task( p->father );
                                        // Task killed!                 //
                                        retval = TRUE;
                                }
                        }
                        else
                        {
                                // If the process p is a child of the   //
                                // process to kill we have to set its   //
                                // father to NULL                       //
                                if ( p->father != NULL )
                                        if ( (p->father)->pid == pid )
                                                p->father = NULL;
                        }
                }

        // Check if the task has killed itself                          //
        if (curr_task->pid == pid)
        {
                sched_leave_critical_region();
                // Wait for the dispatcher                              //
                do_idle();
        }

        sched_leave_critical_region();
        return( retval );
}

//! \brief Kill the current running task.
//! \param n The return code.
/*!
 *      This routine move the current task from the ready queue
 *      to the zombie queue. Then the kpager() daemon should provide
 *      to free the memory and resources owned by this task.
 */
void auto_kill(int n)
{
        kill( curr_task->pid );
}

//! \brief Wait for the exit of a child.
//! \param pid
//!     \li The child process id
//!     \li -1 to wait for the exit of a generic child.
//! \param status Reports the status of the child.
//! \param options Options flags.
//! \return
//!     The pid of the child or -1 if the process has not been
//!     found.
/*!
 *      \todo \a status flags and \a options flags not yet implemented!
 */
pid_t waitpid(pid_t pid, int *status, int options)
{
        // Queues where to search the processes                         //
        static queue_t **q[] = { &ready_queue, &wait_queue };
        task_t *p;
        int i, j, n;
        bool found = FALSE;
        dword IF = GET_IF();

        // A task can't wait for yourself!                              //
        if (curr_task->pid == pid) return(0);

repeat:
        sched_enter_critical_region();
        // Search into every task queue                                 //
        for( i=0; i<_countof(q); i++ )
        {
                for( j=0, n = count_queue( q[i] ); j<n; j++ )
                {
                        p = pick_queue( q[i] );
                        if ( (p->father == curr_task) && ((pid==-1) || (p->pid==pid)) )
                        {
                                // Found!                               //
                                found = TRUE;

                                // Update the pid of the child that we  //
                                // are waiting (when pid is -1).        //
                                pid = p->pid;

                                // Move the current task (father) into  //
                                // the wait queue and wait              //
                                if ( rem_queue(&ready_queue, curr_task) )
                                {
                                        add_queue(&wait_queue, curr_task);
                                        curr_task->state = WAIT;
                                }
                                sched_leave_critical_region();

                                // Sleeped!                             //
                                // Now wait for the dispatcher          //
                                enable();
                                idle();
                                // Task waked-up! Check if the child    //
                                // that we are waiting is dead          //
                                goto repeat;
                        }
                }

        }
        sched_leave_critical_region();
        SET_IF(IF);

        // Return the child pid or -1 if the process has not been found //
        return( (found) ? pid : -1 );
}

//! \brief Sleep a process if it is awake.
//! \param p The structure of the task to sleep.
void sleep_task(task_t *p)
{
        p->state = WAIT;
}

//! \brief Wakeup a process if it is sleeping.
//! \param p The structure of the task to wakeup.
void wakeup_task(task_t *p)
{
        p->state = READY;
}
/** @} */ // end of MTTaskRoutines

// --- Scheduling routines ---------------------------------------------//

/** \ingroup Multitasking
 *  \defgroup MTScheduling The Scheduler
 *  The routines for the tasks scheduling.
 *  @{
 */

//! A semaphore to enable or disable scheduling (used to manage
//! critical regions).
semaphore_t sched_enabled;

//! \brief Disable the scheduling of the other tasks.
//! \warning
//!     \b ATTENTION!!! Remember to call sched_leave_critical_region()
//!     when the task exits from the critical region. Otherwise the
//!     whole system could be blocked, because the scheduling of the
//!     other tasks is disabled after a task calls this function.
void sched_enter_critical_region()
{
        DOWN( &sched_enabled );
}

//! \brief Re-enable scheduling for the other tasks.
void sched_leave_critical_region()
{
        UP( &sched_enabled );
}

//! \brief Return if the scheduling is enabled or not.
//! \return
//!     \li #TRUE if the scheduling is enabled
//!     \li #FALSE otherwise.
bool is_sched_enabled()
{
        if( atomic_read(&sched_enabled) )
                return( TRUE );
        else
                return( FALSE );
}

//! \brief This is a simple round robin scheduler.
/*!
 *      This routine is called by the dispatcher() every time
 *      a task must be scheduled.
 */
static __inline__ void scheduler()
{
        task_t *p=NULL;
        int count;

        // Look for the tasks that need to sleep.
        count = count_queue( &ready_queue );
        for ( ; count; --count )
        {
                p = pick_queue( &ready_queue );
                if ( p->state==WAIT )
                {
                        rem_queue( &ready_queue, p );
                        add_queue( &wait_queue,  p );
                }
        }

        // Look for the tasks that need to wake-up.
        count = count_queue( &wait_queue );
        for ( ; count; --count )
        {
                p = pick_queue( &wait_queue );
                if ( p->state==READY )
                {
                        rem_queue( &wait_queue,  p );
                        add_queue( &ready_queue, p );
                }
        }

        // Select a new task to run (Round Robin).
        curr_task = pick_queue( &ready_queue );
        if (curr_task == NULL) curr_task=idle_task;
}
/** @} */ // end of MTScheduling

/** \ingroup Multitasking
 *  \defgroup MTDispatcher The Dispatcher
 *  The dispatcher routine.
 *  @{
 */

//! \brief The dispatcher.
/*!
 *      This routine supplies to change the context of the tasks.
 *      It is invoked at every clock tick.\n
 *      You can change the frequency of the ticks changing the value
 *      of the #HZ definition.
 */
void dispatcher()
{
        task_t *prev_task;

        // Call the clock task at every tick                            //
        clock_thread();

        // Can we switch to another process?!                           //
        if ( atomic_read(&sched_enabled) )
        {
                // Store the previous task                              //
                prev_task = curr_task;
                // Select a new task                                    //
                scheduler();

                if ( prev_task != curr_task )
                {
                        if ( prev_task->tss.cr3 != curr_task->tss.cr3 )
                        {
                                // Update the page directory of the     //
                                // new task with the kernel page        //
                                // directory in the kernel memory area. //
                                __asm__ __volatile__ (
                                        "movl %%eax, %%cr3\n"
                                        "cld\n"
                                        "rep movsl\n"
                                        "movl %%ebx, %%cr3" : :
                                        "a"(curr_task->tss.cr3),
                                        "b"(prev_task->tss.cr3),
                                        "D"((dword *)PAGE_DIR_MAP+(K_VIR_START/(PAGE_SIZE*1024))),
                                        "S"((dword *)K_PDBR+(K_VIR_START/(PAGE_SIZE*1024))),
                                        "c"((PAGE_DIR_MAP/(PAGE_SIZE*1024)) - (K_VIR_START/(PAGE_SIZE*1024)))
                                );
                                __asm__("" : : : "%eax", "%ebx", "%ecx", "%edi", "%esi");
                        }

                        // Re-enable master interrupt controller        //
                        outportb(PORT_8259_M, EOI);
                        // Perform the task switch                      //
                        jmp_to_tss(curr_task->tss_sel);
                }
        }
}
/** @} */ // end of MTDispatcher

// --- Initialization --------------------------------------------------//

/** \ingroup Multitasking
 *  \defgroup MTInit Task Initialization
 *  The multitasking initialization routine.
 *  @{
 */

//! \brief Initialize the multitasking management.
void init_multitasking()
{
        // Initialize pid counter.
        atomic_set(&last_pid, 0);

        // Initialize scheduler critical region flag.
        INIT_MUTEX( &sched_enabled );

        // Create the "init" task.
        curr_task = create_process(NULL, NULL, 0, "init", KERNEL_PRIVILEGE);
        // Set the console.
        curr_task->console=1;
        // Set the type.
        curr_task->type = KTHREAD_T;

        // Load task register.
        __asm__ __volatile__ ("ltr %%ax" : : "a" (curr_task->tss_sel));
        __asm__ __volatile__ ("" : : : "ax");

        // Load virtual space.
        __asm__ __volatile__ ("movl %0, %%cr3" : : "r"(curr_task->tss.cr3));

        // Initialize the IDLE task.
        // The IDLE task is a special task,
        // it's always ready but never present in the ready queue.
        idle_task = create_kthread(&do_idle, "idle");
        idle_task->console=0;
        rem_queue(&ready_queue, idle_task);

        // Initialize KPager thread
        kpagd = create_kthread(&kpager, "kpagerd");
        kpagd->console = 0;

        // Install the dispatcher.
        install_irq_handler( TIMER_IRQ, (void *)&dispatcher );
}
/** @} */ // end of MTInit

// --- Debug procedures ------------------------------------------------//

/** \ingroup Multitasking
 *  \defgroup MTDebug Debug
 *  Debug procedures for multitasking.
 *  @{
 */

//! \brief
//!     Print the state of every process from the ready, wait
//!     and zombie queues.
void ps()
{
        task_t *p;
        int count, i;

        if ((p = curr_task)==NULL) return;

        // Header //
        kprintf("\n\rPID       STATE       CONSOLE     CMD");

        sched_enter_critical_region();

        // Ready processes //
        for(i=0, count=count_queue(&ready_queue); i<count; i++)
        {
                // Get the next task in the ready queue //
                p = pick_queue(&ready_queue);

                // Print process informations //
                kprintf("\n\r%u", p->pid);
                gotoxy(12, -1);
                kputchar('R');
                gotoxy(22, -1);
                if (p->console)
                        kprintf("tty%u", p->console);
                else
                        kputchar('?');
                gotoxy(34, -1);
                kprintf("%s", p->name);
        }

        // Wait processes //
        for(i=0, count=count_queue(&wait_queue); i<count; i++)
        {
                // Get the next task in the wait queue //
                p = pick_queue(&wait_queue);

                // Print process informations //
                kprintf("\n\r%u", p->pid);
                gotoxy(12, -1);
                kputchar('W');
                gotoxy(22, -1);
                if (p->console)
                        kprintf("tty%u", p->console);
                else
                        kputchar('?');
                gotoxy(34, -1);
                kprintf("%s", p->name);
        }

        // Zombie processes //
        for(i=0, count=count_queue(&zombie_queue); i<count; i++)
        {
                // Get the next task in the zombie queue //
                p = pick_queue(&zombie_queue);

                // Print process informations //
                kprintf("\n\r%u", p->pid);
                gotoxy(12, -1);
                kputchar('Z');
                gotoxy(22, -1);
                if (p->console)
                        kprintf("tty%u", p->console);
                else
                        kputchar('?');
                gotoxy(34, -1);
                kprintf("%s", p->name);
        }

        sched_leave_critical_region();

        kprintf("\n\r");
}
/** @} */ // end of MTDebug

---