---

main.c

Go to the documentation of this file.

/*!     \file kernel/main.c
 *      \brief Kernel Main routine
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update: 2003-11-05
 *      \note Copyright (&copy;) 2003 Andrea Righi
 */

// --- MAIN GROUPS DEFINITION (for Doxygen)---------------------------- //

/*!     \defgroup Kernel                Kernel
 *      The Minirighi kernel.
 *      @{
 *      @}
 */
        /*!     \ingroup Kernel
        *       \defgroup Handlers              Handlers
        *       System interrupt handlers.
        *       @{
        *       @}
        */
/*!     \defgroup Memory                Memory Manager
 *      The Memory manager.
 *      @{
 *      @}
 */
/*!     \defgroup Multitasking          Multitasking
 *      The Multitasking Manager.
 *      @{
 *      @}
 */
/*!     \defgroup FileSystem            File Systems
 *      The File systems.
 *      @{
 *      @}
 */
/*!     \defgroup Drivers               Device Drivers
 *      The Device drivers.
 *      @{
 *      @}
 */
/*!     \defgroup Network               Networking
 *      Network protocols.
 *      \image html network.jpg "Network layers on Minirighi"
 *      @{
 *      @}
 */
/*!     \defgroup UserInterface         User Interface
 *      Shell, GUI, etc...
 *      @{
 *      @}
 */
/*!     \defgroup Library               Library
 *      The set of libraries for Minirighi.
 *      @{
 *      @}
 */
        /*!     \ingroup Library
        *       \defgroup LibC                  LIBC
        *       The ANSI-C library.
        *       @{
        *       @}
        */
        /*!     \ingroup Library
        *       \defgroup LibMinirighi          LIBMinirighi
        *       The Minirighi user library.
        *       @{
        *       @}
        */

// --- END of MAIN GROUPS DEFINITION (for Doxygen)--------------------- //

#include <const.h>
#include <stdarg.h>

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

#include <kernel/clock.h>
#include <kernel/console.h>
#include <kernel/dma.h>
#include <kernel/ext2.h>
#include <kernel/fat.h>
#include <kernel/floppy.h>
#include <kernel/Ide.h>
#include <kernel/kernel_map.h>
#include <kernel/keyboard.h>
#include <kernel/kmalloc.h>
#include <kernel/multiboot.h>
#include <kernel/queue.h>
#include <kernel/semaphore.h>
#include <kernel/serial.h>
#include <kernel/speaker.h>
#include <kernel/task.h>
#include <kernel/time.h>
#include <kernel/video.h>

#include <kernel/shell.h>

/** \ingroup Kernel
 *  \defgroup KernelMain Kernel Initialization
 *  The initialization routine.
 *  @{
 */

//! A pointer to the current running task structure. Declared in task.c.
extern task_t *curr_task;
//! A pointer to ready queue. Declared in task.c.
extern queue_t *ready_queue;
//! The multiboot information pointer from GRUB.
extern multiboot_info_t *boot_info;
//! The physical memory dimension. Initialized in paging.c.
extern dword PHYS_MEM_DIM;

int i; //!< Used to create initial consoles.

//! \brief Print the [ OK ] tag.
void print_ok()
{
        set_color(DEFAULT_COLOR);
        kprintf("\r                                             [    ]");
        set_color(GREEN);
        gotoxy(50, -1);
        kprintf("OK\n\r");
        set_color(DEFAULT_COLOR);
}

//! \brief Print the [ ERROR ] tag.
void print_error()
{
        set_color(DEFAULT_COLOR);
        kprintf("\r                                             [     ]");
        set_color(LIGHT_RED);
        gotoxy(49, -1);
        kprintf("ERROR\n\r");
        set_color(DEFAULT_COLOR);
}

//! \brief
//!     This is the beginning of the kernel!!!
//!     You can figure it as the \e init task...
//! \warning
//!     To obviate memory faults, \b first \b of \b all, we MUST initialize
//!     paging with the init_paging() routine.
void k_main()
{
        // First of all we MUST initialize paging!!!                    //
        init_paging();

        // Initialize video                                             //
        init_video();
        init_main_console();

        // Now we can print some informations...                        //
        kprintf("\n\r<Starting initialization>\n\r");
        kprintf("\n\rKernel is running at virtual address:");
        kprintf("\r                                             %#010x\n\r", (dword)&k_main);

        // Get some multiboot informations                              //
        boot_info = (multiboot_info_t *)PHYSICAL((dword)boot_info);
        if (boot_info->flags & 0x02)
        {
                // set_color(DEFAULT_COLOR);
                kprintf(        "Total amount of conventional memory:");
                kprintf("\r                                             %uKB\n\r", ((dword)boot_info->mem_lower));
                kprintf(        "Total amount of extended memory:");
                kprintf("\r                                             %uMB\n\r", PHYS_MEM_DIM/1024/1024);
                kprintf("\n\r");

        }
        else
        {
                set_color(LIGHT_RED);
                kprintf("\n\rError reading multiboot informations... halting!");
        }

        // Initialize clock                                             //
        kprintf("Initializing system clock...");
        init_clock();
        print_ok();

        // Reprogram the PIC 8259 (interrupt controller)                //
        kprintf("Reprogramming PIC 8259...");
        reprogram_PIC();
        print_ok();

        // Installing GDT                                               //
        kprintf("Installing kernel GDT...");
        install_GDT();
        print_ok();

        // Installing IDT                                               //
        kprintf("Installing kernel IDT...");
        install_IDT();
        print_ok();

        // Initialize memory manager                                    //
        kprintf("Initializing memory manager...");
        kmalloc_init();
        print_ok();

        // Initialize memory manager                                    //
        kprintf("Initializing DMA allocator...");
        dma_alloc_init();
        print_ok();

        // Initialize multitasking                                      //
        kprintf("Initializing multitasking...");
        init_multitasking();
        print_ok();

        // Initialize the Real-Time Clock                               //
        kprintf("Initializing Real-Time Clock...");
        time_init();
        print_ok();

        // Initialize the keyboard                                      //
        kprintf("Initializing keyboard...");
        init_keyboard();
        print_ok();

        // Initialize the floppy                                        //
        kprintf("Initializing floppy driver...");
        if ( init_floppy() )
                print_ok();
        else
                print_error();

        // Auto-mount FAT12 on the floppy                               //
        kprintf("Auto-mounting FAT12 file-system on floppy...");
        if ( Read_FAT() )
                print_ok();
        else
                print_error();

        // ******************* Luca Giovacchini *************************
        // Initialize the ide driver //
        kprintf("Initializing ide driver...");
        // init ide return error that are not critical so we will ignore that
        InitIde();
        print_ok();
        ShowIdeSubData();
        kprintf("\n\r");
        // **************************************************************

        // ********************** Filippo Brogi *************************
        // Initialize the ext2 file-system                              //
        kprintf("Auto-mounting ext2 file-system on /dev/hda1...");
        if ( init_ext2() )
                print_ok();
        else
        {
                kprintf("\n\rUnable to read the super block!!!");
                print_error();
        }
        // **************************************************************

        // Initialize virtual consoles                                  //
        kprintf("Creating virtual consoles...");
        create_virtual_console();
        set_color(GREEN);
        print_ok();

        // Initialization complete                                      //
        kprintf("\n\r<Initialization complete>\n\r");
        set_color(WHITE);
        kprintf("\n\r*** Welcome to %s - Kernel [v%s] ***\n\r", KERNEL_NAME, KERNEL_VERSION);
        set_color(DEFAULT_COLOR);

        // Create a shell task for every console                        //
        for(i=1; i<=10; i++)
        {
                curr_task->console = i;
                if ( i>1 ) clrscr();
                create_kthread(&shell, "MiniShell");
                // create_process(&shell, &shell, 0, "MiniShell", KERNEL_PRIVILEGE);
        }
        curr_task->console=1;
        set_curr_console(1);

        // Well done!!!                                                 //
        auto_kill( 0 );
}
/** @} */ // end of KernelMain

---