Cleaned up code added VFS open flags and >. next up >> will come.

Author: pradosh-arduino

disk.img

@@ -18,13 +18,23 @@
 typedef struct {
     mount_entry_t* mnt;
     fat16_file_t f;
+    int flags;
 } vfs_file_t;
 
 typedef struct {
     mount_entry_t* mnt;
     const char*    rel_path;
 } vfs_mount_res_t;
 
+/* Open flags */
+#define VFS_O_RDONLY  0x0001
+#define VFS_O_WRONLY  0x0002
+#define VFS_O_RDWR    0x0003
+
+#define VFS_O_CREAT   0x0100
+#define VFS_O_TRUNC   0x0200
+#define VFS_O_APPEND  0x0400
+
 
 // Current working directory
 extern char vfs_cwd[256];
@@ -35,7 +45,7 @@ extern char vfs_cwd[256];
  * @param out_file Pointer to vfs_file_t to receive file handle
  * @return 0 on success, negative on error
  */
-int vfs_open(const char* path, vfs_file_t* out_file);
+int vfs_open(const char* path, int flags, vfs_file_t* out_file);
 
 /**
  * @brief Read from an open file

source/includes/filesystems/vfs.h

@@ -25,6 +25,7 @@
 #include <filesystems/fwrfs.h>
 #include <fdlfcn.h>
 #include <commands/commands.h>
+#include <stream.h>
 
 #define BUFFER_SIZE 128
 #define MAX_COMMAND_LINE 1024
@@ -46,6 +47,14 @@ typedef struct
     size_t count;
 } command_list;
 
+typedef struct {
+    int redirect_stdout;
+    int redirect_stderr;
+    int append;
+    const char* filename;
+} redir_t;
+
+
 /**
  * @brief Wrapper to store properly the function commands list.
  * 

source/includes/sh_util.h

@@ -475,17 +475,19 @@ int fat16_read(fat16_file_t* f, uint8_t* out, uint32_t size) {
     return read;
 }
 
-int fat16_write(fat16_file_t* f, const uint8_t* data, uint32_t size) {
+int fat16_write(fat16_file_t* f, const uint8_t* data, uint32_t size)
+{
     uint32_t written = 0;
     uint8_t sector[512];
 
     uint32_t cluster_size =
         f->fs->bs.sectors_per_cluster * 512;
 
-    /* ---------- allocate first cluster if empty ---------- */
+    /* ---------- allocate first cluster ---------- */
     if (f->entry.first_cluster == 0) {
         uint16_t c = fat16_allocate_cluster(f->fs);
-        if (!c) return FAT_OK;
+        if (!c)
+            return written;
 
         fat16_write_fat_entry(f->fs, c, FAT16_EOC);
         f->entry.first_cluster = c;
@@ -502,12 +504,16 @@ int fat16_write(fat16_file_t* f, const uint8_t* data, uint32_t size) {
         /* ---------- walk / extend FAT chain ---------- */
         for (uint32_t i = 0; i < cluster_index; i++) {
             uint16_t next = fat16_read_fat_fs(f->fs, cluster);
+
             if (next >= FAT16_EOC) {
                 next = fat16_allocate_cluster(f->fs);
-                if (!next) return written;
+                if (!next)
+                    return written;
+
                 fat16_write_fat_entry(f->fs, cluster, next);
                 fat16_write_fat_entry(f->fs, next, FAT16_EOC);
             }
+
             cluster = next;
         }
 
@@ -528,8 +534,7 @@ int fat16_write(fat16_file_t* f, const uint8_t* data, uint32_t size) {
         written += to_copy;
     }
 
-    if (f->pos > f->entry.filesize)
-        f->entry.filesize = f->pos;
+    f->entry.filesize = f->pos;
 
     /* ---------- update directory entry ---------- */
     if (f->parent_cluster == 0)
@@ -554,14 +559,16 @@ uint16_t fat16_find_free_cluster(fat16_fs_t* fs) {
         uint16_t* fat = (uint16_t*)sector;
         for (int i = 0; i < 256; i++) {
             uint16_t cluster = s * 256 + i;
-            if (cluster < 2) continue;
 
-            if (fat[i] == 0x0000) {
+            if (cluster < 2)
+                continue;
+
+            if (fat[i] == 0x0000)
                 return cluster;
-            }
         }
     }
-    return FAT_OK; // no space
+
+    return 0; // ✅ NO SPACE
 }
 
 void fat16_write_fat_entry(fat16_fs_t* fs, uint16_t cluster, uint16_t value) {
@@ -579,17 +586,16 @@ void fat16_write_fat_entry(fat16_fs_t* fs, uint16_t cluster, uint16_t value) {
 
 uint16_t fat16_allocate_cluster(fat16_fs_t* fs) {
     uint16_t cluster = fat16_find_free_cluster(fs);
-    if (!cluster)
-        return FAT_OK;
+    if (cluster == 0)
+        return 0;
 
     fat16_write_fat_entry(fs, cluster, FAT16_EOC);
 
     uint8_t zero[512] = {0};
     uint32_t lba = fat16_cluster_lba(fs, cluster);
 
-    for (uint32_t s = 0; s < fs->bs.sectors_per_cluster; s++) {
+    for (uint32_t s = 0; s < fs->bs.sectors_per_cluster; s++)
         ahci_write_sector(fs->portno, lba + s, zero, 1);
-    }
 
     return cluster;
 }
@@ -835,24 +841,27 @@ int fat16_unlink(fat16_fs_t* fs, uint16_t parent_cluster, const char* name) {
     return fat16_delete_entry_in_cluster(fs, parent_cluster, fatname);
 }
 
-int fat16_truncate(fat16_file_t* f, uint32_t new_size) {
-    if (new_size >= f->entry.filesize)
-        return FAT_OK;
-
+int fat16_truncate(fat16_file_t* f, uint32_t new_size)
+{
     uint32_t cluster_size =
         f->fs->bs.sectors_per_cluster * 512;
 
-    /* ----- truncate to zero ----- */
+    /* ---------- truncate to zero ---------- */
     if (new_size == 0) {
         if (f->entry.first_cluster >= 2)
             fat16_free_chain(f->fs, f->entry.first_cluster);
 
         f->entry.first_cluster = 0;
         f->entry.filesize = 0;
-
-        goto update;
+        f->pos = 0;
+        f->cluster = 0;
+        return FAT_OK;
     }
 
+    /* ---------- no-op grow ---------- */
+    if (new_size >= f->entry.filesize)
+        return FAT_OK;
+
     uint32_t keep_clusters =
         (new_size + cluster_size - 1) / cluster_size;
 
@@ -871,16 +880,13 @@ int fat16_truncate(fat16_file_t* f, uint32_t new_size) {
         fat16_free_chain(f->fs, cluster);
 
     f->entry.filesize = new_size;
-    
-update:
-    if (f->parent_cluster == 0)
-        fat16_update_root_entry(f->fs, &f->entry);
-    else
-        fat16_update_dir_entry(f->fs, f->parent_cluster, &f->entry);
+    if (f->pos > new_size)
+        f->pos = new_size;
 
     return FAT_OK;
 }
 
+
 int fat16_mkdir(fat16_fs_t* fs, uint16_t parent_cluster, const char* name) {
     if (fat16_is_reserved_name(name)) {
         printf("refusing to create reserved name '%s'", name);

source/kernel/C/filesystems/fat16.c

@@ -115,32 +115,39 @@ static void vfs_normalize_path(const char* in, char* out) {
     out[oi] = '\0';
 }
 
-int vfs_read(vfs_file_t* file, uint8_t* buf, uint32_t size) {
-    if (!file || !file->mnt || !buf){
-        eprintf("read: invalid parameters passed");
+int vfs_read(vfs_file_t* file, uint8_t* buf, uint32_t size)
+{
+    if (!file || !buf)
         return -1;
-    }
 
-    if (file->mnt->type == FS_FAT16)
-        return fat16_read(&file->f, buf, size);
+    if (!(file->flags & VFS_O_RDONLY) &&
+        !(file->flags & VFS_O_RDWR)) {
+        eprintf("read: file not opened for reading");
+        return -2;
+    }
 
-    eprintf("read: unknown filesystem");
-    return -2;
+    return fat16_read(&file->f, buf, size);
 }
 
-int vfs_write(vfs_file_t* file, const uint8_t* buf, uint32_t size) {
-    if (!file || !file->mnt || !buf){
-        eprintf("write: invalid parameters passed");
+
+int vfs_write(vfs_file_t* file, const uint8_t* buf, uint32_t size)
+{
+    if (!file || !buf)
         return -1;
+
+    if (!(file->flags & VFS_O_WRONLY) &&
+        !(file->flags & VFS_O_RDWR)) {
+        eprintf("write: file not opened for writing");
+        return -2;
     }
 
-    if (file->mnt->type == FS_FAT16)
-        return fat16_write(&file->f, buf, size);
+    // if (file->flags & VFS_O_APPEND)
+    //     file->f.pos = file->f.size;
 
-    eprintf("write: unknown filesystem");
-    return -2;
+    return fat16_write(&file->f, buf, size);
 }
 
+
 void vfs_close(vfs_file_t* file) {
     if (!file || !file->mnt) {
         eprintf("close: invalid file pointer");
@@ -206,29 +213,64 @@ int vfs_ls(const char* path)
     return 0;
 }
 
-int vfs_open(const char* path, vfs_file_t* out) {
+int vfs_open(const char* path, int flags, vfs_file_t* out)
+{
     if (!path || !out) {
-        eprintf("open: invalid parameters passed");
+        eprintf("open: invalid parameters");
         return -1;
     }
 
     char norm[256];
     vfs_normalize_path(path, norm);
 
     vfs_mount_res_t res;
-    if (vfs_resolve_mount(norm, &res) != 0) return -2;
+    if (vfs_resolve_mount(norm, &res) != 0)
+        return -2;
 
-    if (res.mnt->type == FS_FAT16) {
-        if (fat16_open((fat16_fs_t*)res.mnt->fs, res.rel_path, &out->f) != 0)
-            return -4;
+    if (res.mnt->type != FS_FAT16) {
+        eprintf("open: unknown filesystem");
+        return -3;
+    }
 
-        out->mnt = res.mnt;
+    fat16_fs_t* fs = (fat16_fs_t*)res.mnt->fs;
+    int ret;
+
+    /* ---------- CREATE ---------- */
+    if (flags & VFS_O_CREAT) {
+        /* create if missing */
+        ret = fat16_open(fs, res.rel_path, &out->f);
+        if (ret != 0) {
+            /* create new file */
+            ret = fat16_create_path(fs, res.rel_path,
+                                    FAT16_ROOT_CLUSTER,
+                                    0x20); /* archive */
+            if (ret != 0)
+                return -4;
 
-        return 0;
+            ret = fat16_open(fs, res.rel_path, &out->f);
+            if (ret != 0)
+                return -5;
+        }
+    } else {
+        ret = fat16_open(fs, res.rel_path, &out->f);
+        if (ret != 0)
+            return -6;
+    }
+
+    /* ---------- TRUNC ---------- */
+    if (flags & VFS_O_TRUNC) {
+        fat16_truncate(&out->f, 0);
     }
 
-    eprintf("open: unknown filesystem");
-    return -3;
+    /* ---------- APPEND ---------- */
+    // if (flags & VFS_O_APPEND) {
+    //     out->f.pos = out->f.size;
+    // }
+
+    out->mnt   = res.mnt;
+    out->flags = flags;
+
+    return 0;
 }
 
 int vfs_mkdir(const char* path) {

source/kernel/C/filesystems/vfs.c

@@ -249,14 +249,10 @@ void main(void) {
 
 void shutdown(){
     info("shutdown has been called", __FILE__);
-    debug_printf("hhdm offset -> 0x%x", hhdm_request.response->offset);
-
     acpi_shutdown_hack(hhdm_request.response->offset, acpi_find_sdt);
 }
 
 void reboot(){
     info("reboot has been called", __FILE__);
-    debug_printf("hhdm offset -> 0x%x", hhdm_request.response->offset);
-
     acpi_reboot(hhdm_request.response->offset);
 }

source/kernel/C/kernel.c

@@ -29,7 +29,7 @@ int cmd_cat(int argc, char** argv)
         vfs_file_t file;
 
         /* Open file */
-        if (vfs_open(argv[i], &file) != 0) {
+        if (vfs_open(argv[i], VFS_O_RDONLY, &file) != 0) {
             printf("cat: %s: no such file or directory", argv[i]);
             continue;
         }