Implement a basic way for read() to block.

FileHandle gets a hasDataAvailableForRead() getter.
If this returns true in sys$read(), the task will block(BlockedRead) + yield.
The fd blocked on is stored in Task::m_fdBlockedOnRead.
The scheduler then looks at the state of that fd during the unblock phase.

This makes "sh" restful. :^)

There's still some problem with the kernel not surviving the colonel task
getting scheduled. I need to figure that out and fix it.

VirtualFileSystem/CharacterDevice.h

@@ -7,6 +7,8 @@ class CharacterDevice {
 public:
     virtual ~CharacterDevice();
 
+    virtual bool hasDataAvailableForRead() const = 0;
+
     virtual Unix::ssize_t read(byte* buffer, Unix::size_t bufferSize) = 0;
     virtual Unix::ssize_t write(const byte* buffer, Unix::size_t bufferSize) = 0;
 

VirtualFileSystem/FileHandle.cpp

@@ -107,6 +107,13 @@ Unix::ssize_t FileHandle::read(byte* buffer, Unix::size_t count)
     return nread;
 }
 
+bool FileHandle::hasDataAvailableForRead()
+{
+    if (m_vnode->isCharacterDevice())
+        return m_vnode->characterDevice()->hasDataAvailableForRead();
+    return true;
+}
+
 ByteBuffer FileHandle::readEntireFile()
 {
     Locker locker(VirtualFileSystem::lock());

VirtualFileSystem/FileHandle.h

@@ -12,6 +12,8 @@ public:
     Unix::ssize_t read(byte* buffer, Unix::size_t count);
     int stat(Unix::stat*);
 
+    bool hasDataAvailableForRead();
+
     ssize_t get_dir_entries(byte* buffer, Unix::size_t);
 
     ByteBuffer readEntireFile();
@@ -21,6 +23,9 @@ public:
 #ifdef SERENITY
     int fd() const { return m_fd; }
     void setFD(int fd) { m_fd = fd; }
+
+    bool isBlocking() const { return m_isBlocking; }
+    void setBlocking(bool b) { m_isBlocking = b; }
 #endif
 
 private:
@@ -32,6 +37,7 @@ private:
 
 #ifdef SERENITY
     int m_fd { -1 };
+    bool m_isBlocking { true };
 #endif
 };
 

VirtualFileSystem/FullDevice.cpp

@@ -12,6 +12,11 @@ FullDevice::~FullDevice()
 {
 }
 
+bool FullDevice::hasDataAvailableForRead() const
+{
+    return true;
+}
+
 Unix::ssize_t FullDevice::read(byte* buffer, Unix::size_t bufferSize)
 {
     kprintf("FullDevice: read from full\n");

VirtualFileSystem/FullDevice.h

@@ -7,7 +7,8 @@ public:
     FullDevice();
     virtual ~FullDevice();
 
-    Unix::ssize_t read(byte* buffer, Unix::size_t bufferSize) override;
-    Unix::ssize_t write(const byte* buffer, Unix::size_t bufferSize) override;
+    virtual Unix::ssize_t read(byte* buffer, Unix::size_t bufferSize) override;
+    virtual Unix::ssize_t write(const byte* buffer, Unix::size_t bufferSize) override;
+    virtual bool hasDataAvailableForRead() const override;
 };
 

VirtualFileSystem/NullDevice.cpp

@@ -11,6 +11,11 @@ NullDevice::~NullDevice()
 {
 }
 
+bool NullDevice::hasDataAvailableForRead() const
+{
+    return true;
+}
+
 Unix::ssize_t NullDevice::read(byte*, Unix::size_t)
 {
     kprintf("NullDevice: read from null\n");

VirtualFileSystem/NullDevice.h

@@ -5,9 +5,10 @@
 class NullDevice final : public CharacterDevice {
 public:
     NullDevice();
-    virtual ~NullDevice();
+    virtual ~NullDevice() override;
 
-    Unix::ssize_t read(byte* buffer, Unix::size_t bufferSize) override;
-    Unix::ssize_t write(const byte* buffer, Unix::size_t bufferSize) override;
+    virtual Unix::ssize_t read(byte* buffer, Unix::size_t bufferSize) override;
+    virtual Unix::ssize_t write(const byte* buffer, Unix::size_t bufferSize) override;
+    virtual bool hasDataAvailableForRead() const override;
 };
 

VirtualFileSystem/RandomDevice.cpp

@@ -28,6 +28,11 @@ static void mysrand(unsigned seed)
 }
 #endif
 
+bool RandomDevice::hasDataAvailableForRead() const
+{
+    return true;
+}
+
 Unix::ssize_t RandomDevice::read(byte* buffer, Unix::size_t bufferSize)
 {
     const int range = 'z' - 'a';

VirtualFileSystem/RandomDevice.h

@@ -5,9 +5,10 @@
 class RandomDevice final : public CharacterDevice {
 public:
     RandomDevice();
-    virtual ~RandomDevice();
+    virtual ~RandomDevice() override;
 
-    Unix::ssize_t read(byte* buffer, Unix::size_t bufferSize) override;
-    Unix::ssize_t write(const byte* buffer, Unix::size_t bufferSize) override;
+    virtual Unix::ssize_t read(byte* buffer, Unix::size_t bufferSize) override;
+    virtual Unix::ssize_t write(const byte* buffer, Unix::size_t bufferSize) override;
+    virtual bool hasDataAvailableForRead() const override;
 };
 

VirtualFileSystem/ZeroDevice.cpp

@@ -11,6 +11,11 @@ ZeroDevice::~ZeroDevice()
 {
 }
 
+bool ZeroDevice::hasDataAvailableForRead() const
+{
+    return true;
+}
+
 Unix::ssize_t ZeroDevice::read(byte* buffer, Unix::size_t bufferSize)
 {
     kprintf("ZeroDevice: read from zero\n");

VirtualFileSystem/ZeroDevice.h

@@ -5,9 +5,10 @@
 class ZeroDevice final : public CharacterDevice {
 public:
     ZeroDevice();
-    virtual ~ZeroDevice();
+    virtual ~ZeroDevice() override;
 
-    Unix::ssize_t read(byte* buffer, Unix::size_t bufferSize) override;
-    Unix::ssize_t write(const byte* buffer, Unix::size_t bufferSize) override;
+    virtual Unix::ssize_t read(byte* buffer, Unix::size_t bufferSize) override;
+    virtual Unix::ssize_t write(const byte* buffer, Unix::size_t bufferSize) override;
+    virtual bool hasDataAvailableForRead() const override;
 };