Feedback

.vscode/tasks.json

@@ -19,7 +19,7 @@
         {
             "type": "shell",
             "label": "Launch QEMU",
-            "command": "echo Starting QEMU&qemu-system-i386 -s -S -cdrom os2023.iso",
+            "command": "echo Starting QEMU&qemu-system-i386 -s -S -drive file=storage.bin,format=raw,if=ide,index=0,media=disk -cdrom os2023.iso",
             "isBackground": true,
             "dependsOn": "Build OS",
             "options": {

makefile

@@ -6,7 +6,7 @@ CC            = gcc
 # Directory
 SOURCE_FOLDER = src
 OUTPUT_FOLDER = bin
-ISO_NAME      = os2023
+ISO_NAME      = OS2023.iso
 
 # Flags
 WARNING_CFLAG = -Wall -Wextra -Werror
@@ -15,20 +15,25 @@ STRIP_CFLAG   = -nostdlib -nostdinc -fno-builtin -fno-stack-protector -nostartfi
 CFLAGS        = $(DEBUG_CFLAG) $(WARNING_CFLAG) $(STRIP_CFLAG) -m32 -c -I$(SOURCE_FOLDER)
 AFLAGS        = -f elf32 -g -F dwarf
 LFLAGS        = -T $(SOURCE_FOLDER)/linker.ld -melf_i386
-
+ISOFLAGS	  = -no-emul-boot -boot-load-size 4 -A os -input-charset utf8 -quiet -boot-info-table
 
 run: all
-	@qemu-system-i386 -s -S -cdrom $(OUTPUT_FOLDER)/$(ISO_NAME).iso
+	@qemu-system-i386 -s -S -drive file=storage.bin,format=raw,if=ide,index=0,media=disk -cdrom os2023.iso
+
 all: build
 build: iso
 clean:
 	rm -rf *.o *.iso $(OUTPUT_FOLDER)/kernel
 
-
-
 kernel:
-	@$(ASM) $(AFLAGS) $(SOURCE_FOLDER)/kernel_loader.s -o $(OUTPUT_FOLDER)/kernel_loader.o
-# TODO: Compile C file with CFLAGS
+	@$(CC) $(CFLAGS) $(SOURCE_FOLDER)/portio/portio.c -o $(OUTPUT_FOLDER)/portio.o
+	@$(CC) $(CFLAGS) $(SOURCE_FOLDER)/std/stdmem.c -o $(OUTPUT_FOLDER)/stdmem.o
+	@$(CC) $(CFLAGS) $(SOURCE_FOLDER)/filesystem/disk.c -o $(OUTPUT_FOLDER)/disk.o
+	@$(CC) $(CFLAGS) $(SOURCE_FOLDER)/filesystem/fat32.c -o $(OUTPUT_FOLDER)/fat32.o
+	@$(CC) $(CFLAGS) $(SOURCE_FOLDER)/framebuffer/framebuffer.c -o $(OUTPUT_FOLDER)/framebuffer.o
+	@$(CC) $(CFLAGS) $(SOURCE_FOLDER)/gdt/gdt.c -o $(OUTPUT_FOLDER)/gdt.o
+	@$(ASM) $(AFLAGS) $(SOURCE_FOLDER)/kernel/kernel_loader.s -o $(OUTPUT_FOLDER)/kernel_loader.o
+	@$(CC) $(CFLAGS) $(SOURCE_FOLDER)/kernel/kernel.c -o $(OUTPUT_FOLDER)/kernel.o
 	@$(LIN) $(LFLAGS) bin/*.o -o $(OUTPUT_FOLDER)/kernel
 	@echo Linking object files and generate elf32...
 	@rm -f *.o
@@ -38,5 +43,10 @@ iso: kernel
 	@cp $(OUTPUT_FOLDER)/kernel     $(OUTPUT_FOLDER)/iso/boot/
 	@cp other/grub1                 $(OUTPUT_FOLDER)/iso/boot/grub/
 	@cp $(SOURCE_FOLDER)/menu.lst   $(OUTPUT_FOLDER)/iso/boot/grub/
-# TODO: Create ISO image
-	@rm -r $(OUTPUT_FOLDER)/iso/
+	@cd bin && genisoimage -R -b boot/grub/grub1 $(ISOFLAGS) -o $(ISO_NAME) iso
+
+# Disk
+DISK_NAME      = storage
+
+disk:
+	@qemu-img create -f raw $(OUTPUT_FOLDER)/$(DISK_NAME).bin 4M

src/filesystem/disk.c

@@ -0,0 +1,51 @@
+#include "disk.h"
+#include "../portio/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/disk.h

@@ -0,0 +1,44 @@
+#ifndef _DISK_H
+#define _DISK_H
+
+#include "../std/stdtype.h"
+
+/* -- ATA PIO status codes -- */
+#define ATA_STATUS_BSY   0x80
+#define ATA_STATUS_RDY   0x40
+#define ATA_STATUS_DRQ   0x08
+#define ATA_STATUS_DF    0x20
+#define ATA_STATUS_ERR   0x01
+
+#define BLOCK_SIZE      512
+#define HALF_BLOCK_SIZE (BLOCK_SIZE/2)
+
+// Block buffer data type - @param buf Byte buffer with size of BLOCK_SIZE
+struct BlockBuffer {
+    uint8_t buf[BLOCK_SIZE];
+} __attribute__((packed));
+
+/**
+ * ATA PIO logical block address read blocks. Will blocking until read is completed.
+ * Note: ATA PIO will use 2-bytes per read/write operation.
+ * Recommended to use struct BlockBuffer
+ * 
+ * @param ptr                   Pointer for storing reading data, this pointer should point to already allocated memory location.
+ *                              With allocated size positive integer multiple of BLOCK_SIZE, ex: buf[1024]
+ * @param logical_block_address Block address to read data from. Use LBA addressing
+ * @param block_count           How many block to read, starting from block logical_block_address to lba-1
+ */
+void read_blocks(void *ptr, uint32_t logical_block_address, uint8_t block_count);
+
+/**
+ * ATA PIO logical block address write blocks. Will blocking until write is completed.
+ * Note: ATA PIO will use 2-bytes per read/write operation.
+ * Recommended to use struct BlockBuffer
+ *
+ * @param ptr                   Pointer to data that to be written into disk. Memory pointed should be positive integer multiple of BLOCK_SIZE
+ * @param logical_block_address Block address to write data into. Use LBA addressing
+ * @param block_count           How many block to write, starting from block logical_block_address to lba-1
+ */
+void write_blocks(const void *ptr, uint32_t logical_block_address, uint8_t block_count);
+
+#endif

src/filesystem/fat32.c

@@ -0,0 +1,138 @@
+#include "../std/stdtype.h"
+#include "fat32.h"
+#include "../std/stdmem.h"
+
+const uint8_t fs_signature[BLOCK_SIZE] = {
+    'C', 'o', 'u', 'r', 's', 'e', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',  ' ',
+    'D', 'e', 's', 'i', 'g', 'n', 'e', 'd', ' ', 'b', 'y', ' ', ' ', ' ', ' ',  ' ',
+    'L', 'a', 'b', ' ', 'S', 'i', 's', 't', 'e', 'r', ' ', 'I', 'T', 'B', ' ',  ' ',
+    'M', 'a', 'd', 'e', ' ', 'w', 'i', 't', 'h', ' ', '<', '3', ' ', ' ', ' ',  ' ',
+    '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '-', '2', '0', '2', '3', '\n',
+    [BLOCK_SIZE-2] = 'O',
+    [BLOCK_SIZE-1] = 'k',
+};
+
+struct FAT32DriverState driverState;
+
+/* -- 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) {
+    return cluster * 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) {
+    return memcmp(fs_signature, BOOT_SECTOR, BLOCK_SIZE);
+}
+
+/**
+ * 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) {
+    struct FAT32FileAllocationTable table; 
+    table.cluster_map[0] = CLUSTER_0_VALUE;
+    table.cluster_map[1] = CLUSTER_1_VALUE;
+    table.cluster_map[2] = FAT32_FAT_END_OF_FILE;
+
+    write_blocks(fs_signature, cluster_to_lba(0), (uint8_t) CLUSTER_SIZE);
+    write_blocks(&table, cluster_to_lba(1), (uint8_t) CLUSTER_SIZE);
+}
+
+/**
+ * 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_blocks(&(driverState.fat_table), cluster_to_lba(1), (uint8_t) CLUSTER_SIZE);
+
+    }
+}
+
+/**
+ * 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);