Kernel: Rename Blocker::not_blocking(bool) to something more descriptive

Namely, will_unblock_immediately_without_blocking(Reason).

This virtual function is called on a blocker *before any block occurs*,
if it turns out that we don't need to block the thread after all.

This can happens for one of two reasons:

- UnblockImmediatelyReason::UnblockConditionAlreadyMet

    We don't need to block the thread because the condition for
    unblocking it is already met.

- UnblockImmediatelyReason::TimeoutInThePast

    We don't need to block the thread because a timeout was specified
    and that timeout is already in the past.

This patch does not introduce any behavior changes, it's only meant to
clarify this part of the blocking logic.

Kernel/FileSystem/Plan9FileSystem.cpp

@@ -425,7 +425,7 @@ bool Plan9FS::Blocker::unblock(u16 tag)
     return unblock();
 }
 
-void Plan9FS::Blocker::not_blocking(bool)
+void Plan9FS::Blocker::will_unblock_immediately_without_blocking(UnblockImmediatelyReason)
 {
     {
         SpinlockLocker lock(m_lock);

Kernel/FileSystem/Plan9FileSystem.h

@@ -91,7 +91,7 @@ private:
         }
         virtual StringView state_string() const override { return "Waiting"sv; }
         virtual Type blocker_type() const override { return Type::Plan9FS; }
-        virtual void not_blocking(bool) override;
+        virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) override;
 
         const NonnullRefPtr<ReceiveCompletion>& completion() const { return m_completion; }
         u16 tag() const { return m_completion->tag; }

Kernel/Net/Routing.cpp

@@ -26,7 +26,7 @@ public:
     virtual Type blocker_type() const override { return Type::Routing; }
     virtual bool should_block() override { return m_should_block; }
 
-    virtual void not_blocking(bool) override;
+    virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) override;
 
     bool unblock(bool from_add_blocker, const IPv4Address& ip_addr, const MACAddress& addr)
     {
@@ -90,9 +90,9 @@ ARPTableBlocker::ARPTableBlocker(IPv4Address ip_addr, Optional<MACAddress>& addr
         m_should_block = false;
 }
 
-void ARPTableBlocker::not_blocking(bool timeout_in_past)
+void ARPTableBlocker::will_unblock_immediately_without_blocking(UnblockImmediatelyReason reason)
 {
-    VERIFY(timeout_in_past || !m_should_block);
+    VERIFY(reason == UnblockImmediatelyReason::TimeoutInThePast || !m_should_block);
     auto addr = arp_table().with_shared([&](const auto& table) -> auto {
         return table.get(ip_addr());
     });

Kernel/Thread.h

@@ -300,7 +300,14 @@ public:
         virtual Type blocker_type() const = 0;
         virtual const BlockTimeout& override_timeout(const BlockTimeout& timeout) { return timeout; }
         virtual bool can_be_interrupted() const { return true; }
-        virtual void not_blocking(bool) = 0;
+
+        enum class UnblockImmediatelyReason {
+            UnblockConditionAlreadyMet,
+            TimeoutInThePast,
+        };
+
+        virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) = 0;
+
         virtual void was_unblocked(bool did_timeout)
         {
             if (did_timeout) {
@@ -515,7 +522,7 @@ public:
         virtual StringView state_string() const override { return "Joining"sv; }
         virtual bool can_be_interrupted() const override { return false; }
         virtual bool should_block() override { return !m_join_error && m_should_block; }
-        virtual void not_blocking(bool) override;
+        virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) override;
 
         bool unblock(void*, bool);
 
@@ -534,7 +541,7 @@ public:
 
         virtual Type blocker_type() const override { return Type::Queue; }
         virtual StringView state_string() const override { return m_block_reason.is_null() ? m_block_reason : "Queue"sv; }
-        virtual void not_blocking(bool) override { }
+        virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) override { }
 
         virtual bool should_block() override
         {
@@ -556,7 +563,7 @@ public:
 
         virtual Type blocker_type() const override { return Type::Futex; }
         virtual StringView state_string() const override { return "Futex"sv; }
-        virtual void not_blocking(bool) override { }
+        virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) override { }
 
         virtual bool should_block() override
         {
@@ -620,7 +627,7 @@ public:
         const FileDescription& blocked_description() const;
 
         virtual bool unblock(bool, void*) override;
-        virtual void not_blocking(bool) override;
+        virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) override;
 
     protected:
         explicit FileDescriptionBlocker(FileDescription&, BlockFlags, BlockFlags&);
@@ -670,7 +677,7 @@ public:
         virtual StringView state_string() const override { return "Sleeping"sv; }
         virtual Type blocker_type() const override { return Type::Sleep; }
         virtual const BlockTimeout& override_timeout(const BlockTimeout&) override;
-        virtual void not_blocking(bool) override;
+        virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) override;
         virtual void was_unblocked(bool) override;
         virtual Thread::BlockResult block_result() override;
 
@@ -694,7 +701,7 @@ public:
         virtual ~SelectBlocker();
 
         virtual bool unblock(bool, void*) override;
-        virtual void not_blocking(bool) override;
+        virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) override;
         virtual void was_unblocked(bool) override;
         virtual StringView state_string() const override { return "Selecting"sv; }
 
@@ -718,7 +725,7 @@ public:
         virtual StringView state_string() const override { return "Waiting"sv; }
         virtual Type blocker_type() const override { return Type::Wait; }
         virtual bool should_block() override { return m_should_block; }
-        virtual void not_blocking(bool) override;
+        virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) override;
         virtual void was_unblocked(bool) override;
 
         bool unblock(Process& process, UnblockFlags flags, u8 signal, bool from_add_blocker);
@@ -881,7 +888,7 @@ public:
             m_blocker = &blocker;
             if (!blocker.should_block()) {
                 // Don't block if the wake condition is already met
-                blocker.not_blocking(false);
+                blocker.will_unblock_immediately_without_blocking(Blocker::UnblockImmediatelyReason::UnblockConditionAlreadyMet);
                 m_blocker = nullptr;
                 m_in_block = false;
                 return BlockResult::NotBlocked;
@@ -903,7 +910,7 @@ public:
                 });
                 if (!timer_was_added) {
                     // Timeout is already in the past
-                    blocker.not_blocking(true);
+                    blocker.will_unblock_immediately_without_blocking(Blocker::UnblockImmediatelyReason::TimeoutInThePast);
                     m_blocker = nullptr;
                     m_in_block = false;
                     return BlockResult::InterruptedByTimeout;

Kernel/ThreadBlockers.cpp

@@ -87,18 +87,17 @@ Thread::JoinBlocker::JoinBlocker(Thread& joinee, KResult& try_join_result, void*
     }
 }
 
-void Thread::JoinBlocker::not_blocking(bool timeout_in_past)
+void Thread::JoinBlocker::will_unblock_immediately_without_blocking(UnblockImmediatelyReason reason)
 {
     if (!m_should_block) {
-        // add_to_blocker_set returned false, so unblock was already called
-        VERIFY(!timeout_in_past);
+        VERIFY(reason == UnblockImmediatelyReason::UnblockConditionAlreadyMet);
         return;
     }
     // If we should have blocked but got here it must have been that the
     // timeout was already in the past. So we need to ask the BlockerSet
     // to supply us the information. We cannot hold the lock as unblock
     // could be called by the BlockerSet at any time!
-    VERIFY(timeout_in_past);
+    VERIFY(reason == UnblockImmediatelyReason::TimeoutInThePast);
     m_joinee->m_join_blocker_set.try_unblock(*this);
 }
 
@@ -217,18 +216,17 @@ bool Thread::FileDescriptionBlocker::unblock(bool from_add_blocker, void*)
     return true;
 }
 
-void Thread::FileDescriptionBlocker::not_blocking(bool timeout_in_past)
+void Thread::FileDescriptionBlocker::will_unblock_immediately_without_blocking(UnblockImmediatelyReason reason)
 {
     if (!m_should_block) {
-        // add_to_blocker_set returned false, so unblock was already called
-        VERIFY(!timeout_in_past);
+        VERIFY(reason == UnblockImmediatelyReason::UnblockConditionAlreadyMet);
         return;
     }
     // If we should have blocked but got here it must have been that the
     // timeout was already in the past. So we need to ask the BlockerSet
     // to supply us the information. We cannot hold the lock as unblock
     // could be called by the BlockerSet at any time!
-    VERIFY(timeout_in_past);
+    VERIFY(reason == UnblockImmediatelyReason::TimeoutInThePast);
 
     // Just call unblock here because we will query the file description
     // for the data and don't need any input from the FileBlockerSet.
@@ -307,11 +305,11 @@ auto Thread::SleepBlocker::override_timeout(const BlockTimeout& timeout) -> cons
     return m_deadline;
 }
 
-void Thread::SleepBlocker::not_blocking(bool timeout_in_past)
+void Thread::SleepBlocker::will_unblock_immediately_without_blocking(UnblockImmediatelyReason reason)
 {
     // SleepBlocker::should_block should always return true, so timeout
     // in the past is the only valid case when this function is called
-    VERIFY(timeout_in_past);
+    VERIFY(reason == UnblockImmediatelyReason::TimeoutInThePast);
     calculate_remaining();
 }
 
@@ -360,14 +358,14 @@ Thread::SelectBlocker::~SelectBlocker()
         fd_entry.description->blocker_set().remove_blocker(*this, &fd_entry);
 }
 
-void Thread::SelectBlocker::not_blocking(bool timeout_in_past)
+void Thread::SelectBlocker::will_unblock_immediately_without_blocking(UnblockImmediatelyReason reason)
 {
     // Either the timeout was in the past or we didn't add all blockers
-    VERIFY(timeout_in_past || !m_should_block);
+    VERIFY(reason == UnblockImmediatelyReason::TimeoutInThePast || !m_should_block);
     SpinlockLocker lock(m_lock);
     if (!m_should_block || !m_did_unblock) {
         m_did_unblock = true;
-        if (!timeout_in_past) {
+        if (reason == UnblockImmediatelyReason::UnblockConditionAlreadyMet) {
             auto count = collect_unblocked_flags();
             VERIFY(count > 0);
         }
@@ -626,9 +624,9 @@ Thread::WaitBlocker::WaitBlocker(int wait_options, idtype_t id_type, pid_t id, K
         m_should_block = false;
 }
 
-void Thread::WaitBlocker::not_blocking(bool timeout_in_past)
+void Thread::WaitBlocker::will_unblock_immediately_without_blocking(UnblockImmediatelyReason reason)
 {
-    VERIFY(timeout_in_past || !m_should_block);
+    VERIFY(reason == UnblockImmediatelyReason::TimeoutInThePast || !m_should_block);
     if (!m_error)
         Process::current().wait_blocker_set().try_unblock(*this);
 }