nuke extra threads, extra error support; use span instead of vector for poll fds

src/core/hle/service/server_manager.cpp

@@ -245,14 +245,6 @@ Result ServerManager::ManageDeferral(Kernel::KEvent** out_event) {
     R_SUCCEED();
 }
 
-void ServerManager::StartAdditionalHostThreads(const char* name, size_t num_threads) {
-    for (size_t i = 0; i < num_threads; i++) {
-        auto thread_name = fmt::format("{}:{}", name, i + 1);
-        m_threads.emplace_back(m_system.Kernel().RunOnHostCoreThread(
-            std::move(thread_name), [&] { this->LoopProcessImpl(); }));
-    }
-}
-
 Result ServerManager::LoopProcess() {
     SCOPE_EXIT {
         m_stopped.Set();

src/core/hle/service/server_manager.h

@@ -48,7 +48,6 @@ public:
     Result ManageDeferral(Kernel::KEvent** out_event);
 
     Result LoopProcess();
-    void StartAdditionalHostThreads(const char* name, size_t num_threads);
 
     static void RunServer(std::unique_ptr<ServerManager>&& server);
 

src/core/hle/service/sockets/bsd.cpp

@@ -574,8 +574,9 @@ std::pair<s32, Network::Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std:
         return {-1, Network::Errno::INVAL};
     }
 
-    std::vector<Network::PollFD> fds(nfds);
+    std::span<const Network::PollFD> in_fds(reinterpret_cast<const Network::PollFD*>(read_buffer.data()), nfds);
-    std::memcpy(fds.data(), read_buffer.data(), nfds * sizeof(Network::PollFD));
+    std::span<Network::PollFD> out_fds(reinterpret_cast<Network::PollFD*>(write_buffer.data()), nfds);
+    std::copy(in_fds.begin(), in_fds.end(), out_fds.begin());
 
     if (timeout >= 0) {
         const s64 seconds = timeout / 1000;
@@ -590,34 +591,28 @@ std::pair<s32, Network::Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std:
         return {-1, Network::Errno::INVAL};
     }
 
-    bool has_invalid = false;
+    for (size_t i = 0; i < in_fds.size(); ++i) {
-    for (auto& pollfd : fds) {
+        ASSERT(out_fds[i].fd == in_fds[i].fd && False(in_fds[i].revents));
-        ASSERT(False(pollfd.revents));
+        if (!IsFileDescriptorValid(in_fds[i].fd)) {
-        if (!IsFileDescriptorValid(pollfd.fd)) {
+            out_fds[i].revents = {};
-            pollfd.revents = {};
+            if (!file_descriptors[in_fds[i].fd])
-            if (!file_descriptors[pollfd.fd])
+                out_fds[i].revents = Network::PollEvents::NVAL;
-                pollfd.revents = Network::PollEvents::NVAL;
+            return {0, Network::Errno::SUCCESS};
-            has_invalid = true;
         }
     }
-    if (has_invalid) {
-        return {0, Network::Errno::SUCCESS};
-    }
 
-    std::vector<Network::HostPollFD> host_pollfds(fds.size());
+    std::vector<Network::HostPollFD> host_pollfds(in_fds.size());
-    std::transform(fds.begin(), fds.end(), host_pollfds.begin(), [](auto const e) {
+    std::transform(in_fds.begin(), in_fds.end(), host_pollfds.begin(), [](auto const e) {
         Network::HostPollFD result{};
         result.socket = file_descriptors[e.fd]->socket.get();
         result.events = e.events;
-        result.revents = e.revents;
+        result.revents = {};
         return result;
     });
-
+    auto const res = Network::Poll(host_pollfds, timeout);
-    const auto result = Network::Poll(host_pollfds, timeout);
+    for (size_t i = 0; i < in_fds.size(); ++i)
-    for (size_t i = 0; i < host_pollfds.size(); ++i)
+        out_fds[i].revents = host_pollfds[i].revents;
-        fds[i].revents = host_pollfds[i].revents;
+    return res;
-    std::memcpy(write_buffer.data(), fds.data(), nfds * sizeof(Network::PollFD));
-    return result;
 }
 
 std::pair<s32, Network::Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {

src/core/internal_network/network.cpp

@@ -285,7 +285,9 @@ Errno TranslateNativeError(int e, CallType call_type = CallType::Other) {
     NETWORK_ERROR_ELEM(NOTSUP) \
     NETWORK_ERROR_ELEM(ADDRINUSE) \
     NETWORK_ERROR_ELEM(ADDRNOTAVAIL) \
-    NETWORK_ERROR_ELEM(NOTSOCK)
+    NETWORK_ERROR_ELEM(NOTSOCK) \
+    NETWORK_ERROR_ELEM(ALREADY) \
+    NETWORK_ERROR_ELEM(STALE)
 #define NETWORK_ERROR_ELEM(name) case E##name: return Errno::name;
     NETWORK_ERROR_LIST
 #undef NETWORK_ERROR_ELEM
@@ -889,7 +891,6 @@ std::variant<std::vector<AddrInfo>, GetAddrInfoError> GetAddressInfo(const std::
 
 std::pair<s32, Errno> Poll(std::span<HostPollFD> pollfds, s32 timeout) {
     LOG_DEBUG(Network, "pollfds={},timeout={}", pollfds.size(), timeout);
-    const size_t num = pollfds.size();
 
     std::vector<WSAPOLLFD> host_pollfds(pollfds.size());
     std::transform(pollfds.begin(), pollfds.end(), host_pollfds.begin(), [](auto const e) {
@@ -914,16 +915,14 @@ std::pair<s32, Errno> Poll(std::span<HostPollFD> pollfds, s32 timeout) {
         return {0, Errno::SUCCESS};
     }
 
-    for (size_t i = 0; i < num; ++i)
+    for (size_t i = 0; i < pollfds.size(); ++i)
         pollfds[i].revents = TranslatePollRevents(host_pollfds[i].revents);
 
-    if (result > 0) {
+    if (result <= 0) {
-        return {result, Errno::SUCCESS};
+        ASSERT(result == SOCKET_ERROR);
+        return {-1, GetAndLogLastError()};
     }
-
+    return {result, Errno::SUCCESS};
-    ASSERT(result == SOCKET_ERROR);
-
-    return {-1, GetAndLogLastError()};
 }
 
 Socket::~Socket() {

src/core/internal_network/socket_types.h

@@ -43,7 +43,9 @@ enum class Errno : u32 {
     TIMEDOUT = 110,
     CONNREFUSED = 111,
     HOSTUNREACH = 113,
+    ALREADY = 114,
     INPROGRESS = 115,
+    STALE = 116,
     /* made up error? */
     OTHER = 196,
 };