Feedback

.gitignore

@@ -0,0 +1,2 @@
+/test
+*.json

README.md

@@ -18,25 +18,25 @@ Tugas IF2230 - Sistem Operasi 2023 Tahun 2022/2023
 
 
 ## General Information
-G
+Operating System
 
 
 ## Technologies Used
-- 
+- Qemu
+- NASM
+- C
 
 <!-- ## Penjelasan Singkat Algoritma
 *  -->
-
-
 ## Features
-- Implementasi dari
+- Implementasi dari mata kuliah Sistem Operasi 
 
 ## Screenshots
 ![Example screenshot](./doc/OS.png)
 
 
 ## How to Run
-- 
+- make run di terminal
 
 ## Project Status
 Project is: _not complete_ 
@@ -45,11 +45,12 @@ Project is: _not complete_
 ## Room for Improvement
 
 Room for improvement:
-- speed
+- speed up the code
+- add more features
 
 
 ## Division of tasks
-1. Nigel Sahl (13521043)                : 
-2. Razzan Daksana Yoni (13521087)       : 
-3. Rava Maulana Azzikri (13521149)      : 
-4. Hanif Muhammad Zhafran (13521157)    : 
+1. Nigel Sahl (13521043)                
+2. Razzan Daksana Yoni (13521087)        
+3. Rava Maulana Azzikri (13521149)       
+4. Hanif Muhammad Zhafran (13521157)     

makefile

@@ -42,6 +42,7 @@ kernel:
 
 	@$(CC) $(CFLAGS) $(SOURCE_FOLDER)/$(INTERRUPT_FOLDER)/idt.c -o $(OUTPUT_FOLDER)/idt.o
 	@$(CC) $(CFLAGS) $(SOURCE_FOLDER)/$(INTERRUPT_FOLDER)/interrupt.c -o $(OUTPUT_FOLDER)/interrupt.o
+	@$(CC) $(CFLAGS) $(SOURCE_FOLDER)/$(KEYBOARD_FOLDER)/keyboard.c -o $(OUTPUT_FOLDER)/keyboard.o	
 
 
 	@$(LIN) $(LFLAGS) bin/*.o -o $(OUTPUT_FOLDER)/kernel

src/filesystem/disk.c

@@ -0,0 +1,52 @@
+#include "../lib-header/disk.h"
+#include "../lib-header/portio.h"
+
+static void ATA_busy_wait() {
+    while (in(0x1F7) & ATA_STATUS_BSY);
+}
+
+static void ATA_DRQ_wait() {
+    while (!(in(0x1F7) & ATA_STATUS_RDY));
+}
+
+void read_blocks(void *ptr, uint32_t logical_block_address, uint8_t block_count) {
+    ATA_busy_wait();
+    out(0x1F6, 0xE0 | ((logical_block_address >> 24) & 0xF));
+    out(0x1F2, block_count);
+    out(0x1F3, (uint8_t) logical_block_address);
+    out(0x1F4, (uint8_t) (logical_block_address >> 8));
+    out(0x1F5, (uint8_t) (logical_block_address >> 16));
+    out(0x1F7, 0x20);
+
+    uint16_t *target = (uint16_t*) ptr;
+
+    for (uint32_t i = 0; i < block_count; i++) {
+        ATA_busy_wait();
+        ATA_DRQ_wait();
+        for (uint32_t j = 0; j < HALF_BLOCK_SIZE; j++)
+            target[j] = in16(0x1F0);
+        // Note : uint16_t => 2 bytes, HALF_BLOCK_SIZE*2 = BLOCK_SIZE with pointer arithmetic
+        target += HALF_BLOCK_SIZE;
+    }
+}
+
+void write_blocks(const void *ptr, uint32_t logical_block_address, uint8_t block_count) {
+    ATA_busy_wait();
+    out(0x1F6, 0xE0 | ((logical_block_address >> 24) & 0xF));
+    out(0x1F2, block_count);
+    out(0x1F3, (uint8_t) logical_block_address);
+    out(0x1F4, (uint8_t) (logical_block_address >> 8));
+    out(0x1F5, (uint8_t) (logical_block_address >> 16));
+    out(0x1F7, 0x30);
+
+    for (uint32_t i = 0; i < block_count; i++) {
+        ATA_busy_wait();
+        ATA_DRQ_wait();
+        /* Note : uint16_t => 2 bytes, i is current block number to write
+           HALF_BLOCK_SIZE*i = block_offset with pointer arithmetic
+        */
+        for (uint32_t j = 0; j < HALF_BLOCK_SIZE; j++)
+            out16(0x1F0, ((uint16_t*) ptr)[HALF_BLOCK_SIZE*i + j]);
+    }
+}
+

src/filesystem/fat32.c

@@ -10,4 +10,136 @@ const uint8_t fs_signature[BLOCK_SIZE] = {
     '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '2', '0', '2', '3', '\n',
     [BLOCK_SIZE-2] = 'O',
     [BLOCK_SIZE-1] = 'k',
-};
+};
+
+/* -- Driver Interfaces -- */
+
+/**
+ * Convert cluster number to logical block address
+ * 
+ * @param cluster Cluster number to convert
+ * @return uint32_t Logical Block Address
+ */
+uint32_t cluster_to_lba(uint32_t cluster){
+    // dr nanobyte -> lba = data_region_begin + (cluster-2)*sector_per_cluster
+    return (cluster-2) * cluster_size; //  ?
+}
+
+/**
+ * Initialize DirectoryTable value with parent DirectoryEntry and directory name
+ * 
+ * @param dir_table          Pointer to directory table
+ * @param name               8-byte char for directory name
+ * @param parent_dir_cluster Parent directory cluster number
+ */
+void init_directory_table(struct FAT32DirectoryTable *dir_table, char *name, uint32_t parent_dir_cluster){
+
+}
+
+/**
+ * Checking whether filesystem signature is missing or not in boot sector
+ * 
+ * @return True if memcmp(boot_sector, fs_signature) returning inequality
+ */
+bool is_empty_storage(void){
+
+}
+
+/**
+ * Create new FAT32 file system. Will write fs_signature into boot sector and 
+ * proper FileAllocationTable (contain CLUSTER_0_VALUE, CLUSTER_1_VALUE, 
+ * and initialized root directory) into cluster number 1
+ */
+void create_fat32(void){
+
+}
+
+/**
+ * Initialize file system driver state, if is_empty_storage() then create_fat32()
+ * Else, read and cache entire FileAllocationTable (located at cluster number 1) into driver state
+ */
+void initialize_filesystem_fat32(void){
+    if (is_empty_storage()){
+        create_fat32();
+    } else {
+        // read cluster 1
+        // cache FAT
+
+    }
+}
+
+/**
+ * Write cluster operation, wrapper for write_blocks().
+ * Recommended to use struct ClusterBuffer
+ * 
+ * @param ptr            Pointer to source data
+ * @param cluster_number Cluster number to write
+ * @param cluster_count  Cluster count to write, due limitation of write_blocks block_count 255 => max cluster_count = 63
+ */
+void write_clusters(const void *ptr, uint32_t cluster_number, uint8_t cluster_count){
+
+}
+
+/**
+ * Read cluster operation, wrapper for read_blocks().
+ * Recommended to use struct ClusterBuffer
+ * 
+ * @param ptr            Pointer to buffer for reading
+ * @param cluster_number Cluster number to read
+ * @param cluster_count  Cluster count to read, due limitation of read_blocks block_count 255 => max cluster_count = 63
+ */
+void read_clusters(void *ptr, uint32_t cluster_number, uint8_t cluster_count){
+
+}
+
+
+
+
+
+/* -- CRUD Operation -- */
+
+/**
+ *  FAT32 Folder / Directory read
+ *
+ * @param request buf point to struct FAT32DirectoryTable,
+ *                name is directory name,
+ *                ext is unused,
+ *                parent_cluster_number is target directory table to read,
+ *                buffer_size must be exactly sizeof(struct FAT32DirectoryTable)
+ * @return Error code: 0 success - 1 not a folder - 2 not found - -1 unknown
+ */
+int8_t read_directory(struct FAT32DriverRequest request){
+
+}
+
+
+/**
+ * FAT32 read, read a file from file system.
+ *
+ * @param request All attribute will be used for read, buffer_size will limit reading count
+ * @return Error code: 0 success - 1 not a file - 2 not enough buffer - 3 not found - -1 unknown
+ */
+int8_t read(struct FAT32DriverRequest request){
+
+}
+
+/**
+ * FAT32 write, write a file or folder to file system.
+ *
+ * @param request All attribute will be used for write, buffer_size == 0 then create a folder / directory
+ * @return Error code: 0 success - 1 file/folder already exist - 2 invalid parent cluster - -1 unknown
+ */
+int8_t write(struct FAT32DriverRequest request){
+
+}
+
+
+/**
+ * FAT32 delete, delete a file or empty directory (only 1 DirectoryEntry) in file system.
+ *
+ * @param request buf and buffer_size is unused
+ * @return Error code: 0 success - 1 not found - 2 folder is not empty - -1 unknown
+ */
+int8_t delete(struct FAT32DriverRequest request){
+
+}

src/framebuffer.c

@@ -3,20 +3,47 @@
 #include "lib-header/stdmem.h"
 #include "lib-header/portio.h"
 
+
 void framebuffer_set_cursor(uint8_t r, uint8_t c) {
     // TODO : Implement
-    out(CURSOR_PORT_CMD, 0x0A);
-	out(CURSOR_PORT_DATA, (in(CURSOR_PORT_DATA) & 0xC0) | r);
-
-	out(CURSOR_PORT_CMD, 0x0B);
-	out(CURSOR_PORT_DATA, (in(CURSOR_PORT_DATA) & 0xE0) | c);
+    uint16_t pos = r * MAX_COLS + c;
+    // out(0x3D4, 0x0F);
+    // out(0x3D5, (uint8_t)(pos & 0xFF));
+    // out(0x3D4, 0x0E);
+    // out(0x3D5, (uint8_t)((pos >> 8) & 0xFF));
+
+    out(CURSOR_PORT_CMD, VGA_CURSOR_HIGH);
+    out(CURSOR_PORT_DATA, (uint8_t)((pos >> 8) & 0xFF));
+    out(CURSOR_PORT_CMD, VGA_CURSOR_LOW);
+    out(CURSOR_PORT_DATA, (uint8_t)(pos & 0xFF));
+}
+
+struct Cursor framebuffer_get_cursor() {
+    out(CURSOR_PORT_CMD, VGA_CURSOR_HIGH);
+    int offset = in(CURSOR_PORT_DATA) << 8;
+    out(CURSOR_PORT_CMD, VGA_CURSOR_LOW);
+    offset += in(CURSOR_PORT_DATA);
+    struct Cursor c = 
+    {
+        .row = offset / MAX_COLS, 
+        .col = offset % MAX_COLS
+    };
+    return c;
+};
+
+int framebuffer_get_col(struct Cursor c) {
+    return c.col;
+}
+
+int framebuffer_get_row(struct Cursor c) {
+    return c.row;
 }
 
 void framebuffer_write(uint8_t row, uint8_t col, char c, uint8_t fg, uint8_t bg) {
     // TODO : Implement
-    uint16_t attrib = (bg << 4) | (fg & 0x0F);
+    uint16_t attrib = (bg << 4) | (fg & WHITE);
     volatile uint16_t * where;
-    where = (volatile uint16_t *)MEMORY_FRAMEBUFFER + (row * 80 + col) ;
+    where = (volatile uint16_t *)MEMORY_FRAMEBUFFER + (row * MAX_COLS + col) ;
     *where = c | (attrib << 8); 
 }
 
@@ -26,8 +53,52 @@ void framebuffer_clear(void) {
     uint16_t i;
     volatile uint16_t * where;
     where = (volatile uint16_t *)MEMORY_FRAMEBUFFER;
-    for (i = 0; i < 80 * 25; i++) {
+    for (i = 0; i < MAX_COLS * MAX_ROWS; i++) {
         *where = space;
         where++;
     }   
 }
+
+void framebuffer_write_string(char * str) {
+    struct Cursor c = framebuffer_get_cursor();
+    int offset = c.row * MAX_COLS + c.col;
+    int i = 0;
+    while (str[i] != '\0') {
+        if (offset >= MAX_COLS * MAX_ROWS) {
+            offset = framebuffer_scroll_ln(offset);
+        }
+        if (str[i] == '\n') {
+            // offset = (offset / 160 + 1) * 160;
+            offset = (offset / MAX_COLS + 1) * MAX_COLS;
+        } else {
+            // framebuffer_write(offset / 160, offset % 160, str[i], WHITE, BLACK);
+            framebuffer_write(offset / MAX_COLS, offset % MAX_COLS, str[i], WHITE, BLACK);
+            offset += 1;
+        }
+        i++;
+    }
+    framebuffer_set_cursor(offset / MAX_COLS, offset % MAX_COLS);
+}
+
+int framebuffer_scroll_ln(int offset) {
+    // di enter dulu baru scroll
+    memcpy(
+        (void *)MEMORY_FRAMEBUFFER, 
+        (void *)(MEMORY_FRAMEBUFFER + MAX_COLS * 2),
+        // (void *)(MEMORY_FRAMEBUFFER + MAX_COLS * 2),
+        //  160 * 2 * 24);
+        // 2 * MAX_COLS * 2 * (MAX_ROWS - 1));
+        MAX_COLS * 2 * (MAX_ROWS + 1));
+
+    for (int i = 0; i < MAX_COLS; i++) {
+        framebuffer_write(MAX_ROWS - 1, i, ' ', WHITE, BLACK);
+        framebuffer_write(MAX_ROWS - 2, i, ' ', WHITE, BLACK);
+        // framebuffer_write(MAX_ROWS - 3, i, ' ', WHITE, BLACK);
+    }
+
+
+    // return (c.row * MAX_COLS + c.col) - (MAX_ROWS - 1) * MAX_COLS;
+    // return (c.row * MAX_COLS + c.col) - 2 * MAX_COLS;
+    return (offset) - 3 * (MAX_COLS);
+    // return offset - (MAX_ROWS - 1) * MAX_COLS;
+}

src/interrupt/idt.c

@@ -1,6 +1,6 @@
 #include "../lib-header/idt.h"
 
-void *isr_stub_table[ISR_STUB_TABLE_LIMIT];
+// void *isr_stub_table[ISR_STUB_TABLE_LIMIT];
 struct IDTR _idt_idtr;
 
 // global initialization of IDT