---

shell.c

Go to the documentation of this file.

/*!     \file shell/shell.c
 *      \brief MiniShell - a very very simple shell.
 *      \author Andrea Righi <drizzt@inwind.it>
 *      \date Last update: 2003-11-15
 *      \note Copyright (C) 2003 Andrea Righi
 */

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

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

#include <kernel/clock.h>
#include <kernel/console.h>
#include <kernel/elf32.h>
#include <kernel/ext2.h>
#include <kernel/fat.h>
#include <kernel/floppy.h>
#include <kernel/Ide.h>
#include <kernel/IdeDebug.h>
#include <kernel/IdeTimer.h> // must remove
#include <kernel/IdeLow.h>   // must remove
#include <kernel/kernel.h>
#include <kernel/keyboard.h>
#include <kernel/kmalloc.h>
#include <kernel/pci.h>
#include <kernel/speaker.h>
#include <kernel/task.h>
#include <kernel/serial.h>
#include <kernel/time.h>

#include <net/arp.h>
#include <net/eth.h>
#include <net/icmp.h>

#include <kernel/shell.h>

/** \ingroup UserInterface
 *  \defgroup UIMiniShell MiniShell
 *  A simple text-based shell.
 *  @{
 */

#define SH_HELP                 0
#define SH_UNAME                1
#define SH_CLEAR                2
#define SH_REBOOT               3
#define SH_DUMP                 4
#define SH_READ                 5
#define SH_WRITE                6
#define SH_PAGES                7
#define SH_MEM                  8
#define SH_CHECKMEM             9
#define SH_FRAMES               10
#define SH_BG                   11
#define SH_V86EXEC              12
#define SH_V86BG                13
#define SH_TEST                 14
#define SH_CPUID                15
#define SH_MOUNT                16
#define SH_LS                   17
#define SH_CAT                  18
#define SH_CD                   19
#define SH_PS                   20
#define SH_KILL                 21
#define SH_RS232                22
#define SH_EXEC                 23
#define SH_PCISCAN              24
#define SH_ETH_ARP              25
#define SH_RTL8139_INIT         26
#define SH_ETH_PING             27
#define SH_HALT                 28
#define SH_RM                   29
#define SH_ELF                  30
// **************** Luca Giovacchini (Ide) ****************
#define SH_IDETEST              31
#define SH_IDEREAD              32
#define SH_IDEWRITE             33
#define SH_IDEDEVICEINFO        34
// ********************************************************
// ****************** Filippo Brogi ***********************
#define SH_LS_EXT2              35
#define SH_CAT_EXT2             36
#define SH_CD_EXT2              37
// ********************************************************
#define SH_TIME                 38

//! The commands supported in MiniShell.
static CMD_t commands[] = {
{ SH_ETH_ARP, "arp", "arp destination", "Send an ARP echo request to ip destination"},
{ SH_BG, "bg", "bg filename", "Execute a program in background"},
{ SH_V86BG, "bg-v86", "bg-v86 filename", "Execute a virtual 8086 mode program in background"},
{ SH_CAT, "cat", "cat filename", "Concatenate FILE to standard output"},
// ******************** Filippo Brogi *********************
{ SH_CAT_EXT2, "cat2", "cat2 filename", "Concatenate ext2 FILE to standard output"},
// ********************************************************
{ SH_CD, "cd", "cd [dir]", "Change the current directory"},
// ******************** Filippo Brogi *********************
{ SH_CD_EXT2, "cd2", "cd2 [dir]", "Change the current ext2 directory"},
// ********************************************************
{ SH_RS232, "chat", "chat <2400|4800|9600|19200|38400|56700|115200>", "Connect to /dev/modem on COM1"},
{ SH_CHECKMEM, "checkmem", "checkmem", "Create a background task to check frames stack integrity"},
{ SH_CLEAR, "clear", "clear", "Clear the screen"},
{ SH_CPUID, "cpuid", "cpuid", "Show informations about the CPU - Only for IA-32 INTEL(R)"},
{ SH_DUMP, "dump", "dump", "Register dump"},
{ SH_ELF, "elf", "elf filename", "Check if filename is a valid ELF32 file"},
{ SH_FRAMES, "frames", "frames", "Dump free frames"},
{ SH_EXEC, "fg", "fg filename", "Execute a program in foreground (you can use ./ instead of fg)"},
{ SH_V86EXEC, "fg-v86", "fg-v86 filename", "Execute a virtual 8086 mode program in foreground"},
{ SH_HALT, "halt", "halt", "Power down the system (if possible, otherwise halt)"},
{ SH_HELP, "help", "help [cmd]", "Show the command help"},
// **************** Luca Giovacchini (Ide) ****************
{ SH_IDEDEVICEINFO, "idedeviceinfo","idedeviceinfo","Display complete info of a specified device"},
{ SH_IDEREAD, "ideread", "ideread", "Read a block from a device on a specified ide channel"},
{ SH_IDETEST, "idetest", "idetest", "test ide routine for debuging purpose"},
{ SH_IDEWRITE, "idewrite", "idewrite", "Write a block to a device on specified ide channel"},
// ********************************************************
{ SH_RTL8139_INIT, "ifconfig", "ifconfig <up|down> [promisc]", "Initialize RTL8139 ethernet card"},
{ SH_KILL, "kill", "kill [pid]", "Kill a task"},
{ SH_LS, "ls", "ls", "List informations about FILEs"},
// ******************** Filippo Brogi *********************
{ SH_LS_EXT2, "ls2", "ls2", "List information about ext2 FILEs"},
// ********************************************************
{ SH_MEM, "mem", "mem", "Dump kernel memory map"},
{ SH_MOUNT, "mount", "mount", "Mount the FAT12 filesystem on the floppy"},
{ SH_ETH_PING, "ping", "ping destination", "PING to the ip destination"},
{ SH_PAGES, "pages", "pages", "Dump dirty pages"},
{ SH_PCISCAN, "pciscan", "pciscan", "Scan for PCI devices"},
{ SH_PS, "ps", "ps", "Print the state of every processes"},
{ SH_READ, "read", "read [block]", "Read a block from the floppy to the buffer"},
{ SH_REBOOT, "reboot", "reboot", "Reboot the system"},
{ SH_RM, "rm", "rm filename", "Remove a file"},
{ SH_TEST, "test", "test [num]", "Create <num> auto-killing tasks"},
{ SH_TIME, "time", "time", "Print the UNIX timestamp (seconds since 1970-01-01 00:00:00)"},
{ SH_UNAME, "uname", "uname", "Print kernel informations"},
{ SH_WRITE, "write", "write [block]", "Write a block from the buffer to the floppy"},

};

/** @} */ // end of UIMiniShell

// **************** Luca Giovacchini (Ide) ****************
void Sh_IdeTest()
{
        kprintf("\n\rThis command is only for debug purpose.\n\r");
}

void Sh_IdeRead()
{
        int Dev;
        int Lba;
        int Err=FALSE;
        byte DataBuffer[512];

        kprintf("\n\rInsert the channel number (0 or 1): 0\b");
        scanf("%i", &Dev);
        kprintf("\n\rChannel %i Selected",Dev);
        if ( Dev==0 )
                SelectAtaChannel(CC_PRIMARY);
        else if ( Dev==1 )
                SelectAtaChannel(CC_SECONDARY);
        else
        {
                kprintf("\n\rBad Channel Number: Channel 0 will be selected");
                SelectAtaChannel(CC_PRIMARY);
        }

        kprintf("\n\rInsert the device number to Read (0 or 1): 0\b");
        scanf("%i", &Dev);
        kprintf("\n\rDevice %i Selected",Dev);
        if ( Dev==0 || Dev==1 )
        {

                kprintf("\n\rInsert Lba : ");
                scanf("%i", &Lba);
                kprintf("\n\rLba Selected %i",Lba);

                Err=ReadSectorsLba(Dev,(int64) Lba,1,(word *) &DataBuffer,TRUE);
                if (Err)
                        ShowIdeErrorMessage(Err,TRUE);
                else
                {
                        kprintf("\n\r HEX DATA");
                        ShowMatrixData(DataBuffer,1,16,20,512,DBG_SHOWMAT_HEX);
                        WaitKeyPress(MSG_PRESSKEY);
                        kprintf("\n\r CHAR DATA");
                        ShowMatrixData(DataBuffer,1,40,20,512,DBG_SHOWMAT_ASCII);
                        WaitKeyPress(MSG_PRESSKEY);
                }
        }
        else
                kprintf("\n\rBad Device Number");
        kprintf("\n\r ");
}

void Sh_IdeWrite()
{
        int Dev;
        int i=0;
        int Lba;
        char DataBuffer[512];
        int Pattern;
        int Err=FALSE;
        byte Data;

        kprintf("\n\rInsert the channel number (0 or 1): 0\b");
        scanf("%i", &Dev);
        kprintf("\n\rChannel %i Selected",Dev);
        if ( Dev==0 )
        {
                SelectAtaChannel(CC_PRIMARY);
        }
        else if ( Dev==1 )
        {
                SelectAtaChannel(CC_SECONDARY);
        }
        else
        {
                kprintf("\n\rBad Channel Number Channel 0 will be selected");
                SelectAtaChannel(CC_PRIMARY);
        }


        kprintf("\n\rInsert the device number to Write (0 or 1): 0\b");
        scanf("%i", &Dev);
        kprintf("\n\rDevice %i Selected",Dev);
        if ( Dev==0 || Dev==1 )
        {

                kprintf("\n\rInsert Lba : ");
                scanf("%i", &Lba);
                kprintf("\n\rLba Selected %i",Lba);

                kprintf("\n\rSpecify Type of Pattern To Write (1 byte in decimal format): ");
                scanf("%i",&Pattern);
                kprintf("\n\rPattern: %i",Pattern);
                Data=(byte) Pattern;
                for (i=0;i<512;i++)
                        DataBuffer[i]=Data;

                Err=WriteSectorsLba(Dev,(int64) Lba,1,(word *) &DataBuffer,TRUE);
                if (Err)
                        ShowIdeErrorMessage(Err,TRUE);
        }
        else
                kprintf("\n\rBad Device Number");
        kprintf("\n\r ");

}

void Sh_IdeDeviceInfo()
{
        int Dev;

        kprintf("\n\rInsert the channel number (0 or 1): 0\b");
        scanf("%i", &Dev);
        kprintf("\n\rChannel %i Selected",Dev);
        if ( Dev==0 )
                SelectAtaChannel(CC_PRIMARY);
        else if ( Dev==1 )
                SelectAtaChannel(CC_SECONDARY);
        else
        {
                kprintf("\n\rBad Channel Number Channel 0 will be selected");
                SelectAtaChannel(CC_PRIMARY);
        }


        kprintf("\n\rInsert the device number (0 or 1): 0\b");
        scanf("%i", &Dev);
        kprintf("\n\rDevice %i Selected",Dev);
        if ( Dev==0 || Dev==1 )
        {
                ShowDeviceData(Dev,30);
        }
}
// ********************************************************

// ******************** Filippo Brogi *********************

void sh_cd2(char *argv)
{
// Change the current ext2 directory //
        if (argv[0]=='\0') return;

        cd_ext2(argv);
}

void sh_cat2(char *argv)
{
// Concatenate ext2 file to standard output //
        if (argv[0]=='\0')
        {
                kprintf("\n\rcat2 requires argument\n\r");
                return;
        }
        cat_ext2(argv);
}
// ********************************************************

// Floppy buffer //
byte fd_buffer[FDC_SECTOR_SIZE];

void sh_read(char *argv)
{
// Read 1 sector from the floppy disk to the FDC buffer //
        int block, i;

        block = atoi(argv);
        kprintf("\n\rReading block %u...\n\r", block);
        kprintf("\n\r");

        memset(fd_buffer, 0, FDC_SECTOR_SIZE);

        for(i=0; i<3; i++)
                if (fdc_read(block, fd_buffer, 1)) break;

        if (i != 3)
        for(i=0; i<512; i++)
                kputchar(fd_buffer[i]);
        else
                kprintf("\n\rFloppy I/O error. Unable to read the block!!!\n\r");

        kprintf("\n\r");
}

void sh_write(char *argv)
{
// Write 1 sector from the FDC buffer to the floppy disk //
        int block, i;

        block = atoi(argv);
        kprintf("\n\rWriting block %u...\n\r", block);
        for(i=0; i<3; i++)
                if (fdc_write(block, fd_buffer, 1)) break;

        if (i == 3)
                kprintf("\n\rFloppy I/O error. Unable to write the block!!!\n\r");
}

void sh_kill(char *argv)
{
        kprintf("\n\rKilling task %i...", atoi(argv));
        if ( kill(atoi(argv)) )
                kprintf(" OK!\n\r");
        else
                kprintf("\n\rCannot kill this task!\n\r");
}

// --- Virtual 8086 mode ---------------------------------------------- //
#define V86_START_ADDRESS       0x10000
// Create a v86 foreground task.
void sh_v86_exec(char *argv)
{
        byte *file_buffer;
        int file_size;
        task_t *child;
        int status;

        if( !argv )
        {
                kprintf("file name?\n");
                return;
        }
        strtoupper(argv);

        // Get the file size if exists //
        file_size = get_file_size(argv);

        if (file_size != -1)
        {
                // Create the task //
                file_buffer = kmalloc(file_size);
                load_file(argv, file_buffer);
                child = create_v86_process((void *)V86_START_ADDRESS, file_buffer, file_size, argv);
                kfree(file_buffer);
                // Wait until the child is killed //
                waitpid(child->pid, &status, 0);
        }
}

void sh_v86_bg(char *argv)
{
// Create a v86 background task                                         //
        byte *file_buffer;
        int file_size;

        if( !argv )
        {
                kprintf("file name?\n");
                return;
        }
        strtoupper(argv);

        // Get the file size if exists //
        file_size = get_file_size(argv);

        if (file_size != -1)
        {
                // Create the task //
                file_buffer = kmalloc(file_size);
                load_file(argv, file_buffer);
                create_v86_process((void *)V86_START_ADDRESS, file_buffer, file_size, argv);
                kfree(file_buffer);
        }
}
// --- End of Virtual 8086 mode --------------------------------------- //

//! \brief Parse parameters passed to the task by the command line.
int sh_parse_params(const char *cmd_str, char ***argv, int *argc)
{
        char *strtmp=NULL, *cmd_line=NULL;
        int i, len;

        // Initialize argv and argc                                     //
        *argv = (char **)NULL;
        *argc = 0;

        // Empty command line?!                                         //
        if ( cmd_str==NULL )
                return( 0 );
        if ( *cmd_str == '\0' )
                return( 0 );

        // Copy the command string into a temporary array               //
        if ( (len=strlen(cmd_str))!=0  )
                cmd_line = kmalloc(len+1);

        if ( cmd_line == NULL )
                return( -ENOMEM );

        strcpy( cmd_line, cmd_str );

        // Skip the initial spaces                                      //
        while( *cmd_line == ' ' )
                cmd_line++;

        // Calculate the number of parameters (argc)                    //
        strtmp = cmd_line;
        while( TRUE )
        {
                switch( *strtmp )
                {
                        case ' ':
                                *strtmp++ = '\0';
                                (*argc)++;
                                while( *strtmp == ' ' )
                                {
                                        *strtmp++ = '\0';
                                }
                                if ( *strtmp == '\0' )
                                {
                                        goto argc_done;
                                }
                        break;

                        case '\0':
                        case '\n':
                                *strtmp = '\0';
                                (*argc)++;
                                goto argc_done;
                        break;

                        default:
                                strtmp++;
                        break;
                }
        }
argc_done:
        // Allocate the argv array                                      //
        *argv = kmalloc( (*argc) * sizeof(char *) );

        // Calculate the parameter string pointers                      //
        for( i=0; i<(*argc); i++ )
        {
                (*argv)[i] = cmd_line;
                len = strlen(cmd_line);
                cmd_line += (len);
                while( *(++cmd_line) == '\0' );
        }

        // Free the unused memory                                       //
        kfree( cmd_line );
        return( 0 );
}

//! \brief Run a program in foreground.
void sh_exec(char *cmd_line)
{
        task_t *child;
        int file_size;
        int status;
        int u_argc;
        char **u_argv;

        // If all goes well the u_argv array will be allocated in the   //
        // kernel space.                                                //
        if ( sh_parse_params(cmd_line, &u_argv, &u_argc) < 0 )
        {
                kprintf("\n\rOut of virtual memory!!!");
                return;
        }

        if( !u_argv )
        {
                kprintf("file name?\n");
                return;
        }
        strtoupper( u_argv[0] );

        // Get the file size if exists //
        file_size = get_file_size( u_argv[0] );

        if ( file_size != -1 )
        {
                // Create the task //
                child = new_task(u_argv[0], u_argc, u_argv, USER_PRIVILEGE);
                if ( child == NULL )
                {
                        // An error occurs. Treat this file as a
                        // simple binary 8086 code.
                        sh_v86_exec( u_argv[0] );
                        kfree( u_argv );
                        return;
                }
                // Wait until the child is killed //
                waitpid(child->pid, &status, 0);
        }
        else
                kprintf("\n\rFile not found!\n\r");

        // Free the unused memory                                       //
        kfree( u_argv );
}

//! \brief Run a program in background.
void sh_bg(char *cmd_line)
{
        int file_size;
        task_t *child;
        int u_argc;
        char **u_argv;

        // If all goes well the u_argv array will be allocated in the   //
        // kernel space.                                                //
        if ( sh_parse_params(cmd_line, &u_argv, &u_argc) < 0 )
        {
                kprintf("\n\rOut of virtual memory!!!");
                return;
        }

        if( !u_argv )
        {
                kprintf("file name?\n");
                return;
        }
        strtoupper( u_argv[0] );

        // Get the file size if exists //
        file_size = get_file_size( u_argv[0] );

        if ( file_size != -1 )
        {
                // Create the task //
                child = new_task(u_argv[0], u_argc, u_argv, USER_PRIVILEGE);
                if ( child == NULL )
                {
                        // An error occurs. Treat this file as a
                        // simple binary 8086 code.
                        sh_v86_bg( u_argv[0] );
                        kfree( u_argv );
                        return;
                }
        }
        else
                kprintf("\n\rFile not found!\n\r");

        // Free the unused memory                                       //
        kfree( u_argv );
}

void sh_cat(char *argv)
{
// Concatenate a FILE to the standard output //
        strtoupper(argv);
        if ( cat(argv) )
                kprintf("\n\r");
        else
                kprintf("\n\rFile not found!\n\r");
}

void sh_cd(char *argv)
{
// Change the current directory //
        strtoupper(argv);
        if (argv[0]=='\0') return;
        if ( !(cd(argv)) )
                kprintf("\n\rMiniShell: cd: %s: No such directory\n\r", argv);
}

void sh_rm(char *argv)
{
// Remove a file //
        strtoupper(argv);
        if ( rm(argv) )
                kprintf("Deleted!\n\r");
        else
                kprintf("\n\rFile not found!\n\r");
}

void task_test()
{
        register int cr3;
        __asm__ __volatile__(
                "movl %%cr3, %%eax"
                : "=a"(cr3) : );
        __asm__ __volatile__ ("" : : : "eax");
        kprintf("\n\rHello from task %u!!! My PDBR is @ %#010x\n\r", get_pid(), cr3);
        _exit( 0 );
}

void sh_test(char *argv)
{
        int i;
        short int n;

        n = atoi(argv);
        if ( !n ) n=1;
        kprintf("\n\rCreating %u background tasks. Please wait.\n\r", n);
        for(i=0; i<n; i++)
        {
                create_process(&task_test, &task_test, 0, "sh_task_test", KERNEL_PRIVILEGE);
                kputchar('.');
        }
}

void show_cpuid()
{
        typedef struct cache_info {
                byte index;
                char *string;
        } cache_info_t;

        // Cache TLB informations //
        static cache_info_t cache_strings[37] = {
                // { 0x00, "Null descriptor" },
                { 0x01, "Instruction TLB: 4KB Pages 4-way set associative, 32 entries" },
                { 0x02, "Instruction TLB: 4MB Pages, 4-way set associative, 2 entries" },
                { 0x03, "Data TLB: 4KB Pages, 4-way set associative, 64 entries" },
                { 0x04, "Data TLB: 4MB Pages, 4-way set associative, 8 entries" },
                { 0x06, "1st-level instruction cache: 8KB, 4-way set associative, 32 byte line size" },
                { 0x08, "1st-level instruction cache: 16KB, 4-way set associative, 32 byte line size" },
                { 0x0A, "1st-level data cache: 8KB, 2-way set associative, 32 byte line size" },
                { 0x0C, "1st-level data cache: 16KB, 4-way set associative, 32 byte line size" },
                { 0x22, "3rd-level cache: 512KB, 4-way set associative, dual-sectored line, 64 byte sector size" },
                { 0x23, "3rd-level cache: 1MB, 8-way set associative, dual-sectored line, 64 byte sector size" },
                { 0x40, "No 2nd-level cache or, if processor contains a valid 2nd-level cache, no 3rd-level cache" },
                { 0x41, "2nd-level cache: 128KB, 4-way set associative, 32 byte line size" },
                { 0x42, "2nd-level cache: 256KB, 4-way set associative, 32 byte line size" },
                { 0x43, "2nd-level cache: 512KB, 4-way set associative, 32 byte line size" },
                { 0x44, "2nd-level cache: 1MB, 4-way set associative, 32 byte line size" },
                { 0x45, "2nd-level cache: 2MB, 4-way set associative, 32 byte line size" },
                { 0x50, "Instruction TLB: 4KB and 2MB or 4MB pages, 64 entries" },
                { 0x51, "Instruction TLB: 4KB and 2MB or 4MB pages, 128 entries" },
                { 0x52, "Instruction TLB: 4KB and 2MB or 4MB pages, 256 entries" },
                { 0x5B, "Data TLB: 4KB and 4MB pages, 64 entries" },
                { 0x5C, "Data TLB: 4KB and 4MB pages, 128 entries" },
                { 0x5D, "Data TLB: 4KB and 4MB pages, 256 entries" },
                { 0x66, "1st-level data cache: 8KB, 4-way set associative, 64 byte line size" },
                { 0x67, "1st-level data cache: 16KB, 4-way set associative, 64 byte line size" },
                { 0x68, "1st-level data cache: 32KB, 4-way set associative, 64 byte line size" },
                { 0x70, "Trace cache: 12K-op, 8-way set associative" },
                { 0x71, "Trace cache: 16K-op, 8-way set associative" },
                { 0x72, "Trace cache: 32K-op, 8-way set associative" },
                { 0x79, "2nd-level cache: 128KB, 8-way set associative, dual-sectored line, 64 byte sector size" },
                { 0x7A, "2nd-level cache: 256KB, 8-way set associative, dual-sectored line, 64 byte sector size" },
                { 0x7B, "2nd-level cache: 512KB, 8-way set associative, dual-sectored line, 64 byte sector size" },
                { 0x7C, "2nd-level cache: 1MB, 8-way set associative, dual-sectored line, 64 byte sector size" },
                { 0x82, "2nd-level cache: 256KB, 8-way set associative, 32 byte line size" },
                { 0x83, "2nd-level cache: 512KB, 8-way set associative, 32 byte line size" },
                { 0x84, "2nd-level cache: 1MB, 8-way set associative, 32 byte line size" },
                { 0x85, "2nd-level cache: 2MB, 8-way set associative, 32 byte line size" },
        };

        int eax, ebx, ecx, edx;
        dword vendor[4];
        dword i, j;
        int virtual;
        uint64_t timestamp1, timestamp2;
        uint32_t mhz_freq;
        dword IF = GET_IF();

        kprintf("\n\rReading CPU informations...");

        // Calculate the CPU frequency using the real-time clock        //
        disable();

        // Wait until the second has precisely just started             //
        (void)time_read();
        // Read the value of the current time-stamp counter (64-bit)    //
        __asm__ __volatile__("rdtsc" : "=A"(timestamp1));
        // Wait exactly a second                                        //
        (void)time_read();
        // Read the value of the current time-stamp counter again       //
        __asm__ __volatile__("rdtsc" : "=A"(timestamp2));
        // Now we can estimate the CPU frequency as follows             //
        mhz_freq = ((uint32_t)(timestamp2 - timestamp1))/1000000;
        kprintf("\n\rFrequency: %u MHz", mhz_freq);

        SET_IF(IF);

        // Execute the CPUID instruction command 0                      //
        cpuid(0, &eax, &ebx, &ecx, &edx);

        vendor[0] = ebx;
        vendor[1] = edx;
        vendor[2] = ecx;
        vendor[3] = 0;

        kprintf("\n\rDetected \"%s\" CPU", (char *)vendor);

        // Execute the CPUID instruction command 1 //
        cpuid(1, &eax, &ebx, &ecx, &edx);

        // Detect processor type //
        switch((eax >> 12) & 0x03)
        {
                case 0:
                kprintf("\n\rOriginal OEM Processor");
                break;

                case 1:
                kprintf("\n\rIntel Overdrive(R) Processor");
                break;

                case 2:
                kprintf("\n\rDual Processor");
                break;

                case 3:
                kprintf("\n\r??? (reserved)");
                break;
        }
        // Detect processor family & model //
        kprintf(        "\n\rFamily=%u Model=%u SteppingID=%u\n\r",
                ((eax >> 8) & 0x0F), ((eax >> 4) & 0x0F), ((eax >> 0) & 0x0F) );

        // Detect with brand string //
        switch(ebx & 0xFF)
        {
                case 0:
                kprintf(        "Brand identification not supported\n\r"
                        "Processor produced before the introduction of Pentium III Xeon processor\n\r");
                break;

                case 1:
                kprintf("Celeron\n\r");
                break;

                case 2:
                kprintf("Pentium III\n\r");
                break;

                case 3:
                kprintf("Pentium III Xeon\n\r");
                break;

                case 6:
                kprintf("Pentium III Mobile\n\r");
                break;

                case 8:
                kprintf("Pentium 4 (Willamette)\n\r");
                break;

                case 9:
                kprintf("Pentium 4 (Northwood)\n\r");
                break;

                default:
                kprintf("??? (processor) %u\n\r", (ebx & 0xFF));
                break;
        }

        // Detect technology //
        if ( edx & (1<<23) ) kprintf("MMX Technology found\n\r");
        if ( edx & (1<<25) ) kprintf("SSE extension supported\n\r");
        if ( edx & (1<<26) ) kprintf("SSE2 extension supported\n\r");
        if ( (edx & (1<<28)) )
        {
                virtual = ( (ebx >> 16) & 0xFF );
                kprintf("Hyper-Threading Technology found (%u virtual %s)\n\r",
                        virtual, (virtual > 1) ? ("processors") : ("processor") );
        }

        // Detect Cache informations //
        do
        {
                // Execute the CPUID instruction command 2 //
                cpuid(2, &eax, &ebx, &ecx, &edx);
        } while ((eax & 0x0F) != 1);

        kprintf("\n\r- Internal cache informations -\n\r");
        if (!(eax & 0x80000000)) vendor[0] = (eax >> 8);
        if (!(ebx & 0x80000000)) vendor[1] = ebx;
        if (!(ecx & 0x80000000)) vendor[2] = ecx;
        if (!(edx & 0x80000000)) vendor[3] = edx;

        for (j=0; j<(sizeof(cache_strings)/sizeof(cache_info_t)); j++)
                for (i=0; i<4*sizeof(dword); i++)
                {
                        if ( ((char *)vendor)[i] != 0)
                                if ( ((char *)vendor)[i]==cache_strings[j].index )
                                {
                                        kprintf("%s\n\r", cache_strings[j].string);
                                        break;
                                }
                }
        kprintf("\n\r");
}

void sh_help(char *argv)
{
// Print the help //
        int i, row;

        kprintf("\n\r%s\n\r", SH_VERSION);

        if ( *argv != NULL )
        {
                // Print only the selected commands //
                for (i=0; i<SH_COMMANDS; i++)
                if (strcmp(argv, commands[i].name)==0)
                {
                        // Print usage and command info //
                        kprintf("\n\r-> ");
                        set_color(WHITE);
                        kprintf("%s", commands[i].usage);
                        set_color(DEFAULT_COLOR);
                        kprintf("\n\r   %s;\n\n\r", commands[i].help);
                        return;
                }
                // Command not found! //
                kprintf("\n\r   Command not found!\n\n\r");
                return;
        }

        // Print all commands //
        for (i=0, row=2; i<SH_COMMANDS; i++)
        {
                // Print usage and command info //
                kprintf("\n\r-> ");
                set_color(WHITE);
                kprintf("%s", commands[i].usage);
                set_color(DEFAULT_COLOR);
                kprintf("\n\r   %s;", commands[i].help);

                // Wait for keypressed to avoid screen scrolling //
                row += 2;
                if (row >= 24)
                {
                        if (kgetchar() == CTRL_C) break;
                        row = 0;
                }
        }
        kprintf("\n\n\r");
}

void ps_task()
{
// This task run the command ps (processes list)                        //
        ps();
        _exit(0);
}

void sh_ps()
{
        pid_t pid;
        int status;
        pid = create_process(&ps_task, &ps_task, 0, "ps", KERNEL_PRIVILEGE)->pid;
        waitpid(pid, &status, 0);
}

void sh_halt()
{
// Halt the system                                                      //
        kprintf("\n\rHalting system using APM features...");
        beep();

        sh_cd("/");
        sh_cd("bin");
        sh_v86_exec("halt.bin");

        // If you reach this point it means that your motherboard       //
        // does not support APM features...                             //

        // Be sure that the floppy motor has been turned off!           //
        out(0x03F2, 0x0C);

        // Halt the system                                              //
        kprintf("\n\rNow you can turn off power.");
        halt();
}

void sh_elf(char *argv)
{
// Check if the file is a valid ELF32.                                  //
        byte *file_buffer;
        int file_size;

        if( !argv )
        {
                kprintf("background file?\n");
                return;
        }
        strtoupper(argv);

        // Get the file size if exists                                  //
        file_size = get_file_size(argv);

        // Load the ELF32 file                                          //
        file_buffer = kmalloc(file_size);
        switch ( elf32_load_file(argv, file_buffer) )
        {
                case -ENOENT:
                        kprintf("file not found!\n\r");
                break;

                case -ENOEXEC:
                        kprintf("not a valid ELF32 file!\n\r");
                break;

                default:
                        kprintf("ELF32 file-format OK!\n\r");
                break;
        }
        kfree(file_buffer);
}

void shell()
{
// The MINIShell main program //

        #define SH_PROMPT       "\r[root:/fd0/%s]# "
        #define CMD_ARG         (cmd+strlen(commands[i].name)+1)

        // Shell command buffer //
        char cmd[STR_MAX_LENGTH];
        int i;

        // Reset the command buffer //
        memset(cmd, 0, sizeof(cmd));

        // Welcome message //
        set_color(DEFAULT_COLOR);
        kprintf("\n\rWelcome to the MiniShell (tty%u)", get_curr_task()->console);
        kprintf("\n\rHave a lot of fun...\n\r");

        // Command line //
        while(TRUE)
        {
                kprintf(SH_PROMPT, pwd());
                gets(cmd);

                for(i=0; i<SH_COMMANDS; i++)
                {
                        // Parse the command //
                        if ( strncmp(cmd, commands[i].name, strlen(commands[i].name))==0 )
                        {
                                if (*(cmd+strlen(commands[i].name)) == '\0')
                                {
                                        *CMD_ARG = '\0';
                                        break;
                                }
                                if (*(cmd+strlen(commands[i].name)) == ' ')
                                        break;
                        }
                }

                if (i == SH_COMMANDS)
                {
                        // No command requested //
                        if (!cmd[0]) continue;

                        // Execute a file in the current path in foreground //
                        if( !strncmp(cmd, "./", 2) )
                        {
                                if( cmd[2]=='\0' )
                                {
                                        kprintf("\n%s: is a directory\n");
                                        continue;
                                }
                                else
                                {
                                        sh_exec(cmd+2);
                                        continue;
                                }
                        }

                        // Command not found //
                        kprintf("\n%s: command not found\n", cmd);
                        continue;
                }

                switch(commands[i].index)
                {
                        case SH_HELP:
                        sh_help(CMD_ARG);
                        break;

                        case SH_UNAME:
                        kprintf("\n\r%s - Kernel [v%s]\n\r", KERNEL_NAME, KERNEL_VERSION);
                        break;

                        case SH_CLEAR:
                        set_color(DEFAULT_COLOR);
                        clrscr();
                        break;

                        case SH_REBOOT:
                        reboot();
                        break;

                        case SH_DUMP:
                        breakpoint();
                        break;

                        case SH_READ:
                        sh_read(CMD_ARG);
                        break;

                        case SH_WRITE:
                        sh_write(CMD_ARG);
                        break;

                        case SH_PAGES:
                        dump_dirty_pages();
                        break;

                        case SH_MEM:
                        dump_memory_map();
                        break;

                        case SH_CHECKMEM:
                        create_process(
                                &check_free_frames_integrity,
                                &check_free_frames_integrity,
                                0,
                                "frames_check",
                                KERNEL_PRIVILEGE
                        );
                        break;

                        case SH_FRAMES:
                        dump_free_frames();
                        break;

                        case SH_EXEC:
                        sh_exec(CMD_ARG);
                        break;

                        case SH_BG:
                        sh_bg(CMD_ARG);
                        break;

                        case SH_V86EXEC:
                        sh_v86_exec(CMD_ARG);
                        break;

                        case SH_V86BG:
                        sh_v86_bg(CMD_ARG);
                        break;

                        case SH_TEST:
                        sh_test(CMD_ARG);
                        break;

                        case SH_CPUID:
                        show_cpuid();
                        break;

                        case SH_MOUNT:
                        Read_FAT();
                        break;

                        case SH_LS:
                        ls();
                        break;

                        case SH_CAT:
                        sh_cat(CMD_ARG);
                        break;

                        case SH_CD:
                        sh_cd(CMD_ARG);
                        break;

                        case SH_RM:
                        sh_rm(CMD_ARG);
                        break;

                        case SH_PS:
                        sh_ps();
                        break;

                        case SH_KILL:
                        sh_kill(CMD_ARG);
                        break;

                        case SH_RS232:
                        rs232_chat(CMD_ARG);
                        break;

                        case SH_PCISCAN:
                        pci_scan();
                        break;

                        case SH_RTL8139_INIT:
                        ifconfig(CMD_ARG);
                        break;

                        case SH_ETH_PING:
                        ping(CMD_ARG);
                        break;

                        case SH_ETH_ARP:
                        arp_request(CMD_ARG);
                        break;

                        case SH_HALT:
                        sh_halt();
                        break;

                        case SH_ELF:
                        sh_elf(CMD_ARG);
                        break;

                        // **************** Luca Giovacchini (Ide) ****************
                        case SH_IDETEST:
                                Sh_IdeTest();
                                break;
                        case SH_IDEREAD:
                                Sh_IdeRead();
                                break;
                        case SH_IDEWRITE:
                                Sh_IdeWrite();
                                break;
                        case SH_IDEDEVICEINFO:
                                Sh_IdeDeviceInfo();
                                break;
                        // ********************************************************

                        // ******************** Filippo Brogi *********************
                        case SH_LS_EXT2:
                                ls_ext2();
                        break;

                        case SH_CD_EXT2:
                                sh_cd2(CMD_ARG);
                        break;

                        case SH_CAT_EXT2:
                                sh_cat2(CMD_ARG);
                        break;
                        // ********************************************************

                        case SH_TIME:
                                kprintf("\r%u\n\r", time_read());
                        break;
                }
        }
}

---