udevd: wait for workers to finish when exiting

On some systems with lots of devices, device probing for certain drivers can
take a very long time. If systemd-udevd detects a timeout and kills the worker
running modprobe using SIGKILL, some devices will not be probed, or end up in
unusable state. The --event-timeout option can be used to modify the maximum
time spent in an uevent handler. But if systemd-udevd exits, it uses a
different timeout, hard-coded to 30s, and exits when this timeout expires,
causing all workers to be KILLed by systemd afterwards. In practice, this may
lead to workers being killed after significantly less time than specified with
the event-timeout. This is particularly significant during initrd processing:
systemd-udevd will be stopped by systemd when initrd-switch-root.target is
about to be isolated, which usually happens quickly after finding and mounting
the root FS.

If systemd-udevd is started by PID 1 (i.e. basically always), systemd will
kill both udevd and the workers after expiry of TimeoutStopSec. This is
actually better than the built-in udevd timeout, because it's more transparent
and configurable for users. This way users can avoid the mentioned boot problem
by simply increasing StopTimeoutSec= in systemd-udevd.service.

If udevd is not started by systemd (standalone), this is still an
improvement. udevd will kill hanging workers when the event timeout is
reached, which is configurable via the udev.event_timeout= kernel
command line parameter. Before this patch, udevd would simply exit with
workers still running, which would then become zombie processes.

With the timeout removed, the sd_event_now() assertion in manager_exit() can be
dropped.

diff --git a/NEWS b/NEWS
index 56d05ac7efc131d75e51b7b07f5d555416f78932..15a5ceb051197d4c7810d62ffabc67aee2c2b7be 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -2,6 +2,17 @@ systemd System and Service Manager
 
 CHANGES WITH 244 in spe:
 
+        * systemd-udevd: removed the 30s timeout for killing stale workers on
+          exit. systemd-udevd now waits for workers to finish. The hard-coded
+          exit timeout of 30s was too short for some large installations, where
+          driver initialization could be prematurely interrupted during initrd
+          processing if the root file system had been mounted and init was
+          preparing to switch root. If udevd is run without systemd and workers
+          are hanging while udevd receives an exit signal, udevd will now exit
+          when udev.event_timeout is reached for the last hanging worker. With
+          systemd, the exit timeout can additionally be configured using
+          TimeoutStopSec= in systemd-udevd.service.
+
         * Support for the cpuset cgroups v2 controller has been added.
           Processes may be restricted to specific CPUs using the new
           AllowedCPUs= setting, and to specific memory NUMA nodes using the new

diff --git a/src/udev/udevd.c b/src/udev/udevd.c
index 0ae61c1e8b396775b300184ced0151e611756d4c..144a20ec63fbcf2db2e14844e6df4f6994f4ead5 100644 (file)
--- a/src/udev/udevd.c
+++ b/src/udev/udevd.c
@@ -774,21 +774,7 @@ set_delaying_seqnum:
         return true;
 }
 
-static int on_exit_timeout(sd_event_source *s, uint64_t usec, void *userdata) {
-        Manager *manager = userdata;
-
-        assert(manager);
-
-        log_error("Giving up waiting for workers to finish.");
-        sd_event_exit(manager->event, -ETIMEDOUT);
-
-        return 1;
-}
-
 static void manager_exit(Manager *manager) {
-        uint64_t usec;
-        int r;
-
         assert(manager);
 
         manager->exit = true;
@@ -808,13 +794,6 @@ static void manager_exit(Manager *manager) {
         /* discard queued events and kill workers */
         event_queue_cleanup(manager, EVENT_QUEUED);
         manager_kill_workers(manager);
-
-        assert_se(sd_event_now(manager->event, CLOCK_MONOTONIC, &usec) >= 0);
-
-        r = sd_event_add_time(manager->event, NULL, CLOCK_MONOTONIC,
-                              usec + 30 * USEC_PER_SEC, USEC_PER_SEC, on_exit_timeout, manager);
-        if (r < 0)
-                return;
 }
 
 /* reload requested, HUP signal received, rules changed, builtin changed */