uevent-sender: Retry udev_device_new_from_syspath() on failure

Fix a race condition in uevent_sender_send() where
udev_device_new_from_syspath() transiently fails with ENOENT, even
though the device directory exists in the mocked /sys filesystem.

This caused a test flake:

> t_mt_uevent: assertion failed (_data1_->change_count == _data1_->num_changes): (9 == 10)

t_mt_uevent test creates a testbed with a device at /sys/devices/dev1,
then spawns a thread that rapidly sends uevent notifications for that
device by calling tb.uevent(). Each call to tb.uevent() creates a new
UeventSender object, which internally creates a new libudev context via
udev_new(), and then calls udev_device_new_from_syspath() to read the
device information from the mocked /sys filesystem.

The race occurs when multiple threads are simultaneously accessing paths
under the mocked /sys through the umockdev preload library:

1. Thread A (emitter): Calls tb.uevent() → uevent_sender_send() →
   udev_device_new_from_syspath(sender->udev, "/sys/devices/dev1")

2. Thread B (main loop or noise): Simultaneously accessing /sys paths
   (e.g., reading device attributes, binding sockets)

3. The preload library uses TRAP_PATH_LOCK (a pthread mutex) to
   serialize access to trap_path() for all intercepted filesystem
   operations under /sys, /dev, and /proc.

4. When libudev's udev_device_new_from_syspath() tries to enumerate the
   device, it performs multiple filesystem operations (stat, readdir,
   readlink, etc.) on /sys/devices/dev1 and its subdirectories.

5. If another thread holds TRAP_PATH_LOCK during a critical part of
   libudev's device enumeration, or if libudev's internal caching/state
   is inconsistent due to concurrent access, udev_device_new_from_syspath()
   returns NULL with errno=ENOENT.

6. Importantly, the failure is **transient** - an immediate retry
   succeeds because the device directory hasn't actually disappeared; it
   was just temporarily inaccessible or libudev's state was inconsistent.

This is a pragmatic workaround rather than a proper fix.

Author: martinpitt

src/uevent_sender.c

@@ -247,8 +247,15 @@ uevent_sender_send(uevent_sender * sender, const char *devpath, const char *acti
 
     device = udev_device_new_from_syspath(sender->udev, devpath);
     if (device == NULL) {
-	fprintf(stderr, "ERROR: uevent_sender_send: No such device %s\n", devpath);
-	return;
+        fprintf(stderr, "ERROR: uevent_sender_send: Failed udev_device_new_from_syspath(%s): %m\n", devpath);
+        /* HACK: there's a race condition where libudev might not see the device immediately when multiple
+         * threads are accessing /sys, due to TRAP_PATH_LOCK contention. Retry once. */
+        usleep(100);
+        device = udev_device_new_from_syspath(sender->udev, devpath);
+        if (device == NULL) {
+            fprintf(stderr, "ERROR: uevent_sender_send: Failed udev_device_new_from_syspath(%s) after retry: %m\n", devpath);
+            return;
+        }
     }
 
     subsystem = udev_device_get_subsystem(device);

tests/test-umockdev-vala.vala

@@ -1008,7 +1008,7 @@ t_mt_uevent ()
   var ml = new MainLoop ();
   uint add_count = 0;
   uint change_count = 0;
-  uint num_changes = 10;
+  uint num_changes = 100;
 
   gudev.uevent.connect((client, action, device) => {
       if (action == "add")

tests/test-umockdev.c

@@ -811,7 +811,7 @@ t_testbed_uevent_error(UMockdevTestbedFixture * fixture, UNUSED_DATA)
     fflush(stderr);
     rewind(stderr);
     g_assert(fgets(buf, sizeof(buf), stderr) != NULL);
-    g_assert_cmpstr(buf, ==, "ERROR: uevent_sender_send: No such device /devices/unknown\n");
+    g_assert_cmpstr(buf, ==, "ERROR: uevent_sender_send: Failed udev_device_new_from_syspath(/devices/unknown): Invalid argument\n");
     fclose(stderr);
     stderr = orig_stderr;
 #endif