🐛fix epoll fd management

🐛fix compiler error on some platforms

src/components/MayhemServer.cpp

@@ -105,37 +105,49 @@ void MayhemServer::_Serve()
                 // There may be multiple incoming connections.
                 while (AcceptSocket(_listenFd, &data))
                 {
+                    if (data.SocketFd >= MAX_FD)
+                    {
+                        _logger->Error("Unable to handle more connections");
+                        network::CloseSocket(data.SocketFd);
+                        break;
+                    }
+
                     if (!_MonitorFd(data.SocketFd))
                     {
                         _logger->Error("Failed to monitor new connection");
                         network::CloseSocket(data.SocketFd);
                     }
+
                     _handles[data.SocketFd] = CreateRef<AsyncHttpContextBuilder>(data);
                 }
             }
             else if (events[i].events & EPOLLIN)
             {
-                auto& handle = _handles[events[i].data.fd];
+                int fd = events[i].data.fd;
+
+                auto& handle = _handles[fd];
                 MINET_ASSERT(handle);
 
                 int r = handle->Parse();
                 if (r == 1)
                 {
+                    _UnmonitorFd(fd); // prevent from triggering again
+
                     const Ref<HttpContext>& context = handle->GetContext();
                     _DecorateContext(context);
                     if (!_threadPool.Submit([this, context] { _onConnectionCallback(context); }))
                     {
                         _logger->Warn("Server overwhelmed, new connection refused");
-                        network::CloseSocket(data.SocketFd);
-                        _handles[events[i].data.fd].reset();
+                        network::CloseSocket(fd);
+                        _handles[fd].reset();
                     }
                 }
                 else if (r < 0)
                 {
                     // error occurred
                     _logger->Error("Failed to create HTTP context: {}", r);
-                    network::CloseSocket(data.SocketFd);
-                    _handles[events[i].data.fd].reset();
+                    network::CloseSocket(fd);
+                    _handles[fd].reset();
                     continue;
                 }
                 // else, continue parsing
@@ -226,7 +238,16 @@ bool MayhemServer::_MonitorFd(int fd)
         _logger->Error("Failed to add fd to epoll");
         return false;
     }
-    _logger->Debug("New connection {} monitored", fd);
+    return true;
+}
+
+bool MayhemServer::_UnmonitorFd(int fd)
+{
+    if (epoll::Unmonitor(_epollFd, fd) != 0)
+    {
+        _logger->Error("Failed to remove fd from epoll");
+        return false;
+    }
     return true;
 }
 

src/components/MayhemServer.h

@@ -52,6 +52,7 @@ class MayhemServer final : public IServer
     void _OpenEpoll();
     void _CloseEpoll();
     bool _MonitorFd(int fd);
+    bool _UnmonitorFd(int fd);
 
 private:
     /**

src/threading/Queue.h

@@ -20,7 +20,9 @@ namespace threading
 {
 
 // It is better to align critical data to avoid false sharing.
-#if defined(__cpp_lib_hardware_interference_size)
+// Some compiler may throw error for std::hardware_destructive_interference_size,
+// so we use 64 as the default value.
+#if defined(__cpp_lib_hardware_interference_size) && 0
 static constexpr size_t HARDWARE_INTERFERENCE_SIZE = std::hardware_destructive_interference_size;
 #else
 static constexpr size_t HARDWARE_INTERFERENCE_SIZE = 64;

src/utils/Epoll.cpp

@@ -37,6 +37,11 @@ int Monitor(int epfd, int fd, uint32_t events, void* data)
     return epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event);
 }
 
+int Unmonitor(int epfd, int fd)
+{
+    return epoll_ctl(epfd, EPOLL_CTL_DEL, fd, nullptr);
+}
+
 int Modify(int epfd, int fd, uint32_t events, void* data)
 {
     epoll_event event;

src/utils/Epoll.h

@@ -41,6 +41,14 @@ int Monitor(int epfd, int fd, uint32_t events);
  */
 int Monitor(int epfd, int fd, uint32_t events, void* data);
 
+/**
+ * @brief Remove a monitored fd from epoll.
+ * @param epfd Epoll fd.
+ * @param fd The fd to unmonitor.
+ * @return 0 on success, -1 on failure.
+ */
+int Unmonitor(int epfd, int fd);
+
 /**
  * @brief Modify a monitored epoll event.
  * @param epfd Epoll fd.