fix(libkernel): clear select bits from nfds to the end of their word

core/libs/prx/libkernel/Socket/src/Socket.cpp

@@ -51,6 +51,14 @@ void ClearDescriptor(void* set, int descriptor) {
     if (set != nullptr) static_cast<std::uint64_t*>(set)[descriptor / 64] &= ~(std::uint64_t{1} << (descriptor % 64));
 }
 
+void ClearDescriptorsFrom(int nfds, void* readfds, void* writefds, void* exceptfds) {
+    if (nfds % 64 == 0) return;
+    const std::uint64_t kept = (std::uint64_t{1} << (nfds % 64)) - 1;
+    for (void* set : {readfds, writefds, exceptfds}) {
+        if (set != nullptr) static_cast<std::uint64_t*>(set)[nfds / 64] &= kept;
+    }
+}
+
 struct PollGroup {
     KernelSocketPoll::Poller poll;
     std::vector<KernelSocketPoll::Entry> entries;
@@ -311,6 +319,7 @@ int APS5_VABI select_nid_postfix(int nfds, void* readfds, void* writefds, void*
                 if ((entry.revents & (KernelSocketPoll::Writable | KernelSocketPoll::Error)) == 0) ClearDescriptor(writefds, entry.descriptor);
                 if ((entry.revents & KernelSocketPoll::Urgent) == 0) ClearDescriptor(exceptfds, entry.descriptor);
             }
+            ClearDescriptorsFrom(nfds, readfds, writefds, exceptfds);
             return ready;
         }
         if (limit != nullptr && std::chrono::steady_clock::now() >= deadline) {
@@ -319,6 +328,7 @@ int APS5_VABI select_nid_postfix(int nfds, void* readfds, void* writefds, void*
                 ClearDescriptor(writefds, entry.descriptor);
                 ClearDescriptor(exceptfds, entry.descriptor);
             }
+            ClearDescriptorsFrom(nfds, readfds, writefds, exceptfds);
             return 0;
         }
     }

core/libs/tests/GuestSelect.cpp

@@ -185,14 +185,43 @@ int main() {
         Require(read.Has(reader) && write.Has(writer));
     }
 
+    Require(reader < 63);
+
     {
         GuestDescriptorSet read{};
+        GuestDescriptorSet except{};
         read.Add(reader);
+        read.Add(63);
+        read.Add(64);
+        except.Add(63);
         GuestTimeval limit{0, 100000};
-        Require(select_nid_postfix(reader, read.words.data(), nullptr, nullptr, &limit) == 0);
+        Require(select_nid_postfix(reader, read.words.data(), nullptr, except.words.data(), &limit) == 0);
+        Require(!read.Has(reader) && !read.Has(63) && read.Has(64) && !except.Has(63));
+    }
+
+    {
+        GuestDescriptorSet read{};
+        read.Add(reader);
+        const GuestTimeval zero{0, 0};
+        Require(select_nid_postfix(0, read.words.data(), nullptr, nullptr, &zero) == 0);
         Require(read.Has(reader));
     }
 
+    {
+        const char byte = 'n';
+        Require(write_nid_postfix(writer, &byte, 1) == 1);
+        GuestDescriptorSet read{};
+        read.Add(reader);
+        read.Add(63);
+        read.Add(64);
+        GuestTimeval limit{0, 200000};
+        Require(select_nid_postfix(reader + 1, read.words.data(), nullptr, nullptr, &limit) == 1);
+        Require(read.Has(reader) && !read.Has(63) && read.Has(64));
+        char buffer[8]{};
+        const auto count = read_nid_postfix(reader, buffer, sizeof(buffer));
+        Require(count >= 1 && buffer[count - 1] == byte);
+    }
+
     {
         GuestDescriptorSet read{};
         read.Add(reader);

core/libs/tests/GuestSelectWait.cpp

@@ -53,14 +53,17 @@ int main() {
     }
     std::array<std::uint64_t, 16> read{};
     read[0] = 1 | (std::uint64_t{1} << 63);
+    read[1] = 1;
     const GuestTimeval limit{0, 500};
     const auto start = Clock::now();
     Require(select_nid_postfix(1, read.data(), nullptr, nullptr, &limit) == 0,
         "select with no ready device did not time out");
     Require(Clock::now() - start >= std::chrono::microseconds(limit.microseconds),
         "select with no ready device returned before its deadline");
-    Require(read[0] == (std::uint64_t{1} << 63),
-        "select did not preserve bits outside the descriptor limit");
+    Require(read[0] == 0,
+        "select did not clear the bits up to the end of the last copied word");
+    Require(read[1] == 1,
+        "select did not preserve the words past the descriptor limit");
     std::array<std::uint64_t, 16> write{};
     write[0] = 2;
     const GuestTimeval longLimit{1, 0};