RFC manager: Add deferred parsing of mountinfo

src/core/manager.h

@@ -314,6 +314,7 @@ struct Manager {
         /* Data specific to the mount subsystem */
         struct libmnt_monitor *mount_monitor;
         sd_event_source *mount_event_source;
+        sd_event_source *mount_enumerate_source;
 
         /* Data specific to the swap filesystem */
         FILE *proc_swaps;

src/core/mount.c

@@ -1957,9 +1957,27 @@ static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
         return 0;
 }
 
+static int mount_enumerate_late(sd_event_source *s, void *userdata) {
+        Manager *m = ASSERT_PTR(userdata);
+        int r;
+
+        /* Do not delay manager instance start with long mountinfo parsing */
+        if (!m->ready_sent)
+                return 0;
+
+        r = mount_load_proc_self_mountinfo(m, /* set_flags = */ false);
+        if (r < 0)
+                return log_error_errno(r, "Failed to load mountinfo: %m");
+        r = sd_event_source_set_enabled(s, SD_EVENT_OFF);
+        if (r < 0)
+                return log_error_errno(r, "Failed to disable late event source: %m");
+        return r;
+}
+
 static void mount_shutdown(Manager *m) {
         assert(m);
 
+        m->mount_enumerate_source = sd_event_source_disable_unref(m->mount_enumerate_source);
         m->mount_event_source = sd_event_source_disable_unref(m->mount_event_source);
 
         mnt_unref_monitor(m->mount_monitor);
@@ -2045,7 +2063,9 @@ static void mount_enumerate(Manager *m) {
         mnt_init_debug(0);
 
         if (!m->mount_monitor) {
+                usec_t mount_rate_limit_interval = 1 * USEC_PER_SEC;
                 unsigned mount_rate_limit_burst = 5;
+                const char *e;
                 int fd;
 
                 m->mount_monitor = mnt_new_monitor();
@@ -2086,14 +2106,22 @@ static void mount_enumerate(Manager *m) {
                 }
 
                 /* Let users override the default (5 in 1s), as it stalls the boot sequence on busy systems. */
-                const char *e = secure_getenv("SYSTEMD_DEFAULT_MOUNT_RATE_LIMIT_BURST");
+                e = secure_getenv("SYSTEMD_DEFAULT_MOUNT_RATE_LIMIT_BURST");
                 if (e) {
                         r = safe_atou(e, &mount_rate_limit_burst);
                         if (r < 0)
                                 log_debug("Invalid value in $SYSTEMD_DEFAULT_MOUNT_RATE_LIMIT_BURST, ignoring: %s", e);
                 }
 
-                r = sd_event_source_set_ratelimit(m->mount_event_source, 1 * USEC_PER_SEC, mount_rate_limit_burst);
+                e = secure_getenv("SYSTEMD_DEFAULT_MOUNT_RATE_LIMIT_INTERVAL");
+                if (e) {
+                        r = parse_sec(e, &mount_rate_limit_interval);
+                        if (r < 0)
+                                log_debug("Invalid value in $SYSTEMD_DEFAULT_MOUNT_RATE_LIMIT_INTERVAL, ignoring: %s", e);
+                }
+
+
+                r = sd_event_source_set_ratelimit(m->mount_event_source, mount_rate_limit_interval, mount_rate_limit_burst);
                 if (r < 0) {
                         log_error_errno(r, "Failed to enable rate limit for mount events: %m");
                         goto fail;
@@ -2106,11 +2134,40 @@ static void mount_enumerate(Manager *m) {
                 }
 
                 (void) sd_event_source_set_description(m->mount_event_source, "mount-monitor-dispatch");
+
+                if (!MANAGER_IS_SYSTEM(m)) {
+                        /* Keep parsing of large mountinfos out of the way of user managers. We postpone
+                         * mounts enumeration after the manager is ready (see user_manager_send_ready()).
+                         * An arrival of a mountinfo event during start could trigger full mountinfo parsing
+                         * too. As a secondary measure, apply ratelimit preemptively. If we manage to
+                         * initialize manager under mount_rate_limit_interval, we're gold. If we are not, the
+                         * ratelimit yields and that resolves events that would block the initialization.
+                         * (Additionally, if the initialization naturally takes longer than
+                         * mount_rate_limit_interval, we can spend yet more time on full parsing.) */
+                        r = sd_event_source_enter_ratelimit(m->mount_event_source);
+                        if (r < 0) {
+                                log_debug_errno(r, "Failed to enter rate limit for mount events: %m");
+                        }
+
+                        r = sd_event_add_post(m->event, &m->mount_enumerate_source, mount_enumerate_late, m);
+                        if (r < 0) {
+                                log_error_errno(r, "Failed to add late mount enumerate source: %m");
+                                goto fail;
+                        }
+
+                        r = sd_event_source_set_priority(m->mount_enumerate_source, SD_EVENT_PRIORITY_IDLE);
+                        if (r < 0) {
+                                log_error_errno(r, "Failed to adjust mount enumerate priority: %m");
+                                goto fail;
+                        }
+                }
         }
 
-        r = mount_load_proc_self_mountinfo(m, false);
-        if (r < 0)
-                goto fail;
+        if (MANAGER_IS_SYSTEM(m)) {
+                r = mount_load_proc_self_mountinfo(m, /* set_flags = */ false);
+                if (r < 0)
+                        goto fail;
+        }
 
         return;
 

src/libsystemd/libsystemd.sym

@@ -834,3 +834,8 @@ global:
         sd_id128_get_app_specific;
         sd_device_enumerator_add_match_property_required;
 } LIBSYSTEMD_254;
+
+LIBSYSTEMD_256 {
+global:
+        sd_event_source_enter_ratelimit;
+} LIBSYSTEMD_255;

src/libsystemd/sd-event/sd-event.c

@@ -3343,7 +3343,7 @@ _public_ void *sd_event_source_set_userdata(sd_event_source *s, void *userdata)
         return ret;
 }
 
-static int event_source_enter_ratelimited(sd_event_source *s) {
+static int event_source_enter_ratelimited(sd_event_source *s, bool exceeded) {
         int r;
 
         assert(s);
@@ -3354,6 +3354,10 @@ static int event_source_enter_ratelimited(sd_event_source *s) {
         if (s->ratelimited)
                 return 0; /* Already ratelimited, this is a NOP hence */
 
+        if (!exceeded) {
+                s->rate_limit.begin = now(CLOCK_MONOTONIC);
+        }
+
         /* Make sure we can install a CLOCK_MONOTONIC event further down. */
         r = setup_clock_data(s->event, &s->event->monotonic, CLOCK_MONOTONIC);
         if (r < 0)
@@ -3379,7 +3383,8 @@ static int event_source_enter_ratelimited(sd_event_source *s) {
 
         event_source_pp_prioq_reshuffle(s);
 
-        log_debug("Event source %p (%s) entered rate limit state.", s, strna(s->description));
+        if (exceeded)
+                log_debug("Event source %p (%s) entered rate limit state.", s, strna(s->description));
         return 0;
 
 fail:
@@ -4135,7 +4140,7 @@ static int source_dispatch(sd_event_source *s) {
         /* Check if we hit the ratelimit for this event source, and if so, let's disable it. */
         assert(!s->ratelimited);
         if (!ratelimit_below(&s->rate_limit)) {
-                r = event_source_enter_ratelimited(s);
+                r = event_source_enter_ratelimited(s, /* exceeded = */ true);
                 if (r < 0)
                         return r;
 
@@ -5214,6 +5219,27 @@ _public_ int sd_event_source_leave_ratelimit(sd_event_source *s) {
         return 1; /* tell caller that we indeed just left the ratelimit state */
 }
 
+_public_ int sd_event_source_enter_ratelimit(sd_event_source *s) {
+        int r;
+
+        assert_return(s, -EINVAL);
+
+        if (!EVENT_SOURCE_CAN_RATE_LIMIT(s->type))
+                return -EINVAL;
+
+        if (!ratelimit_configured(&s->rate_limit))
+                return 0;
+
+        if (s->ratelimited)
+                return 0;
+
+        r = event_source_enter_ratelimited(s, /* exceeded = */ false);
+        if (r < 0)
+                return r;
+
+        return 1; /* tell caller that we indeed just entered the ratelimit state */
+}
+
 _public_ int sd_event_set_signal_exit(sd_event *e, int b) {
         bool change = false;
         int r;

src/systemd/sd-event.h

@@ -174,6 +174,7 @@ int sd_event_source_get_ratelimit(sd_event_source *s, uint64_t *ret_interval_use
 int sd_event_source_is_ratelimited(sd_event_source *s);
 int sd_event_source_set_ratelimit_expire_callback(sd_event_source *s, sd_event_handler_t callback);
 int sd_event_source_leave_ratelimit(sd_event_source *s);
+int sd_event_source_enter_ratelimit(sd_event_source *s);
 
 int sd_event_trim_memory(void);