Began two-stage hdd bootloader and os installer

6 files changed, 427 insertions, 0 deletions

diff --git a/src/kernel/fs/marfs/directory.c b/src/kernel/fs/marfs/directory.c
new file mode 100644
index 0000000..f7783bb
--- /dev/null
+++ b/src/kernel/fs/marfs/directory.c
@@ -0,0 +1,55 @@
+#include <stdint.h>
+#include <kernel/fs/ata_pio.h>
+#include <kernel/lib/alloc.h>
+#include <kernel/lib/lib.h>
+#include "marfs.h"
+
+uint32_t marfs_new_dir(uint32_t uid) { return marfs_new_file(0, 0, uid, 0, 1); }
+
+
+void marfs_add_to_dir(uint32_t LBAinode, char *filename, uint32_t lba) {
+    struct marfs_INODE *inode = (struct marfs_INODE *) ATA_read28(iface, LBAinode);
+
+    // Read the content
+    uint8_t *old = marfs_allocate_and_read_whole_file(LBAinode);
+
+    // Allocate memory
+    uint8_t *contents = kmalloc(inode->size + strlen(filename) + 1 + 4);
+
+    // Copy the content
+    uint8_t lastWasNull = 0;
+    uint64_t newsize = 0;
+    for (uint64_t i = 0; i < inode->size; i++) {
+        if (old[i] == 0 && lastWasNull) continue;
+
+        contents[newsize++] = old[i];
+        lastWasNull = (old[i] == 0);
+    }
+    kfree(old);
+
+    // Append new file
+    for (uint16_t i = 0; i <= strlen(filename); i++) contents[newsize++] = filename[i];
+    for (signed char j = 24; j > 0; j -= 8) contents[newsize++] = (lba >> j) & 0xFF;
+
+    // Free the blocks
+    uint32_t newsize_in_blocks = newsize / 512;
+    if (newsize % 512) newsize_in_blocks++;
+    for (uint32_t i = 0; i < newsize_in_blocks; i++)
+        marfs_mark_block_as_free(marfs_get_block(inode, i));
+
+    // Overwrite
+    uint32_t aux_inode = marfs_new_file(newsize, contents, 0xDEADBEEF, 0, 0);
+    struct marfs_INODE *real_aux_inode = (struct marfs_INODE *) ATA_read28(iface, aux_inode);
+    for (uint8_t i = 0; i < 10; i++) inode->DBPs[i] = real_aux_inode->DBPs[i];
+    inode->ext_1 = real_aux_inode->ext_1;
+    inode->ext_2 = real_aux_inode->ext_2;
+    inode->ext_3 = real_aux_inode->ext_3;
+    inode->ext_4 = real_aux_inode->ext_4;
+    real_aux_inode->isUsed = 0;
+    ATA_write28(iface, aux_inode, (uint8_t *) real_aux_inode);
+    kfree(real_aux_inode);
+
+    inode->size = newsize;
+    ATA_write28(iface, LBAinode, (uint8_t *) inode);
+    kfree(inode);
+}
diff --git a/src/kernel/fs/marfs/disklevel.c b/src/kernel/fs/marfs/disklevel.c
new file mode 100644
index 0000000..b6fc8c2
--- /dev/null
+++ b/src/kernel/fs/marfs/disklevel.c
@@ -0,0 +1,23 @@
+#include <stdint.h>
+#include <kernel/fs/ata_pio.h>
+#include "marfs.h"
+
+void marfs_format(void) {
+    // Create superblock
+    struct marfs_SUPERBLOCK sb;
+    sb.signature = 0x1083B99F34B59645; // Huh, magic?!
+    sb.n_inodes = (marfs_get_max_lba() - 2) >> 5;
+    sb.n_chunks = (marfs_get_max_lba() - (2 + sb.n_inodes)) >> 9;
+    sb.n_first_unallocated_inode = 0;
+    sb.s_first_inode = 2;
+    sb.s_first_chunk = 2 + sb.n_inodes;
+
+    // Write to disk
+    marfs_writeSB(&sb);
+
+    // Initialize the inodes
+    for (uint32_t i = 0; i < sb.n_inodes; i++) ATA_clear28(iface, 2 + i);
+
+    // Initialize the chunks
+    for (uint32_t i = 0; i < sb.n_chunks; i++) ATA_clear28(iface, sb.s_first_chunk + i * 512);
+}
diff --git a/src/kernel/fs/marfs/marfs.h b/src/kernel/fs/marfs/marfs.h
new file mode 100644
index 0000000..ba6f0b3
--- /dev/null
+++ b/src/kernel/fs/marfs/marfs.h
@@ -0,0 +1,81 @@
+#ifndef MELVIX_MARFS_H
+#define MELVIX_MARFS_H
+
+#include <stdint.h>
+
+struct marfs_SUPERBLOCK {
+    uint64_t signature;
+    uint32_t n_inodes;
+    uint32_t n_chunks;
+    uint32_t n_first_unallocated_inode;
+    uint32_t s_first_inode;
+    uint32_t s_first_chunk;
+} __attribute__((packed));
+
+struct marfs_INODE {
+    uint64_t size;
+    uint32_t creation_time;
+    uint32_t last_mod_time;
+    uint32_t last_access_time;
+    uint32_t n_blocks;
+    uint32_t DBPs[10];
+    uint32_t ext_1;
+    uint32_t ext_2;
+    uint32_t ext_3;
+    uint32_t ext_4;
+    uint32_t uid;
+    uint8_t isApp;
+    uint8_t isDir;
+    uint8_t isUsed;
+} __attribute__((packed));
+
+enum marfs_RESERVED_INODES {
+    marfs_INODE_JBOOT2,
+    marfs_INODE_KERNEL,
+    marfs_INODE_ROOT
+};
+
+struct ATA_INTERFACE *iface;
+struct marfs_SUPERBLOCK sb_cache;
+uint32_t maxLBA;
+
+// marfs_sectorlevel.c
+uint8_t marfs_init(struct ATA_INTERFACE *iface);
+
+uint32_t marfs_get_max_lba(void);
+
+uint8_t marfs_write_mbr(uint8_t *mbr);
+
+struct marfs_SUPERBLOCK *marfs_read_superblock();
+
+uint8_t marfs_writeSB(struct marfs_SUPERBLOCK *sb);
+
+uint32_t marfs_get_free_lba_block(void);
+
+uint8_t marfs_mark_block_as_used(uint32_t LBAsector);
+
+uint8_t marfs_mark_block_as_free(uint32_t LBAsector);
+
+uint32_t marfs_get_free_lba_inode(void);
+
+void marfs_mark_inode_as_free(uint32_t LBAsector);
+
+// marfs_disklevel.c
+void marfs_format(void);
+
+// marfs_new_file.c
+uint32_t marfs_new_file(uint64_t size, uint8_t *data, uint32_t uid, uint8_t exec, uint8_t dir);
+
+// marfs_dir.c
+uint32_t marfs_new_dir(uint32_t uid);
+
+void marfs_add_to_dir(uint32_t LBAinode, char *filename, uint32_t lba);
+
+// marfs_read_whole_file.c
+uint32_t marfs_get_block(struct marfs_INODE *inode, uint32_t i);
+
+void marfs_read_whole_file(uint32_t LBAinode, uint8_t *buffer);
+
+uint8_t *marfs_allocate_and_read_whole_file(uint32_t LBAinode);
+
+#endif
diff --git a/src/kernel/fs/marfs/new_file.c b/src/kernel/fs/marfs/new_file.c
new file mode 100644
index 0000000..7b06621
--- /dev/null
+++ b/src/kernel/fs/marfs/new_file.c
@@ -0,0 +1,102 @@
+#include <stdint.h>
+#include <kernel/fs/ata_pio.h>
+#include <kernel/lib/alloc.h>
+#include "marfs.h"
+
+static uint8_t last_maxlevel = 0;
+
+void marfs_update_recursive(uint8_t level, uint32_t i, uint32_t recLBA, uint32_t realLBA) {
+    if (level > last_maxlevel) last_maxlevel = level;
+    uint32_t *contents = (uint32_t *) ATA_read28(iface, recLBA);
+
+    uint32_t idx = i - 10;
+    if (last_maxlevel > 1) idx -= 1 << 7;
+    if (last_maxlevel > 2) idx -= 1 << (7 * 2);
+    if (last_maxlevel > 3) idx -= 1 << (7 * 3);
+    idx >>= 7 * (level - 1);
+
+    if (level > 1) {
+        if (!contents[idx]) {
+            contents[idx] = marfs_get_free_lba_block();
+            marfs_mark_block_as_used(contents[idx]);
+        }
+    } else {
+        contents[idx] = realLBA;
+    }
+
+    ATA_write28(iface, recLBA, (uint8_t *) contents);
+
+    uint32_t contents_idx = contents[idx];
+    kfree(contents);
+    if (level != 1) {
+        marfs_update_recursive(level - 1, i, contents_idx, realLBA);
+    }
+    last_maxlevel = 0;
+}
+
+uint32_t marfs_new_file(uint64_t size, uint8_t *data, uint32_t uid, uint8_t exec, uint8_t dir) {
+    struct marfs_INODE *inode = (struct marfs_INODE *) kcalloc(1, 512);
+    inode->size = size;
+    inode->creation_time = inode->last_mod_time = inode->last_access_time = 0; // TODO: POSIX time
+    inode->n_blocks = size / 512;
+    if (size % 512) inode->n_blocks++;
+    inode->uid = uid;
+    inode->isApp = exec;
+    inode->isDir = dir;
+    inode->isUsed = 1;
+
+    uint32_t size_in_blocks = inode->n_blocks;
+
+    uint32_t LBA_singly, LBA_doubly, LBA_triply, LBA_quadruply;
+    LBA_singly = LBA_doubly = LBA_triply = LBA_quadruply = 0;
+    for (uint32_t i = 0; i < size_in_blocks; i++) {
+        uint32_t thisblock = marfs_get_free_lba_block();
+        if (i != size_in_blocks - 1) {
+            ATA_write28(iface, thisblock, data);
+        } else if (size % 512) {
+            uint8_t contents[512] = {0};
+            for (uint16_t i = 0; i < size % 512; i++) contents[i] = data[i];
+            ATA_write28(iface, thisblock, contents);
+        }
+        data += 512;
+        marfs_mark_block_as_used(thisblock);
+
+        if (i > 9 + (128 * 128 * 128)) {
+            if (!LBA_quadruply) {
+                LBA_quadruply = marfs_get_free_lba_block();
+                marfs_mark_block_as_used(LBA_quadruply);
+                inode->ext_4 = LBA_quadruply;
+            }
+            marfs_update_recursive(4, i, LBA_quadruply, thisblock);
+        } else if (i > 9 + (128 * 128)) {
+            if (!LBA_triply) {
+                LBA_triply = marfs_get_free_lba_block();
+                marfs_mark_block_as_used(LBA_triply);
+                inode->ext_3 = LBA_triply;
+            }
+            marfs_update_recursive(3, i, LBA_triply, thisblock);
+        } else if (i > 9 + 128) {
+            if (!LBA_doubly) {
+                LBA_doubly = marfs_get_free_lba_block();
+                marfs_mark_block_as_used(LBA_doubly);
+                inode->ext_2 = LBA_doubly;
+            }
+            marfs_update_recursive(2, i, LBA_doubly, thisblock);
+        } else if (i > 9) {
+            if (!LBA_singly) {
+                LBA_singly = marfs_get_free_lba_block();
+                marfs_mark_block_as_used(LBA_singly);
+                inode->ext_1 = LBA_singly;
+            }
+            marfs_update_recursive(1, i, LBA_singly, thisblock);
+        } else {
+            inode->DBPs[i] = thisblock;
+        }
+    }
+
+    // Write the inode
+    uint32_t inode_LBA = marfs_get_free_lba_inode();
+    ATA_write28(iface, inode_LBA, (uint8_t *) inode);
+
+    return inode_LBA;
+}
\ No newline at end of file
diff --git a/src/kernel/fs/marfs/read_whole_file.c b/src/kernel/fs/marfs/read_whole_file.c
new file mode 100644
index 0000000..86aae5f
--- /dev/null
+++ b/src/kernel/fs/marfs/read_whole_file.c
@@ -0,0 +1,65 @@
+#include <stdint.h>
+#include <kernel/fs/ata_pio.h>
+#include <kernel/lib/alloc.h>
+#include "marfs.h"
+
+static uint8_t last_maxlevel = 0;
+
+uint32_t marfs_get_recursive(uint8_t level, uint32_t i, uint32_t recLBA) {
+    if (level > last_maxlevel) last_maxlevel = level;
+    uint32_t *contents = (uint32_t *) ATA_read28(iface, recLBA);
+    uint32_t idx = i - 10;
+    if (last_maxlevel > 1) idx -= 1 << 7;
+    if (last_maxlevel > 2) idx -= 1 << (7 * 2);
+    if (last_maxlevel > 3) idx -= 1 << (7 * 3);
+    idx >>= 7 * (level - 1);
+
+    uint32_t next_recLBA = contents[idx];
+    kfree(contents);
+
+    uint32_t toRet;
+    if (level > 1) toRet = marfs_get_recursive(level - 1, i, next_recLBA);
+    else toRet = next_recLBA;
+    last_maxlevel = 0;
+    return toRet;
+}
+
+uint32_t marfs_get_block(struct marfs_INODE *inode, uint32_t i) {
+    if (i > 9 + (128 * 128 * 128)) {
+        return marfs_get_recursive(4, i, inode->ext_4);
+    } else if (i > 9 + (128 * 128)) {
+        return marfs_get_recursive(3, i, inode->ext_3);
+    } else if (i > 9 + 128) {
+        return marfs_get_recursive(2, i, inode->ext_2);
+    } else if (i > 9) {
+        return marfs_get_recursive(1, i, inode->ext_1);
+    } else {
+        return inode->DBPs[i];
+    }
+}
+
+void marfs_read_whole_file(uint32_t LBAinode, uint8_t *buffer) {
+    struct marfs_INODE *inode = (struct marfs_INODE *) ATA_read28(iface, LBAinode);
+
+    uint32_t size_in_blocks = inode->n_blocks;
+    for (uint32_t i = 0; i < size_in_blocks; i++) {
+        uint32_t this_block = marfs_get_block(inode, i);
+        uint8_t *this_block_contents = ATA_read28(iface, this_block);
+        uint16_t upper_bound = (i != size_in_blocks - 1) ? 512 : (inode->size % 512);
+        for (uint16_t j = 0; j < upper_bound; j++) buffer[(i * 512) + j] = this_block_contents[j];
+        kfree(this_block_contents);
+    }
+
+    kfree(inode);
+}
+
+// TODO: Beautify
+uint8_t *marfs_allocate_and_read_whole_file(uint32_t LBAinode) {
+    struct marfs_INODE *inode = (struct marfs_INODE *) ATA_read28(iface, LBAinode);
+    uint64_t size = inode->size;
+    kfree(inode);
+
+    uint8_t *buffer = kmalloc(size);
+    marfs_read_whole_file(LBAinode, buffer);
+    return buffer;
+}
diff --git a/src/kernel/fs/marfs/sectorlevel.c b/src/kernel/fs/marfs/sectorlevel.c
new file mode 100644
index 0000000..7575f8c
--- /dev/null
+++ b/src/kernel/fs/marfs/sectorlevel.c
@@ -0,0 +1,101 @@
+#include <stdint.h>
+#include <kernel/lib/alloc.h>
+#include <kernel/fs/ata_pio.h>
+#include "marfs.h"
+
+uint8_t marfs_init(struct ATA_INTERFACE *_iface) {
+    iface = _iface;
+    uint16_t identifydata[256 * 2];
+    uint8_t ret = ATA_identify(iface, identifydata);
+    maxLBA = (identifydata[61] << 16) + identifydata[60];
+    return ret;
+}
+
+uint32_t marfs_get_max_lba(void) { return maxLBA; }
+
+uint8_t marfs_write_mbr(uint8_t *mbr) {
+    return ATA_write28(iface, 0, mbr);
+}
+
+struct marfs_SUPERBLOCK *marfs_read_superblock() {
+    struct marfs_SUPERBLOCK *p = (struct marfs_SUPERBLOCK *) ATA_read28(iface, 1);
+    sb_cache = *p;
+    return p;
+}
+
+uint8_t marfs_writeSB(struct marfs_SUPERBLOCK *sb) {
+    sb_cache = *sb;
+    return ATA_write28(iface, 1, (uint8_t *) sb);
+}
+
+uint32_t marfs_get_free_lba_block(void) {
+    uint32_t offset = 2 + sb_cache.s_first_chunk;
+    uint8_t *p = 0;
+    for (uint32_t i = 0; i < sb_cache.n_chunks; i++) {
+        p = ATA_read28(iface, offset);
+        if (!(*p & 0x80)) break;
+        kfree(p);
+        offset += 512;
+    }
+
+    offset++;
+    for (uint16_t i = 1; i < 512; i++) {
+        if (!p[i]) break;
+        offset++;
+    }
+    kfree(p);
+
+    ATA_clear28(iface, offset);
+
+    return offset;
+}
+
+static uint8_t marfs_mark_block(uint32_t lba_sector, uint8_t mode) {
+    lba_sector -= 2;
+    lba_sector -= sb_cache.s_first_chunk;
+    uint16_t block_in_chunk = lba_sector % 512;
+    lba_sector /= 512;
+    lba_sector = 2 + sb_cache.s_first_chunk + (512 * lba_sector);
+
+    uint8_t *p = ATA_read28(iface, lba_sector);
+    p[block_in_chunk] = mode;
+
+    if (mode == 0) {
+        p[0] = 0;
+    } else {
+        uint8_t full_chunk = 1;
+        for (uint16_t i = 1; i < 512; i++) {
+            if (!p[i]) {
+                full_chunk = 0;
+                break;
+            }
+        }
+        p[0] = full_chunk;
+    }
+
+    uint8_t ret = ATA_write28(iface, lba_sector, p);
+    kfree(p);
+    return ret;
+}
+
+uint8_t marfs_mark_block_as_free(uint32_t lba_sector) { return marfs_mark_block(lba_sector, 0); }
+
+uint8_t marfs_mark_block_as_used(uint32_t lba_sector) { return marfs_mark_block(lba_sector, 1); }
+
+uint32_t marfs_get_free_lba_inode(void) {
+    uint32_t offset;
+    for (offset = 2; offset < 2 + sb_cache.n_inodes; offset++) {
+        struct marfs_INODE *inode = (struct marfs_INODE *) ATA_read28(iface, offset);
+        uint8_t used = inode->isUsed;
+        kfree(inode);
+        if (!used) break;
+    }
+    return offset;
+}
+
+void marfs_mark_inode_as_free(uint32_t lba_sector) {
+    struct marfs_INODE *inode = (struct marfs_INODE *) ATA_read28(iface, lba_sector);
+    inode->isUsed = 0;
+    ATA_write28(iface, lba_sector, (uint8_t *) inode);
+    kfree(inode);
+}
\ No newline at end of file