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.

Kernel/Console.cpp

@@ -21,6 +21,11 @@ Console::~Console()
 {
 }
 
+bool Console::hasDataAvailableForRead() const
+{
+    return false;
+}
+
 ssize_t Console::read(byte* buffer, size_t bufferSize)
 {
     // FIXME: Implement reading from the console.

Kernel/Console.h

@@ -9,6 +9,7 @@ public:
     Console();
     virtual ~Console() override;
 
+    virtual bool hasDataAvailableForRead() const override;
     virtual ssize_t read(byte* buffer, size_t size) override;
     virtual ssize_t write(const byte* data, size_t size) override;
 

Kernel/Keyboard.cpp

@@ -86,6 +86,11 @@ Keyboard::~Keyboard()
     ASSERT_NOT_REACHED();
 }
 
+bool Keyboard::hasDataAvailableForRead() const
+{
+    return !m_queue.isEmpty();
+}
+
 ssize_t Keyboard::read(byte* buffer, size_t size)
 {
     ssize_t nread = 0;

Kernel/Keyboard.h

@@ -18,6 +18,7 @@ private:
     // ^CharacterDevice
     virtual ssize_t read(byte* buffer, size_t) override;
     virtual ssize_t write(const byte* buffer, size_t) override;
+    virtual bool hasDataAvailableForRead() const override;
 
     CircularQueue<byte, 16> m_queue;
     byte m_modifiers { 0 };

Kernel/Task.cpp

@@ -466,6 +466,14 @@ bool scheduleNewTask()
                 continue;
             }
         }
+
+        if (task->state() == Task::BlockedRead) {
+            ASSERT(task->m_fdBlockedOnRead != -1);
+            if (task->m_fileHandles[task->m_fdBlockedOnRead]->hasDataAvailableForRead()) {
+                task->unblock();
+                continue;
+            }
+        }
     }
 
 #if 0
@@ -619,6 +627,13 @@ ssize_t Task::sys$read(int fd, void* outbuf, size_t nread)
 #ifdef DEBUG_IO
     kprintf("call read on handle=%p\n", handle);
 #endif
+    if (handle->isBlocking()) {
+        if (!handle->hasDataAvailableForRead()) {
+            m_fdBlockedOnRead = fd;
+            block(BlockedRead);
+            yield();
+        }
+    }
     nread = handle->read((byte*)outbuf, nread);
 #ifdef DEBUG_IO
     kprintf("Task::sys$read: nread=%u\n", nread);

Kernel/Task.h

@@ -31,11 +31,12 @@ public:
         Invalid = 0,
         Runnable = 1,
         Running = 2,
-        BlockedSleep = 3,
-        BlockedWait = 4,
-        Terminated = 5,
-        Crashing = 6,
-        Exiting = 7,
+        Terminated = 3,
+        Crashing = 4,
+        Exiting = 5,
+        BlockedSleep = 6,
+        BlockedWait = 7,
+        BlockedRead = 8,
     };
 
     enum RingLevel {
@@ -114,6 +115,7 @@ public:
 
 private:
     friend class MemoryManager;
+    friend bool scheduleNewTask();
 
     Task(String&& name, uid_t, gid_t, pid_t parentPID, RingLevel);
 
@@ -143,6 +145,7 @@ private:
     void* m_kernelStack { nullptr };
     dword m_timesScheduled { 0 };
     pid_t m_waitee { -1 };
+    int m_fdBlockedOnRead { -1 };
 
     String m_cwd;
 

Kernel/init.cpp

@@ -165,7 +165,7 @@ static void init_stage2()
 #endif
 
     for (;;) {
-        sleep(3600 * TICKS_PER_SECOND);
+        //sleep(3600 * TICKS_PER_SECOND);
         asm("hlt");
     }
 }