---

v86.c

Go to the documentation of this file.

/*!     \file arch/i386/kernel/v86.c
 *      \brief Virtual 8086 mode.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update:\n
 *              2003-12-16 Andrea Righi:
 *                      Added temporary memory operators to get and
 *                      free the temporary mapped pages.\n
 *      \note Copyright (C) 2003 Andrea Righi
 */

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

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

#include <kernel/console.h>
#include <kernel/kmalloc.h>
#include <kernel/queue.h>
#include <kernel/kernel_map.h>
#include <kernel/task.h>

#include <arch/v86.h>

// --- Virtual 8086 mode task creation -------------------------------- //

extern int new_pid();
extern queue_t *ready_queue;
extern task_t *curr_task;

//! The address where the task stack is placed.
#define V86_TASK_STACK_START    0x90000

//! \brief Create a new virtual-8086 mode process.
//! \param address
//!     The address of the starting point for the task.
//! \param buffer
//!     An address to a buffer where is placed the executable code.
//! \param size
//!     The size of the executable code buffer.
//! \param v86name
//!     The name of the new v86 task.
//! \return A pointer to the new-created task structure.
//! \exception NULL If an error occurs (in particular out-of-memory).
/*!
 *      This routine initializes a new v86-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_v86_process(void *address, void *buffer, size_t size, char *v86name)
{
        extern dword K_PDBR[PAGE_SIZE/sizeof(dword)];
        task_t *new_task;
        byte *pl0_stack;
        dword *PDBR;
        dword cr3, PDBR_frame, i;

        sched_enter_critical_region();

        // --- Create the task structure --- //
        new_task = kmemalign(PAGE_SIZE, sizeof(task_t));
        if (!new_task)
        {
                // Out of virtual memory!!! //
                set_color(LIGHT_RED);
                kprintf("\n\rOut of virtual memory!!! Cannot create v86task [%s].", v86name);
                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)
        {
                // Out of virtual memory!!! //
                set_color(LIGHT_RED);
                kprintf("\n\rOut of virtual memory!!! Cannot create v86task [%s].", v86name);
                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 of physical memory!!! Cannot create v86task [%s].", v86name);
                set_color(DEFAULT_COLOR);
                // Free the previous allocated space //
                kfree((void *)(new_task->pl0_stack-STACK_SIZE));
                kfree((void *)new_task);
                // Destroy the TSS //
                remove_GDT_entry(new_task->tss_sel);

                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));

        // Map the IVT (Interrupt Vector Table) //
        for (i=BIOS_IVT_START; i<BIOS_IVT_END; i+=PAGE_SIZE)
                map_page(i, i, P_PRESENT | P_WRITE | P_USER);
        // Map the VIDEO BUFFER //
        for (i=VIDEO_BUF_START; i<VIDEO_BUF_END; i+=PAGE_SIZE)
                map_page(i, i, P_PRESENT | P_WRITE | P_USER);
        // Map the BIOS ROM memory //
        for (i=BIOS_ROM_START; i<BIOS_ROM_END; i+=PAGE_SIZE)
                map_page(i, i, P_PRESENT | P_WRITE | P_USER);

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

        // Create the stack //

        // It is not necessary to null the stack to enforce page        //
        // mapping, because V86-mode tasks run permanently at CPL3.     //
        // So a stack-fault is managed like a normal page-fault.        //
        new_task->tss.ss = SEGMENT((dword)V86_TASK_STACK_START-sizeof(uint32_t));
        new_task->tss.esp = OFFSET((dword)(V86_TASK_STACK_START-sizeof(uint32_t)));

        // Map the user code and data //
        if (address != buffer)
        {
                memcpy(address, buffer, size);
        }

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

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

        // Setup the IO port mapping //
        new_task->tss.io_map_addr = sizeof(tss_t);
        // for (i=0; i<8192; i++) new_task->tss.io_map[i] = 0;

        // Initialize segment registers //
        new_task->tss.ds = new_task->tss.es =
        new_task->tss.fs = new_task->tss.gs = SEGMENT((dword)address);

        // 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;

        // Virtual 8086 mode task - IOPL = 0 //
        // IOPL < 3 => all IOPL-sensitive instructions trap to the kernel with a GPF //
        new_task->tss.eflags = EFLAGS_IOPL0 | EFLAGS_VM | EFLAGS_IF | 0x02;

        // 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 program counter //
        new_task->tss.cs = SEGMENT((dword)address);
        new_task->tss.eip = OFFSET((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, v86name, sizeof(new_task->name)-2);

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

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

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

        sched_leave_critical_region();

        return (new_task);
}


// --- Virtual 8086 monitor ------------------------------------------- //

//! \brief The virtual-8086 monitor.
void v86_monitor()
{
        v86_context *context = (v86_context *)(curr_task->pl0_stack-sizeof(v86_context));
        byte *ip;
        word *stack, *ivt;

        ip = (byte *) LINEAR(context->cs, context->ip);
        stack = (word *) LINEAR(context->ss, context->sp);
        ivt = (word *) BIOS_IVT_START;

        while(TRUE)
        {
                switch (ip[0])
                {
                case 0x9C:      // PUSHF //
                        context->sp = ((context->sp & 0xFFFF) - 2) & 0xFFFF;
                        stack--;
                        stack[0] = (word) context->eflags;
                        context->ip = (word)(context->ip + 1);
                        return;

                case 0x9D:      // POPF //
                        context->eflags = stack[0] | EFLAGS_VM;
                        context->sp = ((context->sp & 0xFFFF) + 2) & 0xFFFF;
                        context->ip = (word)(context->ip + 1);
                        return;

                case 0xCD:      // INT n //
                        if (ip[1]==MINIRIGHI_INT)
                                // Exit to system (syscalls are reserved for 32-bit tasks!!!) //
                                auto_kill( 1 );
                        else
                        {
                                if (ip[1]==DOS_INT)
                                {
                                        // Emulate DOS 0x20 interrupt... not yet implemented! //
                                        // If you like to do it... here are the source... good luck! :)
                                        kprintf("\n\rV86 monitor -> INT 0x20 emulation not yet implemented @CS=%#06x,IP=%#06x",
                                                context->cs, context->ip);
                                        kprintf("\n\rKilling task: [%s] (%i)\n\r", get_pname(), get_pid());
                                        auto_kill( 1 );
                                }
                                stack -= 3;
                                context->sp = ((context->sp & 0xFFFF) - 6) & 0xFFFF;
                                stack[0] = (word) (context->ip + 2);
                                stack[1] = (word) context->cs;
                                stack[2] = (word) context->eflags;

                                context->cs = ivt[ip[1] * 2 + 1];
                                context->ip = ivt[ip[1] * 2];
                                return;
                        }

                case 0xCF:      // IRET //
                        context->ip = stack[0];
                        context->cs = stack[1];
                        context->eflags = stack[2] | EFLAGS_VM;
                        context->sp = ((context->sp & 0xFFFF) + 6) & 0xFFFF;
                        return;

                case 0xFA:      // CLI //
                        context->eflags = (context->eflags & (~EFLAGS_IF));
                        context->ip = (word)(context->ip + 1);
                        return;

                case 0xFB:      // STI //
                        context->eflags = (context->eflags | EFLAGS_IF);
                        context->ip = (word)(context->ip + 1);
                        return;

                case 0xF4:      // HLT //
                        // If interrupts are disabled the current task  //
                        // wants to disable the CPU, so kill this task! //
                        if ((context->eflags & EFLAGS_IF) != EFLAGS_IF)
                        {
                                kprintf("\n\rAttempt to disable the CPU.");
                                kprintf("\n\rKilling task: [%s] (%i)\n\r", get_pname(), get_pid());
                                auto_kill( 1 );
                        }
                        // Wait for an interrupt //
                        context->ip = (word)(context->ip + 1);
                        enable();
                        __asm__("hlt");
                        return;

                default:
                        kprintf("\n\rV86 monitor -> %#04x Unknown instruction@CS=%#06x,IP=%#06x",
                                ip[0], context->cs, context->ip);
                        context->ip = (word)(context->ip + 1);
                        kprintf("\n\rKilling task: [%s] (%i)\n\r", get_pname(), get_pid());
                        auto_kill( 1 );
                        return;
                }
        }
}

---