shell.c

Go to the documentation of this file.

//shell.c -- kernel shell for raw testing
#include "shell.h"
#include "../fs/ide.h" //for ide
#include "../mem/mem.h" //memory
#include "../fs/fs.h" //for filesystem
#include "../io/vga.h" //for rdln and prt
#include "../io/cm.h" //for cnb
#include "../lib/err.h" //for panic test
#include "../lib/utils.h" //for cmds
#include "../mem/heap.h" //for arena allocator
#include "editor.h" //for editor
#include "../fs/ffs.h" //ffs disksize
#include "../kernel/cpu.h" //cpu funcs
#include "../io/io.h"
 
extern arena_t *cmd_arena; //command arena from main.c
extern arena_t *fs_arena;  //filesystem arena from main.c
 
/**
 * @brief displays shell help
 *  
 * the show_help() internal function of shell.c displays kernel help 
 * adding help should be done with:
 *
 * @code{.c}
 * clscr(); //clear screen
 * int row = 0;
 * prt(0, row++, "tape kernel commands:", 0x01);
 * prt(0, row++, "help              - this message", 0x0F); 
 * (existing prints) 
 * prt(0, row++, "mycmd [myint]     - my description", 0x0F) //YOUR actual help message
 * row++; //increment cursor so help doesnt overwrite
 * cob(0, row++); set cursor
 * @endcode
 * 
 * please use variable naming convention of '[param]' for ints and '<param>' for strings
*/
static void show_help(void) {
    clscr();
    int row = 0;
    prt(0, row++, "tape kernel commands:", 0x01);
    prt(0, row++, "help              - this message", 0x0F);
    prt(0, row++, "clear             - clear screen", 0x0F);
    prt(0, row++, "ls                - list files", 0x0F);
    prt(0, row++, "read <name>       - read file", 0x0F);
    prt(0, row++, "write <name>      - write file", 0x0F);
    prt(0, row++, "rm <name>         - delete file", 0x0F); 
    prt(0, row++, "echo <text>       - echo text back", 0x0F);
    prt(0, row++, "reboot            - reboots system", 0x0F);
    prt(0, row++, "alloc [size]      - allocate memory (default 100)", 0x0F);
    prt(0, row++, "heap              - show heap info", 0x0F);
    prt(0, row++, "panic             - test panic", 0x0F);
    prt(0, row++, "info              - show system info", 0x0F);
    row++;
    cob(0, row++); //set cursor after help
}
 
/**
 * @brief cmd_writefile writes a text message to a new file
 *
 * cmd_writefile is a static function that creates a new file with
 * a given name and fills it with the provided text content
 * @param name, the name of the file to create
 * @param msg, the text content to write
 *
 * @see cmd_readfile(), fswrite(), fsadd()
 */
static void cmd_writefile(const char *name, const char *msg) {
    uint32_t lba = fsnextlba();
    uint8_t sector[512];
    
    //clear sector
    for (int i = 0; i < 512; i++) sector[i] = 0;
    
    //write message
    for (int i = 0; msg[i] && i < 512; i++) sector[i] = (uint8_t)msg[i];
    
    iwrt(lba, sector);
    fsadd(fs_arena, name, lba);
    
    int cx, cy;
    cnb(&cx, &cy);
    prt(0, cy + 1, "wrote file: ", 0x0F);
    prt(13, cy + 1, name, 0x0F);
    cob(0, cy + 2); //move cursor to next line after output
}
 
/**
 * @brief cmd_readfile reads and displays a files contents
 *
 * cmd_readfile is a static function that looks up a file on disk
 * by name and prints its contents to the screen
 * @param name, the name of the file to read
 *
 * @see cmd_writefile(), fsread()
 */
static void cmd_readfile(const char *name) {
    uint32_t lba = fsfind(name);
    int cx, cy;
    cnb(&cx, &cy);
    
    if (lba == 0) {
        prt(0, cy + 1, "file not found: ", 0x0C);
        prt(17, cy + 1, name, 0x0C);
        cob(0, cy + 2);
        return;
    }
    
    uint8_t sector[512];
    irsec(lba, sector);
    
    if (sector[0] != '\0') {
        //create a temporary buffer with newline appended
        char temp[513];
        int i;
        for (i = 0; i < 511 && sector[i] != '\0'; i++) {
            temp[i] = (char)sector[i];
        } //this stops the prompt from overwriting text
        temp[i] = '\n';
        temp[i + 1] = '\0';
        
        prt(0, cy + 1, temp, 0x0F);
        
        //count lines including the appended newline
        int lines = 1;
        for (int j = 0; temp[j] != '\0'; j++) {
            if (temp[j] == '\n') lines++;
        }
        cob(0, cy + lines);
    } else {
        prt(0, cy + 1, "(empty)", 0x0F);
        cob(0, cy + 2);
    }
}
 
/**
 * @brief cmd_alloc allocates memory from the command arena
 *
 * cmd_alloc is a static function that allocates a block of memory
 * from cmd_arena and prints the resulting pointer address
 * @param size, the number of bytes to allocate (defaults to 100)
 *
 * @see alc(), cmd_arena, res()
 */
static void cmd_alloc(uint32_t size) {
    if (size == 0) size = 100;
    
    void *ptr = alc(cmd_arena, size);
    int cx, cy;
    cnb(&cx, &cy);
    
    if (ptr == 0) {
        prt(0, cy + 1, "alloc fail", 0x0C);
    } else {
        prt(0, cy + 1, "alloc ", 0x0F);
        prtd(6, cy + 1, (int)size, 0x0F);
        prt(10, cy + 1, " bytes at 0x", 0x0F);
        prth(22, cy + 1, (uint32_t)ptr, 0x0F);
    }
    cob(0, cy + 2);
}
 
/**
 * @brief shell is the interactive kernel command shell
 *
 * shell is a function that runs an infinite loop displaying the
 * tape prompt and processing user commands
 * @param mb_info, the multiboot info pointer passed from kmain
 * for memory queries
 *
 * shell supports the following commands: help, clear, ls, read,
 * write, rm, echo, reboot, alloc, heap, panic, and info
 *
 * using shell is done with
 * @code{.c}
 * #include "../usr/shell.h" //or just shell.h
 * shell(mb_info);
 * @endcode
 *
 * @see kmain(), show_help(), cmd_arena
 */
NORETURN void __shell(void *mb_info) {
    char inpt[100];
    char *args[MAX_ARGS];
    int cx, cy;
    
    while (1) {
        res(cmd_arena); //reset command arena before each command
        
        cnb(&cx, &cy);
        prt(0, cy, "tape", 0x0F); //prompt
        prt(4, cy, "@", 0x06);
        cob(cx + 6, cy);
        rdln(inpt, 100);
        
        if (inpt[0] == '\0') {
            //just move to next line if empty input
            cnb(&cx, &cy);
            cob(0, cy + 1);
            continue;
        }
        
        int argc = pargs(inpt, args);
        if (argc == 0) continue;
        
        if (strcmp(args[0], "help") == 0) {
            show_help();
        }
        else if (strcmp(args[0], "clear") == 0) {
            clscr();
            cob(0, 0);
        }
        else if (strcmp(args[0], "ls") == 0) {
            char *list = fslist();
            cnb(&cx, &cy);
            if (list[0] == '\0') {
                prt(0, cy + 1, "(empty)", 0x0F);
                cob(0, cy + 2);
            } else {
                //append newline to the list
                char temp[513];
                int i;
                for (i = 0; i < 511 && list[i] != '\0'; i++) {
                    temp[i] = list[i];
                }
                temp[i] = '\n';
                temp[i + 1] = '\0';
        
                prt(0, cy + 1, temp, 0x0F);
        
                int lines = 1;
                for (int j = 0; temp[j] != '\0'; j++) {
                    if (temp[j] == '\n') lines++;
                }
                cob(0, cy + lines);
            }
        }
        else if (strcmp(args[0], "panic") == 0) {
            panic("test panic");
        }
        else if (strcmp(args[0], "alloc") == 0) {
            uint32_t size = (argc >= 2) ? (uint32_t)atoi(args[1]) : 100;
            cmd_alloc(size);
        }
        else if (strcmp(args[0], "heap") == 0) {
            cnb(&cx, &cy);
            prt(0, cy + 1, "cmd arena start: 0x", 0x0F); //show cmd_arena info
            prth(19, cy + 1, (uint32_t)cmd_arena->start, 0x0F);
            prt(0, cy + 2, "cmd arena current: 0x", 0x0F);
            prth(21, cy + 2, (uint32_t)cmd_arena->current, 0x0F);
            prt(0, cy + 3, "cmd arena size: ", 0x0F);
            prtd(17, cy + 3, (int)cmd_arena->size, 0x0F);
            prt(0, cy + 4, "cmd arena used: ", 0x0F);
            prtd(17, cy + 4, (int)((uint32_t)cmd_arena->current - (uint32_t)cmd_arena->start), 0x0F);
            cob(0, cy + 5);
        }
        else if (strcmp(args[0], "read") == 0) {
            if (argc < 2) {
                cnb(&cx, &cy);
                prt(0, cy + 1, "usage: read <name>", 0x0C);
                cob(0, cy + 2);
            } else {
                cmd_readfile(args[1]);
            }
        }
        else if (strcmp(args[0], "write") == 0) {
            if (argc < 2) {
                cnb(&cx, &cy);
                prt(0, cy + 1, "usage: write <name>", 0x0C);
                cob(0, cy + 2);
            } else if (argc == 3) {
                cmd_writefile(args[1], args[2]);
            } else {
                editor(args[1]);
            }
        } 
        else if (strcmp(args[0], "rm") == 0) {
            if (argc < 2) {
                cnb(&cx, &cy);
                prt(0, cy + 1, "usage: rm <name>", 0x0C);
                cob(0, cy + 2);
            } else {
                uint32_t lba = fsfind(args[1]);
                cnb(&cx, &cy);
                if (lba == 0) {
                    prt(0, cy + 1, "rm: file not found: ", 0x0C);
                    prt(21, cy + 1, args[1], 0x0C);
                    cob(0, cy + 2);
                } else {
                    fsdelete(args[1]);
                    prt(0, cy + 1, "rm: deleted ", 0x0F);
                    prt(13, cy + 1, args[1], 0x0F);
                    cob(0, cy + 2);
                }
            }
        }
        else if (strcmp(args[0], "reboot") == 0) {
            reboot();
        }
        else if (strcmp(args[0], "echo") == 0) {
            cnb(&cx, &cy);
            
            //print incrementally
            int curx = 0;
            int cury = cy + 1;
            
            for (int i = 1; i < argc; i++) {
                //print each argument directly
                prt(curx, cury, args[i], 0x0F);
                
                //update cursor position for next print
                curx += strlen(args[i]);
                
                if (i < argc - 1) {
                    prt(curx, cury, " ", 0x0F);
                    curx++;
                }
                
                //handle line wrapping
                if (curx >= 80) {
                    curx = 0;
                    cury++;
                    if (cury >= 25) {
                        scrl();
                        cury = 24;
                    }
                }
            }
            
            //set cursor to next line
            cob(0, cy + 2);
        } 
        else if (strcmp(args[0], "info") == 0) {
            cnb(&cx, &cy);
            prt(0, cy + 1, "sysinfo:", 0x01);
            
            prt(0, cy + 2, "mem: ", 0x0F);
            uint32_t msize = memsize(mb_info); //get mem size
            prtd(5, cy + 2, (int)msize, 0x0F);
            
            prt(0, cy + 3, "disk: ", 0x0F);
            uint32_t dsize = disksize(); //get disk sizec
            prtd(7, cy + 3, (int)dsize, 0x0F);
            
            char cpu[64];
            getcpu(cpu, sizeof(cpu)); //get cpu str
            prt(0, cy + 4, "cpu: ", 0x0F);
            prt(5, cy + 4, cpu, 0x0F);
            
            cob(0, cy + 5);
        }
        else {
            cnb(&cx, &cy);
            prt(0, cy + 1, "unknown: ", 0x0C);
            prt(9, cy + 1, args[0], 0x0C);
            cob(0, cy + 2);
        }
    }
}