core: rename manager_unit_file_maybe_loadable_from_cache()

The name is misleading, since we aren't really loading the unit from cache — if
this function returns true, we'll try to load the unit from disk, updating the
cache in the process.

(cherry picked from commit 81be23886d3d2099784890f35379fee119b351a8)

diff --git a/src/core/manager.c b/src/core/manager.c
index 41e0d73736627cd70bcfd165019416da349f0740..01eb31e1299415b03a57577d4ee288fb401621bb 100644 (file)
--- a/src/core/manager.c
+++ b/src/core/manager.c
@@ -1937,18 +1937,24 @@ unsigned manager_dispatch_load_queue(Manager *m) {
         return n;
 }
 
-bool manager_unit_file_maybe_loadable_from_cache(Unit *u) {
+bool manager_unit_cache_should_retry_load(Unit *u) {
         assert(u);
 
+        /* Automatic reloading from disk only applies to units which were not found sometime in the past, and
+         * the not-found stub is kept pinned in the unit graph by dependencies. For units that were
+         * previously loaded, we don't do automatic reloading, and daemon-reload is necessary to update. */
         if (u->load_state != UNIT_NOT_FOUND)
                 return false;
 
         if (u->manager->unit_cache_mtime == 0)
                 return false;
 
+        /* The cache has been updated since the last time we tried to load the unit. There might be new
+         * fragment paths to read. */
         if (u->manager->unit_cache_mtime > u->fragment_loadtime)
                 return true;
 
+        /* The cache needs to be updated because there are modifications on disk. */
         return !lookup_paths_mtime_good(&u->manager->lookup_paths, u->manager->unit_cache_mtime);
 }
 
@@ -1998,10 +2004,10 @@ int manager_load_unit_prepare(
                  * first if anything in the usual paths was modified since the last time
                  * the cache was loaded. Also check if the last time an attempt to load the
                  * unit was made was before the most recent cache refresh, so that we know
-                 * we need to try again - even if the cache is current, it might have been
+                 * we need to try again — even if the cache is current, it might have been
                  * updated in a different context before we had a chance to retry loading
                  * this particular unit. */
-                if (manager_unit_file_maybe_loadable_from_cache(ret))
+                if (manager_unit_cache_should_retry_load(ret))
                         ret->load_state = UNIT_STUB;
                 else {
                         *_ret = ret;

diff --git a/src/core/manager.h b/src/core/manager.h
index 81b0c13a955a7bcbbb56cc655ce74eaf24215e0f..d15c05c9635aaafb008e01e5a95e109609280778 100644 (file)
--- a/src/core/manager.h
+++ b/src/core/manager.h
@@ -463,7 +463,7 @@ Unit *manager_get_unit(Manager *m, const char *name);
 
 int manager_get_job_from_dbus_path(Manager *m, const char *s, Job **_j);
 
-bool manager_unit_file_maybe_loadable_from_cache(Unit *u);
+bool manager_unit_cache_should_retry_load(Unit *u);
 int manager_load_unit_prepare(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **_ret);
 int manager_load_unit(Manager *m, const char *name, const char *path, sd_bus_error *e, Unit **_ret);
 int manager_load_startable_unit_or_warn(Manager *m, const char *name, const char *path, Unit **ret);

diff --git a/src/core/transaction.c b/src/core/transaction.c
index 958243bc94b14747869c9d7805c6cfc5a8db2cba..0fa419787ef90acd5032e29611098287ae64f478 100644 (file)
--- a/src/core/transaction.c
+++ b/src/core/transaction.c
@@ -960,12 +960,13 @@ int transaction_add_job_and_dependencies(
                  * first if anything in the usual paths was modified since the last time
                  * the cache was loaded. Also check if the last time an attempt to load the
                  * unit was made was before the most recent cache refresh, so that we know
-                 * we need to try again - even if the cache is current, it might have been
+                 * we need to try again — even if the cache is current, it might have been
                  * updated in a different context before we had a chance to retry loading
                  * this particular unit.
+                 *
                  * Given building up the transaction is a synchronous operation, attempt
                  * to load the unit immediately. */
-                if (r < 0 && manager_unit_file_maybe_loadable_from_cache(unit)) {
+                if (r < 0 && manager_unit_cache_should_retry_load(unit)) {
                         sd_bus_error_free(e);
                         unit->load_state = UNIT_STUB;
                         r = unit_load(unit);

diff --git a/src/core/unit.c b/src/core/unit.c
index 2c09def06f3b228450cea414b582287422175fe5..d5968f36f8b6ff14a805f55a44e30b4e07c37697 100644 (file)
--- a/src/core/unit.c
+++ b/src/core/unit.c
@@ -1674,8 +1674,8 @@ int unit_load(Unit *u) {
         return 0;
 
 fail:
-        /* We convert ENOEXEC errors to the UNIT_BAD_SETTING load state here. Configuration parsing code should hence
-         * return ENOEXEC to ensure units are placed in this state after loading */
+        /* We convert ENOEXEC errors to the UNIT_BAD_SETTING load state here. Configuration parsing code
+         * should hence return ENOEXEC to ensure units are placed in this state after loading. */
 
         u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND :
                                      r == -ENOEXEC ? UNIT_BAD_SETTING :
@@ -1683,7 +1683,7 @@ fail:
         u->load_error = r;
 
         /* Record the last time we tried to load the unit, so that if the cache gets updated between now
-         * and the next time an attempt is made to load this unit, we know we need to check again */
+         * and the next time an attempt is made to load this unit, we know we need to check again. */
         if (u->load_state == UNIT_NOT_FOUND)
                 u->fragment_loadtime = now(CLOCK_REALTIME);