Restore nonblocking Linux UHID registration

Author: ReenigneArcher

docs/platform-support.md

@@ -138,11 +138,12 @@ and control channels. Numbered control-channel output is normalized before
 parsing, whether the kernel includes the report number in the payload or
 provides it separately on the UHID event.
 
-The UHID event reader is active before device registration begins, and gamepad
-creation does not report success until the kernel returns `UHID_START`. This
-keeps control-channel initialization available throughout registration and
-prevents streaming hosts from publishing a controller before its kernel HID
-device has started.
+The backend opens `/dev/uhid` in nonblocking mode, matching the original
+asynchronous gamepad registration path. Its event reader is active before
+device registration begins, and creation does not report success until the
+kernel returns `UHID_START`. This keeps control-channel initialization
+available throughout registration and prevents streaming hosts from publishing
+a controller before its kernel HID device has started.
 
 On Linux, DualShock 4 and DualSense emit Sony's native `Wireless Controller`
 product name for Steam HID discovery. The requested USB or Bluetooth bus,

src/platform/linux/uhid_backend.cpp

@@ -3245,7 +3245,7 @@ namespace lvh::detail {
         }
 
 #if defined(__linux__)
-        const auto fd = system_open(uhid_path, O_RDWR | O_CLOEXEC);
+        const auto fd = system_open(uhid_path, O_RDWR | O_CLOEXEC | O_NONBLOCK);
         if (fd < 0) {
           return {system_error_status(ErrorCode::backend_unavailable, "failed to open /dev/uhid", errno), nullptr};
         }

tests/fixtures/include/fixtures/linux_backend_test_hooks.hpp

@@ -845,6 +845,13 @@ namespace lvh::detail::test {
    */
   OperationStatus linux_backend_gamepad_fake_open_failure();
 
+  /**
+   * @brief Capture the flags used to open UHID for a descriptor-driven gamepad.
+   *
+   * @return Flags passed to `open()` for `/dev/uhid`.
+   */
+  int linux_backend_gamepad_open_flags();
+
   /**
    * @brief Try creating a Linux backend gamepad while fake UHID creation fails.
    *

tests/fixtures/linux_backend_test_hooks.cpp

@@ -120,6 +120,7 @@ namespace lvh::detail::test {
       int access_result = 0;
       bool override_open = false;
       int open_result = 100000;
+      int last_open_flags = 0;
       bool override_write = false;
       std::atomic_int write_call_count = 0;
       int fail_write_call = -1;
@@ -207,6 +208,9 @@ int lvh_linux_test_access(const char *path, int mode) {
 }
 
 int lvh_linux_test_open(const char *path, int flags) {
+  if (lvh::detail::test::active_test_syscalls() != nullptr) {
+    lvh::detail::test::active_test_syscalls()->last_open_flags = flags;
+  }
   if (lvh::detail::test::active_test_syscalls() != nullptr && lvh::detail::test::active_test_syscalls()->override_open) {
     if (lvh::detail::test::active_test_syscalls()->open_result < 0) {
       errno = ENOENT;
@@ -1975,6 +1979,21 @@ namespace lvh::detail::test {
     return backend.create_gamepad(1, options).status;
   }
 
+  int linux_backend_gamepad_open_flags() {
+    LinuxTestSyscalls syscalls;
+    syscalls.override_access = true;
+    syscalls.override_open = true;
+    syscalls.open_result = -1;
+    ScopedLinuxTestSyscalls scoped_syscalls {syscalls};
+
+    LinuxUhidBackend backend;
+
+    CreateGamepadOptions options;
+    options.profile = profiles::dualshock4_usb();
+    static_cast<void>(backend.create_gamepad(1, options));
+    return syscalls.last_open_flags;
+  }
+
   OperationStatus linux_backend_gamepad_fake_create_failure() {
     LinuxTestSyscalls syscalls;
     enable_fake_device_syscalls(syscalls);

tests/unit/test_linux_backend.cpp

@@ -15,6 +15,7 @@
 #include <vector>
 
 // platform includes
+#include <fcntl.h>
 #include <linux/input.h>
 #if defined(LIBVIRTUALHID_HAVE_XTEST)
   #include <X11/keysym.h>
@@ -908,6 +909,13 @@ TEST_F(LinuxBackendTest, FakeLinuxBackendCreatesAllDeviceTypes) {
   EXPECT_TRUE(result.pen_tablet_close_status.ok()) << result.pen_tablet_close_status.message();
 }
 
+TEST_F(LinuxBackendTest, OpensUhidGamepadsNonblocking) {
+  const auto flags = lvh::detail::test::linux_backend_gamepad_open_flags();
+  EXPECT_EQ(flags & O_ACCMODE, O_RDWR);
+  EXPECT_NE(flags & O_CLOEXEC, 0);
+  EXPECT_NE(flags & O_NONBLOCK, 0);
+}
+
 TEST_F(LinuxBackendTest, FakeUhidSyscallsCoverFailureBranches) {
   EXPECT_EQ(lvh::detail::test::linux_uhid_submit_fake_write_failure().code(), lvh::ErrorCode::backend_failure);
   EXPECT_EQ(lvh::detail::test::linux_uhid_submit_fake_short_write().code(), lvh::ErrorCode::backend_failure);