From: Zbigniew Jędrzejewski-Szmek Date: Fri, 28 Aug 2020 08:32:39 +0000 (+0200) Subject: core: rename manager_unit_file_maybe_loadable_from_cache() X-Git-Tag: v247-rc1~324^2~3 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=81be23886d3d2099784890f35379fee119b351a8;p=thirdparty%2Fsystemd.git 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. --- diff --git a/src/core/manager.c b/src/core/manager.c index 49bf5419d8e..20ec7ba874e 100644 --- a/src/core/manager.c +++ b/src/core/manager.c @@ -1947,18 +1947,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); } @@ -2008,10 +2014,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 d507dc1f3b4..760fa917055 100644 --- a/src/core/manager.h +++ b/src/core/manager.h @@ -464,7 +464,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 958243bc94b..0fa419787ef 100644 --- 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 e81ef2fd9c9..0124451c78a 100644 --- a/src/core/unit.c +++ b/src/core/unit.c @@ -1671,8 +1671,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 : @@ -1680,7 +1680,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);