Kernel/VFS: Change polling from variables to functions

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

18 files changed, 136 insertions, 112 deletions

diff --git a/kernel/drivers/ahci.c b/kernel/drivers/ahci.c
index 1fad0a3..34de443 100644
--- a/kernel/drivers/ahci.c
+++ b/kernel/drivers/ahci.c
@@ -485,6 +485,11 @@ int ahci_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   return rc;
 }
 
+int ahci_has_data(vfs_inode_t *inode) {
+  (void)inode;
+  return 1;
+}
+
 void add_devfs_drive_file(u8 port) {
   static u8 num_drives_added = 0;
   char *path = "/sda";
@@ -492,7 +497,7 @@ void add_devfs_drive_file(u8 port) {
   num_drives_added++;
   vfs_inode_t *inode =
       devfs_add_file(path, ahci_read, ahci_write, NULL /*get_vm_object*/,
-                     1 /*has_data*/, 0 /*can_write*/, FS_TYPE_BLOCK_DEVICE);
+                     ahci_has_data, NULL /*can_write*/, FS_TYPE_BLOCK_DEVICE);
   inode->inode_num = port;
 }
 
diff --git a/kernel/drivers/keyboard.c b/kernel/drivers/keyboard.c
index fe4fe16..ab61d58 100644
--- a/kernel/drivers/keyboard.c
+++ b/kernel/drivers/keyboard.c
@@ -155,9 +155,11 @@ void int_keyboard(reg_t *frame) {
   ev.mode |= is_alt_down << 1;
   ev.mode |= is_ctrl_down << 2;
   fifo_object_write((u8 *)&ev, 0, sizeof(ev), keyboard_fifo);
-  if (kb_inode) {
-    kb_inode->has_data = keyboard_fifo->has_data;
-  }
+}
+
+int keyboard_has_data(vfs_inode_t *inode) {
+  (void)inode;
+  return keyboard_fifo->has_data;
 }
 
 void install_keyboard(void) {
@@ -168,15 +170,14 @@ void install_keyboard(void) {
 int keyboard_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   (void)offset;
 
-  if (0 == fd->inode->has_data) {
+  int rc = fifo_object_read(buffer, 0, len, keyboard_fifo);
+  if (0 == rc) {
     return -EAGAIN;
   }
-  int rc = fifo_object_read(buffer, 0, len, keyboard_fifo);
-  fd->inode->has_data = keyboard_fifo->has_data;
   return rc;
 }
 
 void add_keyboard(void) {
-  kb_inode = devfs_add_file("/keyboard", keyboard_read, NULL, NULL, 0, 0,
-                            FS_TYPE_CHAR_DEVICE);
+  kb_inode = devfs_add_file("/keyboard", keyboard_read, NULL, NULL,
+                            keyboard_has_data, NULL, FS_TYPE_CHAR_DEVICE);
 }
diff --git a/kernel/drivers/mouse.c b/kernel/drivers/mouse.c
index 4b0696a..93e3be6 100644
--- a/kernel/drivers/mouse.c
+++ b/kernel/drivers/mouse.c
@@ -19,26 +19,25 @@ struct mouse_event {
   u8 y;
 };
 
+int fs_mouse_has_data(vfs_inode_t *inode) {
+  FIFO_FILE *f = inode->internal_object;
+  return f->has_data;
+}
+
 int fs_mouse_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
-  int rc = fifo_object_write(buffer, offset, len, fd->inode->internal_object);
   FIFO_FILE *f = fd->inode->internal_object;
-  mouse_inode->has_data = f->has_data;
-  return rc;
+  return fifo_object_write(buffer, offset, len, f);
 }
 
 int fs_mouse_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   FIFO_FILE *f = fd->inode->internal_object;
-  if (!mouse_inode->has_data) {
-    return 0;
-  }
-  int rc = fifo_object_read(buffer, offset, len, f);
-  mouse_inode->has_data = f->has_data;
-  return rc;
+  return fifo_object_read(buffer, offset, len, f);
 }
 
 void add_mouse(void) {
-  mouse_inode = devfs_add_file("/mouse", fs_mouse_read, fs_mouse_write, NULL, 0,
-                               0, FS_TYPE_CHAR_DEVICE);
+  mouse_inode =
+      devfs_add_file("/mouse", fs_mouse_read, fs_mouse_write, NULL,
+                     fs_mouse_has_data, always_can_write, FS_TYPE_CHAR_DEVICE);
   mouse_inode->internal_object = create_fifo_object();
   // Don't look at this
   int fd = vfs_open("/dev/mouse", O_RDWR, 0);
diff --git a/kernel/drivers/vbe.c b/kernel/drivers/vbe.c
index e67a3d9..c0603d6 100644
--- a/kernel/drivers/vbe.c
+++ b/kernel/drivers/vbe.c
@@ -37,7 +37,7 @@ int display_driver_init(multiboot_info_t *mbi) {
   framebuffer_physical = mbi->framebuffer_addr;
   framebuffer =
       mmu_map_frames((void *)(u32)mbi->framebuffer_addr, framebuffer_size);
-  if(!framebuffer) {
+  if (!framebuffer) {
     return 0;
   }
 
@@ -68,8 +68,8 @@ int display_info_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
 }
 
 void add_vbe_device(void) {
-  devfs_add_file("/vbe", NULL, NULL, vbe_get_vm_object, 1, 1,
-                 FS_TYPE_BLOCK_DEVICE);
-  devfs_add_file("/display_info", display_info_read, NULL, NULL, 1, 0,
-                 FS_TYPE_BLOCK_DEVICE);
+  devfs_add_file("/vbe", NULL, NULL, vbe_get_vm_object, always_has_data,
+                 always_can_write, FS_TYPE_BLOCK_DEVICE);
+  devfs_add_file("/display_info", display_info_read, NULL, NULL,
+                 always_has_data, NULL, FS_TYPE_BLOCK_DEVICE);
 }
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),
diff --git a/kernel/poll.c b/kernel/poll.c
index 7107646..4c6e411 100644
--- a/kernel/poll.c
+++ b/kernel/poll.c
@@ -57,11 +57,15 @@ int poll(struct pollfd *fds, size_t nfds, int timeout) {
         fds[i].revents |= POLLHUP;
       }
     } else {
-      if (f->inode->has_data && fds[i].events & POLLIN) {
-        fds[i].revents |= POLLIN;
+      if (f->inode->_has_data) {
+        if (f->inode->_has_data(f->inode) && fds[i].events & POLLIN) {
+          fds[i].revents |= POLLIN;
+        }
       }
-      if (f->inode->can_write && fds[i].events & POLLOUT) {
-        fds[i].revents |= POLLOUT;
+      if (f->inode->_can_write) {
+        if (f->inode->_can_write(f->inode) && fds[i].events & POLLOUT) {
+          fds[i].revents |= POLLOUT;
+        }
       }
       if (!(f->inode->is_open) && fds[i].events & POLLHUP) {
         fds[i].revents |= POLLHUP;
diff --git a/kernel/queue.c b/kernel/queue.c
index b1cf698..0bef21b 100644
--- a/kernel/queue.c
+++ b/kernel/queue.c
@@ -57,8 +57,10 @@ int queue_should_block(struct event_queue *q, int *is_empty) {
         kprintf("queue: Invalid fd given\n");
         continue;
       }
-      if (fd->inode->has_data) {
-        return 0;
+      if (fd->inode->_has_data) {
+        if (fd->inode->_has_data(fd->inode)) {
+          return 0;
+        }
       }
     } else if (EVENT_TYPE_TCP_SOCKET == ev->type) {
       struct TcpConnection *con = tcp_get_connection(ev->internal_id, q->p);
diff --git a/kernel/random.c b/kernel/random.c
index 38924ce..2d77ccd 100644
--- a/kernel/random.c
+++ b/kernel/random.c
@@ -155,8 +155,8 @@ int random_read(BYTEPTR buffer, u64 offset, u64 len, vfs_fd_t *fd) {
 }
 
 void add_random_devices(void) {
-  devfs_add_file("/random", random_read, random_write, NULL, 1, 1,
-                 FS_TYPE_CHAR_DEVICE);
-  devfs_add_file("/urandom", random_read, random_write, NULL, 1, 1,
-                 FS_TYPE_CHAR_DEVICE);
+  devfs_add_file("/random", random_read, random_write, NULL, always_has_data,
+                 always_can_write, FS_TYPE_CHAR_DEVICE);
+  devfs_add_file("/urandom", random_read, random_write, NULL, always_has_data,
+                 always_can_write, FS_TYPE_CHAR_DEVICE);
 }
diff --git a/kernel/sched/scheduler.c b/kernel/sched/scheduler.c
index 9948c72..6454775 100644
--- a/kernel/sched/scheduler.c
+++ b/kernel/sched/scheduler.c
@@ -382,8 +382,10 @@ int isset_fdhalt(process_t *p, int *empty) {
       break;
     }
     *empty = 0;
-    if (inode->has_data) {
-      return 0;
+    if (inode->_has_data) {
+      if (inode->_has_data(inode)) {
+        return 0;
+      }
     }
     blocked = 1;
   }
@@ -393,8 +395,10 @@ int isset_fdhalt(process_t *p, int *empty) {
       break;
     }
     *empty = 0;
-    if (inode->can_write) {
-      return 0;
+    if (inode->_can_write) {
+      if (inode->_can_write(inode)) {
+        return 0;
+      }
     }
     blocked = 1;
   }
@@ -647,8 +651,8 @@ void *mmap(void *addr, size_t length, int prot, int flags, int fd,
   }
   void *rc = create_physical_mapping(vmobject->object, length);
   if (!rc) {
-      kprintf("ENOMEM\n");
-      return (void *)-ENOMEM;
+    kprintf("ENOMEM\n");
+    return (void *)-ENOMEM;
   }
   free_map->u_address = rc;
   free_map->k_address = NULL;
diff --git a/kernel/socket.c b/kernel/socket.c
index d24e39c..53dd71e 100644
--- a/kernel/socket.c
+++ b/kernel/socket.c
@@ -31,7 +31,6 @@ struct TcpConnection *tcp_find_connection(u16 port) {
       if (!list_get(connections, i, (void **)&c)) {
         break;
       }
-      kprintf("got port: %d\n", c->incoming_port);
       if (c->incoming_port == port) {
         return c;
       }
@@ -237,7 +236,6 @@ int uds_open(const char *path) {
 
   char c = 'i';
   fifo_object_write((u8 *)&c, 1, 0, s->fifo_file);
-  s->ptr_socket_fd->inode->has_data = 1;
 
   s->incoming_fd = get_vfs_fd(fd[1], NULL);
   s->incoming_fd->reference_count++;
@@ -253,7 +251,7 @@ int accept(int socket, struct sockaddr *address, socklen_t *address_len) {
   vfs_inode_t *inode = fd_ptr->inode;
   SOCKET *s = (SOCKET *)inode->internal_object;
 
-  if (NULL == s->incoming_fd) {
+  for (; NULL == s->incoming_fd;) {
     // Wait until we have gotten a connection
     struct pollfd fds[1];
     fds[0].fd = socket;
@@ -268,12 +266,21 @@ int accept(int socket, struct sockaddr *address, socklen_t *address_len) {
   s->incoming_fd = NULL;
   //  for (char c; 0 < vfs_pread(s->fifo_fd, &c, 1, 0);)
   //    ;
-  inode->has_data = 0;
   //  s->ptr_fifo_fd->inode->has_data = 0;
 
   return index;
 }
 
+int bind_has_data(vfs_inode_t *inode) {
+  SOCKET *socket = inode->internal_object;
+  return socket->incoming_fd;
+}
+
+int bind_can_write(vfs_inode_t *inode) {
+  (void)inode;
+  return 1;
+}
+
 int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
   (void)addrlen;
   vfs_fd_t *fd = get_vfs_fd(sockfd, NULL);
@@ -305,26 +312,34 @@ int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
     us->path = s->path;
     us->s = s;
     s->child = us;
-    devfs_add_file(us->path, NULL, NULL, NULL, 1, 1, FS_TYPE_UNIX_SOCKET);
+    devfs_add_file(us->path, NULL, NULL, NULL, NULL, bind_can_write,
+                   FS_TYPE_UNIX_SOCKET);
     return 0;
   }
   return 0;
 }
 
+int socket_has_data(vfs_inode_t *inode) {
+  SOCKET *s = (SOCKET *)inode->internal_object;
+  FIFO_FILE *file = s->fifo_file;
+  return file->has_data;
+}
+
+int socket_can_write(vfs_inode_t *inode) {
+  (void)inode;
+  return 1;
+}
+
 int socket_write(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   SOCKET *s = (SOCKET *)fd->inode->internal_object;
   FIFO_FILE *file = s->fifo_file;
-  int rc = fifo_object_write(buffer, 0, len, file);
-  fd->inode->has_data = file->has_data;
-  return rc;
+  return fifo_object_write(buffer, 0, len, file);
 }
 
 int socket_read(u8 *buffer, u64 offset, u64 len, vfs_fd_t *fd) {
   SOCKET *s = (SOCKET *)fd->inode->internal_object;
   FIFO_FILE *file = s->fifo_file;
-  int rc = fifo_object_read(buffer, 0, len, file);
-  fd->inode->has_data = file->has_data;
-  return rc;
+  return fifo_object_read(buffer, 0, len, file);
 }
 
 void socket_close(vfs_fd_t *fd) {
@@ -338,7 +353,7 @@ int socket(int domain, int type, int protocol) {
 
   SOCKET *new_socket = kmalloc(sizeof(SOCKET));
   vfs_inode_t *inode = vfs_create_inode(
-      0 /*inode_num*/, FS_TYPE_UNIX_SOCKET, 0 /*has_data*/, 1 /*can_write*/,
+      0 /*inode_num*/, FS_TYPE_UNIX_SOCKET, bind_has_data, socket_can_write,
       1 /*is_open*/, new_socket /*internal_object*/, 0 /*file_size*/,
       NULL /*open*/, NULL /*create_file*/, socket_read, socket_write,
       socket_close, NULL /*create_directory*/, NULL /*get_vm_object*/,