chiark / gitweb /
manager: don't do plymouth in a container
[elogind.git] / src / core / load-dropin.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <dirent.h>
23 #include <errno.h>
24
25 #include "unit.h"
26 #include "load-dropin.h"
27 #include "log.h"
28 #include "strv.h"
29 #include "unit-name.h"
30 #include "conf-parser.h"
31 #include "load-fragment.h"
32 #include "conf-files.h"
33
34 static int iterate_dir(
35                 Unit *u,
36                 const char *path,
37                 UnitDependency dependency,
38                 char ***strv) {
39
40         _cleanup_closedir_ DIR *d = NULL;
41         int r;
42
43         assert(u);
44         assert(path);
45
46         /* The config directories are special, since the order of the
47          * drop-ins matters */
48         if (dependency < 0)  {
49                 r = strv_extend(strv, path);
50                 if (r < 0)
51                         return log_oom();
52
53                 return 0;
54         }
55
56         d = opendir(path);
57         if (!d) {
58                 if (errno == ENOENT)
59                         return 0;
60
61                 return -errno;
62         }
63
64         for (;;) {
65                 struct dirent *de;
66                 union dirent_storage buf;
67                 _cleanup_free_ char *f = NULL;
68                 int k;
69
70                 k = readdir_r(d, &buf.de, &de);
71                 if (k != 0) {
72                         log_error("Failed to read directory %s: %s", path, strerror(k));
73                         return -k;
74                 }
75
76                 if (!de)
77                         break;
78
79                 if (ignore_file(de->d_name))
80                         continue;
81
82                 f = strjoin(path, "/", de->d_name, NULL);
83                 if (!f)
84                         return log_oom();
85
86                 r = unit_add_dependency_by_name(u, dependency, de->d_name, f, true);
87                 if (r < 0)
88                         log_error("Cannot add dependency %s to %s, ignoring: %s", de->d_name, u->id, strerror(-r));
89         }
90
91         return 0;
92 }
93
94 static int process_dir(
95                 Unit *u,
96                 const char *unit_path,
97                 const char *name,
98                 const char *suffix,
99                 UnitDependency dependency,
100                 char ***strv) {
101
102         int r;
103         char *path;
104
105         assert(u);
106         assert(unit_path);
107         assert(name);
108         assert(suffix);
109
110         path = strjoin(unit_path, "/", name, suffix, NULL);
111         if (!path)
112                 return log_oom();
113
114         if (u->manager->unit_path_cache &&
115             !set_get(u->manager->unit_path_cache, path))
116                 r = 0;
117         else
118                 r = iterate_dir(u, path, dependency, strv);
119         free(path);
120
121         if (r < 0)
122                 return r;
123
124         if (u->instance) {
125                 char *template;
126                 /* Also try the template dir */
127
128                 template = unit_name_template(name);
129                 if (!template)
130                         return log_oom();
131
132                 path = strjoin(unit_path, "/", template, suffix, NULL);
133                 free(template);
134
135                 if (!path)
136                         return log_oom();
137
138                 if (u->manager->unit_path_cache &&
139                     !set_get(u->manager->unit_path_cache, path))
140                         r = 0;
141                 else
142                         r = iterate_dir(u, path, dependency, strv);
143                 free(path);
144
145                 if (r < 0)
146                         return r;
147         }
148
149         return 0;
150 }
151
152 char **unit_find_dropin_paths(Unit *u) {
153         _cleanup_strv_free_ char **strv = NULL;
154         char **configs = NULL;
155         Iterator i;
156         char *t;
157         int r;
158
159         assert(u);
160
161         SET_FOREACH(t, u->names, i) {
162                 char **p;
163
164                 STRV_FOREACH(p, u->manager->lookup_paths.unit_path) {
165                         /* This loads the drop-in config snippets */
166                         r = process_dir(u, *p, t, ".d", _UNIT_DEPENDENCY_INVALID, &strv);
167                         if (r < 0)
168                                 return NULL;
169                 }
170         }
171
172         if (strv_isempty(strv))
173                 return NULL;
174
175         r = conf_files_list_strv(&configs, ".conf", NULL, (const char**) strv);
176         if (r < 0) {
177                 log_error("Failed to get list of configuration files: %s", strerror(-r));
178                 strv_free(configs);
179                 return NULL;
180         }
181
182         return configs;
183 }
184
185 int unit_load_dropin(Unit *u) {
186         Iterator i;
187         char *t, **f;
188         int r;
189
190         assert(u);
191
192         /* Load dependencies from supplementary drop-in directories */
193
194         SET_FOREACH(t, u->names, i) {
195                 char **p;
196
197                 STRV_FOREACH(p, u->manager->lookup_paths.unit_path) {
198                         r = process_dir(u, *p, t, ".wants", UNIT_WANTS, NULL);
199                         if (r < 0)
200                                 return r;
201
202                         r = process_dir(u, *p, t, ".requires", UNIT_REQUIRES, NULL);
203                         if (r < 0)
204                                 return r;
205                 }
206         }
207
208         u->dropin_paths = unit_find_dropin_paths(u);
209         if (! u->dropin_paths)
210                 return 0;
211
212         STRV_FOREACH(f, u->dropin_paths) {
213                 r = config_parse(u->id, *f, NULL,
214                                  UNIT_VTABLE(u)->sections, config_item_perf_lookup,
215                                  (void*) load_fragment_gperf_lookup, false, false, u);
216                 if (r < 0)
217                         return r;
218         }
219
220         u->dropin_mtime = now(CLOCK_REALTIME);
221
222         return 0;
223 }