From a2632eca864670f7a88e1a81947a9e726282e531 Mon Sep 17 00:00:00 2001

From: =?UTF-8?q?Zbigniew=20J=C4=99drzejewski-Szmek?= <zbyszek@in.waw.pl>

Date: Wed, 2 Mar 2022 17:17:39 +0100

Subject: [PATCH] shared/install: consistently use 'lp' as the name for the

 LookupPaths instance

Most of the codebase does this. Here we were using 'p' or 'paths'

instead. Those names are very generic and not good for a "global-like"

object like the LookupPaths instance. And we also have 'path' variable,

and it's confusing to have 'path' and 'paths' in the same function that

are unrelated.

Also pass down LookupPaths* lower in the call stack, in preparation for

future changes.

(cherry picked from commit c3e7fba07c19f232f5945c07e7cc730986615adf)

Related: #2082131

---

 src/shared/install.c | 427 +++++++++++++++++++++----------------------

 1 file changed, 212 insertions(+), 215 deletions(-)

diff --git a/src/shared/install.c b/src/shared/install.c

index 8f1af755fa..c6cbe96fdb 100644

--- a/src/shared/install.c

+++ b/src/shared/install.c

@@ -98,7 +98,7 @@ static const char *const unit_file_type_table[_UNIT_FILE_TYPE_MAX] = {

 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(unit_file_type, UnitFileType);

-static int in_search_path(const LookupPaths *p, const char *path) {

+static int in_search_path(const LookupPaths *lp, const char *path) {

         _cleanup_free_ char *parent = NULL;

         assert(path);

@@ -107,19 +107,16 @@ static int in_search_path(const LookupPaths *p, const char *path) {

         if (!parent)

                 return -ENOMEM;

-        return path_strv_contains(p->search_path, parent);

+        return path_strv_contains(lp->search_path, parent);

 }

-static const char* skip_root(const LookupPaths *p, const char *path) {

-        char *e;

-

-        assert(p);

+static const char* skip_root(const char *root_dir, const char *path) {

         assert(path);

-        if (!p->root_dir)

+        if (!root_dir)

                 return path;

-        e = path_startswith(path, p->root_dir);

+        const char *e = path_startswith(path, root_dir);

         if (!e)

                 return NULL;

@@ -134,52 +131,52 @@ static const char* skip_root(const LookupPaths *p, const char *path) {

         return e;

 }

-static int path_is_generator(const LookupPaths *p, const char *path) {

+static int path_is_generator(const LookupPaths *lp, const char *path) {

         _cleanup_free_ char *parent = NULL;

-        assert(p);

+        assert(lp);

         assert(path);

         parent = dirname_malloc(path);

         if (!parent)

                 return -ENOMEM;

-        return path_equal_ptr(parent, p->generator) ||

-               path_equal_ptr(parent, p->generator_early) ||

-               path_equal_ptr(parent, p->generator_late);

+        return path_equal_ptr(parent, lp->generator) ||

+               path_equal_ptr(parent, lp->generator_early) ||

+               path_equal_ptr(parent, lp->generator_late);

 }

-static int path_is_transient(const LookupPaths *p, const char *path) {

+static int path_is_transient(const LookupPaths *lp, const char *path) {

         _cleanup_free_ char *parent = NULL;

-        assert(p);

+        assert(lp);

         assert(path);

         parent = dirname_malloc(path);

         if (!parent)

                 return -ENOMEM;

-        return path_equal_ptr(parent, p->transient);

+        return path_equal_ptr(parent, lp->transient);

 }

-static int path_is_control(const LookupPaths *p, const char *path) {

+static int path_is_control(const LookupPaths *lp, const char *path) {

         _cleanup_free_ char *parent = NULL;

-        assert(p);

+        assert(lp);

         assert(path);

         parent = dirname_malloc(path);

         if (!parent)

                 return -ENOMEM;

-        return path_equal_ptr(parent, p->persistent_control) ||

-               path_equal_ptr(parent, p->runtime_control);

+        return path_equal_ptr(parent, lp->persistent_control) ||

+               path_equal_ptr(parent, lp->runtime_control);

 }

-static int path_is_config(const LookupPaths *p, const char *path, bool check_parent) {

+static int path_is_config(const LookupPaths *lp, const char *path, bool check_parent) {

         _cleanup_free_ char *parent = NULL;

-        assert(p);

+        assert(lp);

         assert(path);

         /* Note that we do *not* have generic checks for /etc or /run in place, since with

@@ -193,21 +190,21 @@ static int path_is_config(const LookupPaths *p, const char *path, bool check_par

                 path = parent;

         }

-        return path_equal_ptr(path, p->persistent_config) ||

-               path_equal_ptr(path, p->runtime_config);

+        return path_equal_ptr(path, lp->persistent_config) ||

+               path_equal_ptr(path, lp->runtime_config);

 }

-static int path_is_runtime(const LookupPaths *p, const char *path, bool check_parent) {

+static int path_is_runtime(const LookupPaths *lp, const char *path, bool check_parent) {

         _cleanup_free_ char *parent = NULL;

         const char *rpath;

-        assert(p);

+        assert(lp);

         assert(path);

         /* Everything in /run is considered runtime. On top of that we also add

          * explicit checks for the various runtime directories, as safety net. */

-        rpath = skip_root(p, path);

+        rpath = skip_root(lp->root_dir, path);

         if (rpath && path_startswith(rpath, "/run"))

                 return true;

@@ -219,21 +216,21 @@ static int path_is_runtime(const LookupPaths *p, const char *path, bool check_pa

                 path = parent;

         }

-        return path_equal_ptr(path, p->runtime_config) ||

-               path_equal_ptr(path, p->generator) ||

-               path_equal_ptr(path, p->generator_early) ||

-               path_equal_ptr(path, p->generator_late) ||

-               path_equal_ptr(path, p->transient) ||

-               path_equal_ptr(path, p->runtime_control);

+        return path_equal_ptr(path, lp->runtime_config) ||

+               path_equal_ptr(path, lp->generator) ||

+               path_equal_ptr(path, lp->generator_early) ||

+               path_equal_ptr(path, lp->generator_late) ||

+               path_equal_ptr(path, lp->transient) ||

+               path_equal_ptr(path, lp->runtime_control);

 }

-static int path_is_vendor_or_generator(const LookupPaths *p, const char *path) {

+static int path_is_vendor_or_generator(const LookupPaths *lp, const char *path) {

         const char *rpath;

-        assert(p);

+        assert(lp);

         assert(path);

-        rpath = skip_root(p, path);

+        rpath = skip_root(lp->root_dir, path);

         if (!rpath)

                 return 0;

@@ -245,19 +242,19 @@ static int path_is_vendor_or_generator(const LookupPaths *p, const char *path) {

                 return true;

 #endif

-        if (path_is_generator(p, rpath))

+        if (path_is_generator(lp, rpath))

                 return true;

         return path_equal(rpath, SYSTEM_DATA_UNIT_DIR);

 }

-static const char* config_path_from_flags(const LookupPaths *paths, UnitFileFlags flags) {

-        assert(paths);

+static const char* config_path_from_flags(const LookupPaths *lp, UnitFileFlags flags) {

+        assert(lp);

         if (FLAGS_SET(flags, UNIT_FILE_PORTABLE))

-                return FLAGS_SET(flags, UNIT_FILE_RUNTIME) ? paths->runtime_attached : paths->persistent_attached;

+                return FLAGS_SET(flags, UNIT_FILE_RUNTIME) ? lp->runtime_attached : lp->persistent_attached;

         else

-                return FLAGS_SET(flags, UNIT_FILE_RUNTIME) ? paths->runtime_config : paths->persistent_config;

+                return FLAGS_SET(flags, UNIT_FILE_RUNTIME) ? lp->runtime_config : lp->persistent_config;

 }

 int unit_file_changes_add(

@@ -435,7 +432,7 @@ static bool chroot_symlinks_same(const char *root, const char *wd, const char *a

 }

 static int create_symlink(

-                const LookupPaths *paths,

+                const LookupPaths *lp,

                 const char *old_path,

                 const char *new_path,

                 bool force,

@@ -449,7 +446,7 @@ static int create_symlink(

         assert(old_path);

         assert(new_path);

-        rp = skip_root(paths, old_path);

+        rp = skip_root(lp->root_dir, old_path);

         if (rp)

                 old_path = rp;

@@ -487,7 +484,7 @@ static int create_symlink(

         if (!dirname)

                 return -ENOMEM;

-        if (chroot_symlinks_same(paths->root_dir, dirname, dest, old_path)) {

+        if (chroot_symlinks_same(lp->root_dir, dirname, dest, old_path)) {

                 log_debug("Symlink %s → %s already exists", new_path, dest);

                 return 1;

         }

@@ -642,7 +639,7 @@ static int remove_marked_symlinks_fd(

                         /* Now, remember the full path (but with the root prefix removed) of

                          * the symlink we just removed, and remove any symlinks to it, too. */

-                        rp = skip_root(lp, p);

+                        rp = skip_root(lp->root_dir, p);

                         q = mark_symlink_for_removal(&remove_symlinks_to, rp ?: p);

                         if (q < 0)

                                 return q;

@@ -861,7 +858,7 @@ static int find_symlinks(

 static int find_symlinks_in_scope(

                 UnitFileScope scope,

-                const LookupPaths *paths,

+                const LookupPaths *lp,

                 const UnitFileInstallInfo *i,

                 bool match_name,

                 UnitFileState *state) {

@@ -872,23 +869,23 @@ static int find_symlinks_in_scope(

         char **p;

         int r;

-        assert(paths);

+        assert(lp);

         assert(i);

-        /* As we iterate over the list of search paths in paths->search_path, we may encounter "same name"

+        /* As we iterate over the list of search paths in lp->search_path, we may encounter "same name"

          * symlinks. The ones which are "below" (i.e. have lower priority) than the unit file itself are

          * effectively masked, so we should ignore them. */

-        STRV_FOREACH(p, paths->search_path)  {

+        STRV_FOREACH(p, lp->search_path)  {

                 bool same_name_link = false;

-                r = find_symlinks(paths->root_dir, i, match_name, ignore_same_name, *p, &same_name_link);

+                r = find_symlinks(lp->root_dir, i, match_name, ignore_same_name, *p, &same_name_link);

                 if (r < 0)

                         return r;

                 if (r > 0) {

                         /* We found symlinks in this dir? Yay! Let's see where precisely it is enabled. */

-                        if (path_equal_ptr(*p, paths->persistent_config)) {

+                        if (path_equal_ptr(*p, lp->persistent_config)) {

                                 /* This is the best outcome, let's return it immediately. */

                                 *state = UNIT_FILE_ENABLED;

                                 return 1;

@@ -900,7 +897,7 @@ static int find_symlinks_in_scope(

                                 return 1;

                         }

-                        r = path_is_runtime(paths, *p, false);

+                        r = path_is_runtime(lp, *p, false);

                         if (r < 0)

                                 return r;

                         if (r > 0)

@@ -909,10 +906,10 @@ static int find_symlinks_in_scope(

                                 enabled_at_all = true;

                 } else if (same_name_link) {

-                        if (path_equal_ptr(*p, paths->persistent_config))

+                        if (path_equal_ptr(*p, lp->persistent_config))

                                 same_name_link_config = true;

                         else {

-                                r = path_is_runtime(paths, *p, false);

+                                r = path_is_runtime(lp, *p, false);

                                 if (r < 0)

                                         return r;

                                 if (r > 0)

@@ -990,11 +987,11 @@ static UnitFileInstallInfo *install_info_find(InstallContext *c, const char *nam

 static int install_info_may_process(

                 const UnitFileInstallInfo *i,

-                const LookupPaths *paths,

+                const LookupPaths *lp,

                 UnitFileChange **changes,

                 size_t *n_changes) {

         assert(i);

-        assert(paths);

+        assert(lp);

         /* Checks whether the loaded unit file is one we should process, or is masked,

          * transient or generated and thus not subject to enable/disable operations. */

@@ -1003,8 +1000,8 @@ static int install_info_may_process(

                 unit_file_changes_add(changes, n_changes, -ERFKILL, i->path, NULL);

                 return -ERFKILL;

         }

-        if (path_is_generator(paths, i->path) ||

-            path_is_transient(paths, i->path)) {

+        if (path_is_generator(lp, i->path) ||

+            path_is_transient(lp, i->path)) {

                 unit_file_changes_add(changes, n_changes, -EADDRNOTAVAIL, i->path, NULL);

                 return -EADDRNOTAVAIL;

         }

@@ -1339,20 +1336,20 @@ static int unit_file_load_or_readlink(

                 InstallContext *c,

                 UnitFileInstallInfo *info,

                 const char *path,

-                const char *root_dir,

+                const LookupPaths *lp,

                 SearchFlags flags) {

         _cleanup_free_ char *resolved = NULL;

         int r;

-        r = unit_file_load(c, info, path, root_dir, flags);

+        r = unit_file_load(c, info, path, lp->root_dir, flags);

         if (r != -ELOOP || (flags & SEARCH_DROPIN))

                 return r;

-        r = chase_symlinks(path, root_dir, CHASE_WARN | CHASE_NONEXISTENT, &resolved, NULL);

+        r = chase_symlinks(path, lp->root_dir, CHASE_WARN | CHASE_NONEXISTENT, &resolved, NULL);

         if (r >= 0 &&

-            root_dir &&

-            path_equal_ptr(path_startswith(resolved, root_dir), "dev/null"))

+            lp->root_dir &&

+            path_equal_ptr(path_startswith(resolved, lp->root_dir), "dev/null"))

                 /* When looking under root_dir, we can't expect /dev/ to be mounted,

                  * so let's see if the path is a (possibly dangling) symlink to /dev/null. */

                 info->type = UNIT_FILE_TYPE_MASKED;

@@ -1402,7 +1399,7 @@ static int unit_file_load_or_readlink(

                 if (path_is_absolute(target))

                         /* This is an absolute path, prefix the root so that we always deal with fully qualified paths */

-                        info->symlink_target = path_join(root_dir, target);

+                        info->symlink_target = path_join(lp->root_dir, target);

                 else

                         /* This is a relative path, take it relative to the dir the symlink is located in. */

                         info->symlink_target = file_in_same_dir(path, target);

@@ -1418,7 +1415,7 @@ static int unit_file_load_or_readlink(

 static int unit_file_search(

                 InstallContext *c,

                 UnitFileInstallInfo *info,

-                const LookupPaths *paths,

+                const LookupPaths *lp,

                 SearchFlags flags) {

         const char *dropin_dir_name = NULL, *dropin_template_dir_name = NULL;

@@ -1429,14 +1426,14 @@ static int unit_file_search(

         char **p;

         assert(info);

-        assert(paths);

+        assert(lp);

         /* Was this unit already loaded? */

         if (info->type != _UNIT_FILE_TYPE_INVALID)

                 return 0;

         if (info->path)

-                return unit_file_load_or_readlink(c, info, info->path, paths->root_dir, flags);

+                return unit_file_load_or_readlink(c, info, info->path, lp, flags);

         assert(info->name);

@@ -1446,14 +1443,14 @@ static int unit_file_search(

                         return r;

         }

-        STRV_FOREACH(p, paths->search_path) {

+        STRV_FOREACH(p, lp->search_path) {

                 _cleanup_free_ char *path = NULL;

                 path = path_join(*p, info->name);

                 if (!path)

                         return -ENOMEM;

-                r = unit_file_load_or_readlink(c, info, path, paths->root_dir, flags);

+                r = unit_file_load_or_readlink(c, info, path, lp, flags);

                 if (r >= 0) {

                         info->path = TAKE_PTR(path);

                         result = r;

@@ -1469,14 +1466,14 @@ static int unit_file_search(

                  * enablement was requested.  We will check if it is

                  * possible to load template unit file. */

-                STRV_FOREACH(p, paths->search_path) {

+                STRV_FOREACH(p, lp->search_path) {

                         _cleanup_free_ char *path = NULL;

                         path = path_join(*p, template);

                         if (!path)

                                 return -ENOMEM;

-                        r = unit_file_load_or_readlink(c, info, path, paths->root_dir, flags);

+                        r = unit_file_load_or_readlink(c, info, path, lp, flags);

                         if (r >= 0) {

                                 info->path = TAKE_PTR(path);

                                 result = r;

@@ -1498,7 +1495,7 @@ static int unit_file_search(

         /* Search for drop-in directories */

         dropin_dir_name = strjoina(info->name, ".d");

-        STRV_FOREACH(p, paths->search_path) {

+        STRV_FOREACH(p, lp->search_path) {

                 char *path;

                 path = path_join(*p, dropin_dir_name);

@@ -1512,7 +1509,7 @@ static int unit_file_search(

         if (template) {

                 dropin_template_dir_name = strjoina(template, ".d");

-                STRV_FOREACH(p, paths->search_path) {

+                STRV_FOREACH(p, lp->search_path) {

                         char *path;

                         path = path_join(*p, dropin_template_dir_name);

@@ -1532,7 +1529,7 @@ static int unit_file_search(

                 return log_debug_errno(r, "Failed to get list of conf files: %m");

         STRV_FOREACH(p, files) {

-                r = unit_file_load_or_readlink(c, info, *p, paths->root_dir, flags | SEARCH_DROPIN);

+                r = unit_file_load_or_readlink(c, info, *p, lp, flags | SEARCH_DROPIN);

                 if (r < 0)

                         return log_debug_errno(r, "Failed to load conf file %s: %m", *p);

         }

@@ -1543,7 +1540,7 @@ static int unit_file_search(

 static int install_info_follow(

                 InstallContext *c,

                 UnitFileInstallInfo *i,

-                const char *root_dir,

+                const LookupPaths *lp,

                 SearchFlags flags,

                 bool ignore_different_name) {

@@ -1564,7 +1561,7 @@ static int install_info_follow(

         free_and_replace(i->path, i->symlink_target);

         i->type = _UNIT_FILE_TYPE_INVALID;

-        return unit_file_load_or_readlink(c, i, i->path, root_dir, flags);

+        return unit_file_load_or_readlink(c, i, i->path, lp, flags);

 }

 /**

@@ -1574,7 +1571,7 @@ static int install_info_follow(

 static int install_info_traverse(

                 UnitFileScope scope,

                 InstallContext *c,

-                const LookupPaths *paths,

+                const LookupPaths *lp,

                 UnitFileInstallInfo *start,

                 SearchFlags flags,

                 UnitFileInstallInfo **ret) {

@@ -1583,11 +1580,11 @@ static int install_info_traverse(

         unsigned k = 0;

         int r;

-        assert(paths);

+        assert(lp);

         assert(start);

         assert(c);

-        r = unit_file_search(c, start, paths, flags);

+        r = unit_file_search(c, start, lp, flags);

         if (r < 0)

                 return r;

@@ -1599,14 +1596,14 @@ static int install_info_traverse(

                         return -ELOOP;

                 if (!(flags & SEARCH_FOLLOW_CONFIG_SYMLINKS)) {

-                        r = path_is_config(paths, i->path, true);

+                        r = path_is_config(lp, i->path, true);

                         if (r < 0)

                                 return r;

                         if (r > 0)

                                 return -ELOOP;

                 }

-                r = install_info_follow(c, i, paths->root_dir, flags, false);

+                r = install_info_follow(c, i, lp, flags, false);

                 if (r == -EXDEV) {

                         _cleanup_free_ char *buffer = NULL;

                         const char *bn;

@@ -1635,7 +1632,7 @@ static int install_info_traverse(

                                         /* We filled in the instance, and the target stayed the same? If so, then let's

                                          * honour the link as it is. */

-                                        r = install_info_follow(c, i, paths->root_dir, flags, true);

+                                        r = install_info_follow(c, i, lp, flags, true);

                                         if (r < 0)

                                                 return r;

@@ -1645,12 +1642,12 @@ static int install_info_traverse(

                                 bn = buffer;

                         }

-                        r = install_info_add(c, bn, NULL, paths->root_dir, /* auxiliary= */ false, &i);

+                        r = install_info_add(c, bn, NULL, lp->root_dir, /* auxiliary= */ false, &i);

                         if (r < 0)

                                 return r;

                         /* Try again, with the new target we found. */

-                        r = unit_file_search(c, i, paths, flags);

+                        r = unit_file_search(c, i, lp, flags);

                         if (r == -ENOENT)

                                 /* Translate error code to highlight this specific case */

                                 return -ENOLINK;

@@ -1672,7 +1669,7 @@ static int install_info_traverse(

  */

 static int install_info_add_auto(

                 InstallContext *c,

-                const LookupPaths *paths,

+                const LookupPaths *lp,

                 const char *name_or_path,

                 UnitFileInstallInfo **ret) {

@@ -1682,17 +1679,17 @@ static int install_info_add_auto(

         if (path_is_absolute(name_or_path)) {

                 const char *pp;

-                pp = prefix_roota(paths->root_dir, name_or_path);

+                pp = prefix_roota(lp->root_dir, name_or_path);

-                return install_info_add(c, NULL, pp, paths->root_dir, /* auxiliary= */ false, ret);

+                return install_info_add(c, NULL, pp, lp->root_dir, /* auxiliary= */ false, ret);

         } else

-                return install_info_add(c, name_or_path, NULL, paths->root_dir, /* auxiliary= */ false, ret);

+                return install_info_add(c, name_or_path, NULL, lp->root_dir, /* auxiliary= */ false, ret);

 }

 static int install_info_discover(

                 UnitFileScope scope,

                 InstallContext *c,

-                const LookupPaths *paths,

+                const LookupPaths *lp,

                 const char *name,

                 SearchFlags flags,

                 UnitFileInstallInfo **ret,

@@ -1703,12 +1700,12 @@ static int install_info_discover(

         int r;

         assert(c);

-        assert(paths);

+        assert(lp);

         assert(name);

-        r = install_info_add_auto(c, paths, name, &i);

+        r = install_info_add_auto(c, lp, name, &i);

         if (r >= 0)

-                r = install_info_traverse(scope, c, paths, i, flags, ret);

+                r = install_info_traverse(scope, c, lp, i, flags, ret);

         if (r < 0)

                 unit_file_changes_add(changes, n_changes, r, name, NULL);

@@ -1718,7 +1715,7 @@ static int install_info_discover(

 static int install_info_discover_and_check(

                         UnitFileScope scope,

                         InstallContext *c,

-                        const LookupPaths *paths,

+                        const LookupPaths *lp,

                         const char *name,

                         SearchFlags flags,

                         UnitFileInstallInfo **ret,

@@ -1727,11 +1724,11 @@ static int install_info_discover_and_check(

         int r;

-        r = install_info_discover(scope, c, paths, name, flags, ret, changes, n_changes);

+        r = install_info_discover(scope, c, lp, name, flags, ret, changes, n_changes);

         if (r < 0)

                 return r;

-        return install_info_may_process(ret ? *ret : NULL, paths, changes, n_changes);

+        return install_info_may_process(ret ? *ret : NULL, lp, changes, n_changes);

 }

 int unit_file_verify_alias(const UnitFileInstallInfo *i, const char *dst, char **ret_dst) {

@@ -1812,7 +1809,7 @@ int unit_file_verify_alias(const UnitFileInstallInfo *i, const char *dst, char *

 static int install_info_symlink_alias(

                 UnitFileInstallInfo *i,

-                const LookupPaths *paths,

+                const LookupPaths *lp,

                 const char *config_path,

                 bool force,

                 UnitFileChange **changes,

@@ -1822,7 +1819,7 @@ static int install_info_symlink_alias(

         int r = 0, q;

         assert(i);

-        assert(paths);

+        assert(lp);

         assert(config_path);

         STRV_FOREACH(s, i->aliases) {

@@ -1840,7 +1837,7 @@ static int install_info_symlink_alias(

                 if (!alias_path)

                         return -ENOMEM;

-                q = create_symlink(paths, i->path, alias_path, force, changes, n_changes);

+                q = create_symlink(lp, i->path, alias_path, force, changes, n_changes);

                 if (r == 0)

                         r = q;

         }

@@ -1852,7 +1849,7 @@ static int install_info_symlink_wants(

                 UnitFileScope scope,

                 UnitFileFlags file_flags,

                 UnitFileInstallInfo *i,

-                const LookupPaths *paths,

+                const LookupPaths *lp,

                 const char *config_path,

                 char **list,

                 const char *suffix,

@@ -1866,7 +1863,7 @@ static int install_info_symlink_wants(

         int r = 0, q;

         assert(i);

-        assert(paths);

+        assert(lp);

         assert(config_path);

         if (strv_isempty(list))

@@ -1889,7 +1886,7 @@ static int install_info_symlink_wants(

                         return r;

                 instance.name = buf;

-                r = unit_file_search(NULL, &instance, paths, SEARCH_FOLLOW_CONFIG_SYMLINKS);

+                r = unit_file_search(NULL, &instance, lp, SEARCH_FOLLOW_CONFIG_SYMLINKS);

                 if (r < 0)

                         return r;

@@ -1943,11 +1940,11 @@ static int install_info_symlink_wants(

                 if (!path)

                         return -ENOMEM;

-                q = create_symlink(paths, i->path, path, true, changes, n_changes);

+                q = create_symlink(lp, i->path, path, true, changes, n_changes);

                 if (r == 0)

                         r = q;

-                if (unit_file_exists(scope, paths, dst) == 0)

+                if (unit_file_exists(scope, lp, dst) == 0)

                         unit_file_changes_add(changes, n_changes, UNIT_FILE_DESTINATION_NOT_PRESENT, dst, i->path);

         }

@@ -1956,7 +1953,7 @@ static int install_info_symlink_wants(

 static int install_info_symlink_link(

                 UnitFileInstallInfo *i,

-                const LookupPaths *paths,

+                const LookupPaths *lp,

                 const char *config_path,

                 bool force,

                 UnitFileChange **changes,

@@ -1966,11 +1963,11 @@ static int install_info_symlink_link(

         int r;

         assert(i);

-        assert(paths);

+        assert(lp);

         assert(config_path);

         assert(i->path);

-        r = in_search_path(paths, i->path);

+        r = in_search_path(lp, i->path);

         if (r < 0)

                 return r;

         if (r > 0)

@@ -1980,14 +1977,14 @@ static int install_info_symlink_link(

         if (!path)

                 return -ENOMEM;

-        return create_symlink(paths, i->path, path, force, changes, n_changes);

+        return create_symlink(lp, i->path, path, force, changes, n_changes);

 }

 static int install_info_apply(

                 UnitFileScope scope,

                 UnitFileFlags file_flags,

                 UnitFileInstallInfo *i,

-                const LookupPaths *paths,

+                const LookupPaths *lp,

                 const char *config_path,

                 UnitFileChange **changes,

                 size_t *n_changes) {

@@ -1995,7 +1992,7 @@ static int install_info_apply(

         int r, q;

         assert(i);

-        assert(paths);

+        assert(lp);

         assert(config_path);