Simple file IO with the ioctl syscall

kernel/Makefile

@@ -59,6 +59,7 @@ SRCFILES += $(call GRABSRC, \
               flanterm/src \
               flanterm/src/flanterm_backends \
               syscall \
+							path \
             )
 
 ifeq ($(ARCH),x86_64)

kernel/fs/portlfs/portlfs.c

@@ -27,6 +27,10 @@ void littlefs_vobj_cleanup(struct VfsObj *vobj) {
 }
 
 int32_t littlefs_vobj_read(struct VfsObj *vobj, uint8_t *const buffer, size_t n, size_t off) {
+  if (!(vobj->flags & VFS_FLAG_READ)) {
+    return E_INVALIDOPER;
+  }
+
   spinlock_acquire(&vobj->spinlock);
   
   int ok = lfs_file_seek(&vobj->vmp->fs.littlefs.instance, (lfs_file_t *)vobj->extra, off, LFS_SEEK_SET);
@@ -45,6 +49,29 @@ int32_t littlefs_vobj_read(struct VfsObj *vobj, uint8_t *const buffer, size_t n,
   return E_OK;
 }
 
+int32_t littlefs_vobj_write(struct VfsObj *vobj, const uint8_t *const buffer, size_t n, size_t off) {
+  if (!(vobj->flags & VFS_FLAG_WRITE)) {
+    return E_INVALIDOPER;
+  }
+
+  spinlock_acquire(&vobj->spinlock);
+
+  int ok = lfs_file_seek(&vobj->vmp->fs.littlefs.instance, (lfs_file_t *)vobj->extra, off, LFS_SEEK_SET);
+  if (ok < 0) {
+    spinlock_release(&vobj->spinlock);
+    return E_BADIO;
+  }
+
+  ok = lfs_file_write(&vobj->vmp->fs.littlefs.instance, (lfs_file_t *)vobj->extra, buffer, n);
+  if (ok < 0) {
+    spinlock_release(&vobj->spinlock);
+    return E_BADIO;
+  }
+
+  spinlock_release(&vobj->spinlock);
+  return E_OK;
+}
+
 int32_t littlefs_vobj_stat(struct VfsObj *vobj, struct VfsStat *stat) {
   struct lfs_info statbuf;
 
@@ -107,12 +134,14 @@ struct VfsObj *littlefs_open(struct VfsMountPoint *vmp, const char *path, uint32
     return NULL;
   }
 
+  vobj->flags = flags;
   vobj->extra = file;
   vobj->extrasize = sizeof(*file);
   vobj->vmp = vmp;
   vobj->cleanup = &littlefs_vobj_cleanup;
   vobj->read = &littlefs_vobj_read;
   vobj->stat = &littlefs_vobj_stat;
+  vobj->write = &littlefs_vobj_write;
   hal_strcpy(vobj->path, path);
 
   spinlock_release(&vmp->spinlock);

kernel/path/path.c

@@ -0,0 +1,41 @@
+#include "path.h"
+
+void path_parse(const char *in, char *mp, char *path) {
+  if (in == 0 || *in == 0) {
+    mp[0] = 0;
+    path[0] = 0;
+    return;
+  }
+
+  int i = 0, j = 0, colonfound = 0;
+
+  while (in[i]) {
+    if (in[i] == ':') {
+      if (colonfound) {
+        mp[0] = 0;
+        path[0] = 0;
+        return;
+      }
+      colonfound = 1;
+      mp[i] = 0;
+      i++;
+      continue;
+    }
+
+    if (!colonfound) {
+      mp[i] = in[i];
+    } else {
+      path[j++] = in[i];
+    }
+
+    i++;
+  }
+
+  if (!colonfound) {
+    mp[i] = 0;
+    path[0] = 0;
+  } else {
+    path[j] = 0;
+  }
+}
+

kernel/path/path.h

@@ -0,0 +1,6 @@
+#ifndef PATH_PATH_H_
+#define PATH_PATH_H_
+
+void path_parse(const char *in, char *mp, char *path);
+
+#endif // PATH_PATH_H_

kernel/proc/proc.h

@@ -41,6 +41,7 @@ typedef struct Proc {
   bool kern;
 
   VfsObj *vobjs[PROC_VFSHANDLES_MAX];
+  uint64_t vobjcnt;
 } Proc;
 
 typedef struct {

kernel/syscall/ioctl.c

@@ -0,0 +1,139 @@
+#include <stdint.h>
+#include <stddef.h>
+#include "syscall.h"
+#include "sysdefs/ioctl.h"
+#include "errors.h"
+#include "path/path.h"
+#include "vfs/vfs.h"
+#include "kprintf.h"
+#include "proc/proc.h"
+#include "spinlock/spinlock.h"
+
+#define IOCTL_MP_MAX 0xff
+#define IOCTL_PATH_MAX VFS_PATH_MAX
+
+int32_t SYSCALL3(sys_ioctl, ioh1, cmd1, optsptr1) {
+  uint64_t ioh = ioh1;
+  uint64_t cmd = cmd1;
+  int32_t ret = E_BADIO;
+
+  switch (cmd) {
+    case IOCTL_OPENF: {
+      IOCtlOF *ioctlof = (IOCtlOF *)(void *)optsptr1;
+
+      if (ioctlof == NULL) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      char mp[IOCTL_MP_MAX];
+      char path[IOCTL_PATH_MAX];
+
+      if (ioctlof->path == NULL) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      path_parse(ioctlof->path, mp, path);
+
+      VfsObj *vobj = vfs_open(mp, path, ioctlof->flags);
+      if (vobj == NULL) {
+        ret = E_NOENTRY;
+        goto done;
+      }
+
+      spinlock_acquire(&PROCS.spinlock);
+
+      Proc *proc = PROCS.current;
+      if (proc->vobjcnt < PROC_VFSHANDLES_MAX) {
+        proc->vobjs[proc->vobjcnt++] = vobj;
+        ret = proc->vobjcnt - 1;
+      } else {
+        ret = E_NOMEMORY;
+      }
+
+      spinlock_release(&PROCS.spinlock);
+    } break;
+    case IOCTL_CLOSEF: {
+      spinlock_acquire(&PROCS.spinlock);
+      Proc *proc = PROCS.current;
+      VfsObj *vobj = proc->vobjs[ioh];
+      spinlock_release(&PROCS.spinlock);
+
+      if (vobj == NULL) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      vfs_close(vobj);
+      ret = E_OK;
+    } break;
+    case IOCTL_WRITE: {
+      IOCtlWF *ioctlwf = (IOCtlWF *)(void *)optsptr1;
+
+      if (ioctlwf == NULL) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      if (ioctlwf->buffer == NULL) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      if (ioh >= PROC_VFSHANDLES_MAX) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      spinlock_acquire(&PROCS.spinlock);
+      Proc *proc = PROCS.current;
+      VfsObj *vobj = proc->vobjs[ioh];
+      spinlock_release(&PROCS.spinlock);
+
+      if (vobj == NULL) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      ret = vobj->write(vobj, ioctlwf->buffer, ioctlwf->len, ioctlwf->off);
+    } break;
+    case IOCTL_READ: {
+      IOCtlRF *ioctlrf = (IOCtlRF *)(void *)optsptr1;
+
+      if (ioctlrf == NULL) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      if (ioctlrf->buffer == NULL) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      if (ioh >= PROC_VFSHANDLES_MAX) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      spinlock_acquire(&PROCS.spinlock);
+      Proc *proc = PROCS.current;
+      VfsObj *vobj = proc->vobjs[ioh];
+      spinlock_release(&PROCS.spinlock);
+
+      if (vobj == NULL) {
+        ret = E_INVALIDARGUMENT;
+        goto done;
+      }
+
+      ret = vobj->read(vobj, ioctlrf->buffer, ioctlrf->len, ioctlrf->off);
+    } break;
+    default: {
+      ret = E_INVALIDARGUMENT;
+      goto done;
+    } break;
+  }
+
+done:
+  return ret;
+}

kernel/syscall/ioctl.h

@@ -0,0 +1,9 @@
+#ifndef SYSCALL_IOCTL_H_
+#define SYSCALL_IOCTL_H_
+
+#include <stdint.h>
+#include "syscall.h"
+
+int32_t SYSCALL3(sys_ioctl, ioh1, cmd1, optsptr1);
+
+#endif // SYSCALL_IOCTL_H_

kernel/syscall/syscall.c

@@ -4,6 +4,7 @@
 #include "kprintf.h"
 #include "processctl.h"
 #include "sysdefs/syscall.h"
+#include "ioctl.h"
 
 int32_t SYSCALL1(sys_debugprint, string) {
   char *p = (char *)string;
@@ -14,4 +15,5 @@ int32_t SYSCALL1(sys_debugprint, string) {
 SyscallFn SYSCALL_TABLE[SYSCALLS_MAX] = {
   [SYS_DEBUGPRINT] = &sys_debugprint,
   [SYS_PROCESSCTL] = &sys_processctl,
+  [SYS_IOCTL]      = &sys_ioctl,
 };

kernel/vfs/vfs.h

@@ -43,8 +43,10 @@ typedef struct VfsObj {
   size_t extrasize;
   struct VfsMountPoint *vmp;
   char path[VFS_PATH_MAX];
+  int32_t flags;
   int32_t (*read)(struct VfsObj *vobj, uint8_t *const buffer, size_t n, size_t off);
   int32_t (*stat)(struct VfsObj *vobj, struct VfsStat *stat);
+  int32_t (*write)(struct VfsObj *vobj, const uint8_t *const buffer, size_t n, size_t off);
   void (*cleanup)(struct VfsObj *vobj);
 } VfsObj;