Kernel/VFS: Change polling from variables to functions

Instead of having to store state in variables functions are called to
check the object directly.

9 files changed, 53 insertions, 59 deletions

diff --git a/kernel/fs/devfs.c b/kernel/fs/devfs.c
index c25c996..8139448 100644
--- a/kernel/fs/devfs.c
+++ b/kernel/fs/devfs.c
@@ -1,3 +1,4 @@
+#include <assert.h>
 #include <drivers/keyboard.h>
 #include <drivers/serial.h>
 #include <fs/devfs.h>
@@ -10,8 +11,9 @@ int num_files = 0;
 vfs_inode_t *devfs_add_file(
     char *path, int (*read)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
     int (*write)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
-    vfs_vm_object_t *(get_vm_object)(u64 length, u64 offset, vfs_fd_t *fd),
-    u8 has_data, u8 can_write, int type) {
+    vfs_vm_object_t *(*get_vm_object)(u64 length, u64 offset, vfs_fd_t *fd),
+    int (*has_data)(vfs_inode_t *inode), int (*can_write)(vfs_inode_t *inode),
+    int type) {
   files[num_files].name = copy_and_allocate_string(path);
 
   vfs_inode_t *i = kcalloc(1, sizeof(vfs_inode_t));
@@ -21,9 +23,9 @@ vfs_inode_t *devfs_add_file(
   i->write = write;
   i->close = NULL;
   i->get_vm_object = get_vm_object;
-  i->has_data = has_data;
+  i->_has_data = has_data;
+  i->_can_write = can_write;
   i->is_open = 1;
-  i->can_write = can_write;
   i->ref = 1;
   num_files++;
   return i;
@@ -73,13 +75,23 @@ int serial_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   return rc;
 }
 
+int always_has_data(vfs_inode_t *inode) {
+  (void)inode;
+  return 1;
+}
+
+int always_can_write(vfs_inode_t *inode) {
+  (void)inode;
+  return 1;
+}
+
 void add_serial(void) {
-  devfs_add_file("/serial", NULL, serial_write, NULL, 0, 1,
+  devfs_add_file("/serial", NULL, serial_write, NULL, NULL, always_can_write,
                  FS_TYPE_CHAR_DEVICE);
 }
 
 void add_stdout(void) {
-  devfs_add_file("/stdout", NULL, stdout_write, NULL, 0, 1,
+  devfs_add_file("/stdout", NULL, stdout_write, NULL, NULL, always_can_write,
                  FS_TYPE_CHAR_DEVICE);
 }
 
diff --git a/kernel/fs/devfs.h b/kernel/fs/devfs.h
index 8ebadae..09bf4d6 100644
--- a/kernel/fs/devfs.h
+++ b/kernel/fs/devfs.h
@@ -19,6 +19,10 @@ vfs_inode_t *devfs_add_file(
     char *path, int (*read)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
     int (*write)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
     vfs_vm_object_t *(*get_vm_object)(u64 length, u64 offset, vfs_fd_t *fd),
-    u8 has_data, u8 can_write, int type);
+    int (*has_data)(vfs_inode_t *inode), int (*can_write)(vfs_inode_t *inode),
+    int type);
 
+
+int always_has_data(vfs_inode_t *inode);
+int always_can_write(vfs_inode_t *inode);
 #endif
diff --git a/kernel/fs/ext2.c b/kernel/fs/ext2.c
index c3fbd73..db947c0 100644
--- a/kernel/fs/ext2.c
+++ b/kernel/fs/ext2.c
@@ -604,7 +604,7 @@ vfs_inode_t *ext2_open(const char *path) {
     break;
   }
 
-  return vfs_create_inode(inode_num, type, 1 /*has_data*/, 1 /*can_write*/,
+  return vfs_create_inode(inode_num, type, NULL, NULL,
                           1 /*is_open*/, NULL /*internal_object*/, file_size,
                           ext2_open, ext2_create_file, ext2_read, ext2_write,
                           ext2_close, ext2_create_directory,
@@ -805,7 +805,7 @@ vfs_inode_t *ext2_mount(void) {
     return NULL;
   }
   int fd = vfs_open("/dev/sda", O_RDWR, 0);
-  if(0 > fd) {
+  if (0 > fd) {
     kfree(cache);
     return NULL;
   }
diff --git a/kernel/fs/fifo.c b/kernel/fs/fifo.c
index 5b01616..8a00b42 100644
--- a/kernel/fs/fifo.c
+++ b/kernel/fs/fifo.c
@@ -62,21 +62,3 @@ FIFO_FILE *create_fifo_object(void) {
   n->write_len = 0;
   return n;
 }
-
-int fifo_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
-  (void)offset;
-  FIFO_FILE *file = (FIFO_FILE *)fd->inode->internal_object;
-  int rc = fifo_object_write(buffer, offset, len, file);
-  fd->inode->has_data = file->has_data;
-  fd->inode->can_write = file->can_write;
-  return rc;
-}
-
-int fifo_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
-  FIFO_FILE *file = (FIFO_FILE *)fd->inode->internal_object;
-  file->is_blocking = !(fd->flags & O_NONBLOCK);
-  int rc = fifo_object_read(buffer, offset, len, file);
-  fd->inode->has_data = file->has_data;
-  fd->inode->can_write = file->can_write;
-  return rc;
-}
diff --git a/kernel/fs/fifo.h b/kernel/fs/fifo.h
index 450b9b5..3cc0b84 100644
--- a/kernel/fs/fifo.h
+++ b/kernel/fs/fifo.h
@@ -17,6 +17,4 @@ struct S_FIFO_FILE {
 FIFO_FILE *create_fifo_object(void);
 int fifo_object_write(u8 *buffer, u64 offset, u64 len, FIFO_FILE *file);
 int fifo_object_read(u8 *buffer, u64 offset, u64 len, FIFO_FILE *file);
-int fifo_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd);
-int fifo_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd);
 #endif
diff --git a/kernel/fs/shm.c b/kernel/fs/shm.c
index 0735efc..caf356c 100644
--- a/kernel/fs/shm.c
+++ b/kernel/fs/shm.c
@@ -87,11 +87,10 @@ int shm_open(const char *name, int oflag, mode_t mode) {
   }
 
   vfs_inode_t *inode = vfs_create_inode(
-      0 /*inode_num*/, 0 /*type*/, 1 /*has_data*/, 1 /*can_write*/,
-      1 /*is_open*/, internal_object, 0 /*file_size*/, NULL /*open*/,
-      NULL /*create_file*/, shm_read, shm_write, NULL /*close*/,
-      NULL /*create_directory*/, shm_get_vm_object, shm_ftruncate,
-      NULL /*stat*/, NULL /*send_signal*/);
+      0 /*inode_num*/, 0 /*type*/, NULL, NULL, 1 /*is_open*/,
+      internal_object, 0 /*file_size*/, NULL /*open*/, NULL /*create_file*/,
+      shm_read, shm_write, NULL /*close*/, NULL /*create_directory*/,
+      shm_get_vm_object, shm_ftruncate, NULL /*stat*/, NULL /*send_signal*/);
 
   vfs_fd_t *fd_ptr;
   int fd = vfs_create_fd(oflag, mode, 0 /*is_tty*/, inode, &fd_ptr);
diff --git a/kernel/fs/tmpfs.c b/kernel/fs/tmpfs.c
index 3ef774c..eb6ae34 100644
--- a/kernel/fs/tmpfs.c
+++ b/kernel/fs/tmpfs.c
@@ -10,6 +10,16 @@ void tmp_close(vfs_fd_t *fd) {
   ((tmp_inode *)fd->inode->internal_object)->read_inode->is_open = 0;
 }
 
+int tmp_has_data(vfs_inode_t *inode) {
+  tmp_inode *calling_file = inode->internal_object;
+  return calling_file->fifo->has_data;
+}
+
+int tmp_can_write(vfs_inode_t *inode) {
+  tmp_inode *child_file = inode->internal_object;
+  return child_file->fifo->can_write;
+}
+
 int tmp_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   tmp_inode *calling_file = fd->inode->internal_object;
   tmp_inode *child_file = calling_file->read_inode->internal_object;
@@ -17,23 +27,16 @@ int tmp_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
     return -EPIPE;
   }
 
-  int rc = fifo_object_write(buffer, offset, len, child_file->fifo);
-  calling_file->read_inode->has_data = child_file->fifo->has_data;
-  fd->inode->can_write = child_file->fifo->can_write;
-  return rc;
+  return fifo_object_write(buffer, offset, len, child_file->fifo);
 }
 
 int tmp_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   tmp_inode *calling_file = fd->inode->internal_object;
-  tmp_inode *child_file = calling_file->read_inode->internal_object;
   if (calling_file->is_closed) {
     return -EPIPE;
   }
 
-  int rc = fifo_object_read(buffer, offset, len, calling_file->fifo);
-  fd->inode->has_data = calling_file->fifo->has_data;
-  calling_file->read_inode->can_write = child_file->fifo->can_write;
-  return rc;
+  return fifo_object_read(buffer, offset, len, calling_file->fifo);
 }
 
 void dual_pipe(int fd[2]) {
@@ -42,12 +45,10 @@ void dual_pipe(int fd[2]) {
     tmp_inode *pipe = kmalloc(sizeof(tmp_inode));
     pipe->fifo = create_fifo_object();
 
-    int has_data = 0;
-    int can_write = 1;
     int is_open = 1;
     void *internal_object = pipe;
     vfs_inode_t *inode = vfs_create_inode(
-        0 /*inode_num*/, 0 /*type*/, has_data, can_write, is_open,
+        0 /*inode_num*/, 0 /*type*/, tmp_has_data, tmp_can_write, is_open,
         internal_object, 0 /*file_size*/, NULL /*open*/, NULL /*create_file*/,
         tmp_read, tmp_write, tmp_close, NULL /*create_directory*/,
         NULL /*get_vm_object*/, NULL /*truncate*/, NULL /*stat*/,
@@ -77,12 +78,10 @@ void pipe(int fd[2]) {
     tmp_inode *pipe = kmalloc(sizeof(tmp_inode));
     pipe->fifo = create_fifo_object();
 
-    int has_data = 0;
-    int can_write = 1;
     int is_open = 1;
     void *internal_object = pipe;
     vfs_inode_t *inode = vfs_create_inode(
-        0 /*inode_num*/, 0 /*type*/, has_data, can_write, is_open,
+        0 /*inode_num*/, 0 /*type*/, tmp_has_data, tmp_can_write, is_open,
         internal_object, 0 /*file_size*/, NULL /*open*/, NULL /*create_file*/,
         tmp_read, tmp_write, tmp_close, NULL /*create_directory*/,
         NULL /*get_vm_object*/, NULL /*truncate*/, NULL /*stat*/,
diff --git a/kernel/fs/vfs.c b/kernel/fs/vfs.c
index a55f78c..63db938 100644
--- a/kernel/fs/vfs.c
+++ b/kernel/fs/vfs.c
@@ -25,9 +25,9 @@ vfs_fd_t *get_vfs_fd(int fd, process_t *p) {
 }
 
 vfs_inode_t *vfs_create_inode(
-    int inode_num, int type, u8 has_data, u8 can_write, u8 is_open,
-    void *internal_object, u64 file_size,
-    vfs_inode_t *(*open)(const char *path),
+    int inode_num, int type, int (*has_data)(vfs_inode_t *inode),
+    int (*can_write)(vfs_inode_t *inode), u8 is_open, void *internal_object,
+    u64 file_size, vfs_inode_t *(*open)(const char *path),
     int (*create_file)(const char *path, int mode),
     int (*read)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
     int (*write)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
@@ -40,8 +40,8 @@ vfs_inode_t *vfs_create_inode(
   vfs_inode_t *r = kmalloc(sizeof(inode_t));
   r->inode_num = inode_num;
   r->type = type;
-  r->has_data = has_data;
-  r->can_write = can_write;
+  r->_has_data = has_data;
+  r->_can_write = can_write;
   r->is_open = is_open;
   r->internal_object = internal_object;
   r->file_size = file_size;
diff --git a/kernel/fs/vfs.h b/kernel/fs/vfs.h
index e75d12e..83f1375 100644
--- a/kernel/fs/vfs.h
+++ b/kernel/fs/vfs.h
@@ -55,8 +55,8 @@ struct vfs_inode {
   int inode_num;
   int type;
   int ref;
-  u8 has_data;
-  u8 can_write;
+  int (*_has_data)(vfs_inode_t *iinode);
+  int (*_can_write)(vfs_inode_t *iinode);
   u8 is_open;
   void *internal_object;
   u64 file_size;
@@ -92,9 +92,9 @@ int vfs_ftruncate(int fd, size_t length);
 int vfs_chdir(const char *path);
 int vfs_fstat(int fd, struct stat *buf);
 vfs_inode_t *vfs_create_inode(
-    int inode_num, int type, u8 has_data, u8 can_write, u8 is_open,
-    void *internal_object, u64 file_size,
-    vfs_inode_t *(*open)(const char *path),
+    int inode_num, int type, int (*has_data)(vfs_inode_t *inode),
+    int (*can_write)(vfs_inode_t *inode), u8 is_open, void *internal_object,
+    u64 file_size, vfs_inode_t *(*open)(const char *path),
     int (*create_file)(const char *path, int mode),
     int (*read)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),
     int (*write)(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd),