chiark / gitweb /
kill: always send SIGCONT after SIGTERM
[elogind.git] / src / cgroup.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 General Public License as published by
10   the Free Software Foundation; either version 2 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   General Public License for more details.
17
18   You should have received a copy of the GNU General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <assert.h>
24 #include <unistd.h>
25 #include <sys/types.h>
26 #include <signal.h>
27 #include <sys/mount.h>
28 #include <fcntl.h>
29
30 #include "cgroup.h"
31 #include "cgroup-util.h"
32 #include "log.h"
33
34 int cgroup_bonding_realize(CGroupBonding *b) {
35         int r;
36
37         assert(b);
38         assert(b->path);
39         assert(b->controller);
40
41         if (b->realized)
42                 return 0;
43
44         if ((r = cg_create(b->controller, b->path)) < 0)
45                 return r;
46
47         b->realized = true;
48
49         if (b->ours)
50                 cg_trim(b->controller, b->path, false);
51
52         return 0;
53 }
54
55 int cgroup_bonding_realize_list(CGroupBonding *first) {
56         CGroupBonding *b;
57         int r;
58
59         LIST_FOREACH(by_unit, b, first)
60                 if ((r = cgroup_bonding_realize(b)) < 0 && b->essential)
61                         return r;
62
63         return 0;
64 }
65
66 void cgroup_bonding_free(CGroupBonding *b) {
67         assert(b);
68
69         if (b->unit) {
70                 CGroupBonding *f;
71
72                 LIST_REMOVE(CGroupBonding, by_unit, b->unit->meta.cgroup_bondings, b);
73
74                 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
75                         assert_se(f = hashmap_get(b->unit->meta.manager->cgroup_bondings, b->path));
76                         LIST_REMOVE(CGroupBonding, by_path, f, b);
77
78                         if (f)
79                                 hashmap_replace(b->unit->meta.manager->cgroup_bondings, b->path, f);
80                         else
81                                 hashmap_remove(b->unit->meta.manager->cgroup_bondings, b->path);
82                 }
83         }
84
85         if (b->realized && b->ours) {
86
87                 if (cgroup_bonding_is_empty(b) > 0)
88                         cg_delete(b->controller, b->path);
89                 else
90                         cg_trim(b->controller, b->path, false);
91         }
92
93         free(b->controller);
94         free(b->path);
95         free(b);
96 }
97
98 void cgroup_bonding_free_list(CGroupBonding *first) {
99         CGroupBonding *b, *n;
100
101         LIST_FOREACH_SAFE(by_unit, b, n, first)
102                 cgroup_bonding_free(b);
103 }
104
105 void cgroup_bonding_trim(CGroupBonding *b, bool delete_root) {
106         assert(b);
107
108         if (b->realized && b->ours)
109                 cg_trim(b->controller, b->path, delete_root);
110 }
111
112 void cgroup_bonding_trim_list(CGroupBonding *first, bool delete_root) {
113         CGroupBonding *b;
114
115         LIST_FOREACH(by_unit, b, first)
116                 cgroup_bonding_trim(b, delete_root);
117 }
118
119 int cgroup_bonding_install(CGroupBonding *b, pid_t pid) {
120         int r;
121
122         assert(b);
123         assert(pid >= 0);
124
125         if ((r = cg_create_and_attach(b->controller, b->path, pid)) < 0)
126                 return r;
127
128         b->realized = true;
129         return 0;
130 }
131
132 int cgroup_bonding_install_list(CGroupBonding *first, pid_t pid) {
133         CGroupBonding *b;
134         int r;
135
136         LIST_FOREACH(by_unit, b, first)
137                 if ((r = cgroup_bonding_install(b, pid)) < 0 && b->essential)
138                         return r;
139
140         return 0;
141 }
142
143 int cgroup_bonding_kill(CGroupBonding *b, int sig, bool sigcont, Set *s) {
144         assert(b);
145         assert(sig >= 0);
146
147         /* Don't kill cgroups that aren't ours */
148         if (!b->realized || !b->ours)
149                 return 0;
150
151         return cg_kill_recursive(b->controller, b->path, sig, sigcont, true, false, s);
152 }
153
154 int cgroup_bonding_kill_list(CGroupBonding *first, int sig, bool sigcont, Set *s) {
155         CGroupBonding *b;
156         Set *allocated_set = NULL;
157         int ret = -EAGAIN, r;
158
159         if (!s)
160                 if (!(s = allocated_set = set_new(trivial_hash_func, trivial_compare_func)))
161                         return -ENOMEM;
162
163         LIST_FOREACH(by_unit, b, first) {
164                 if ((r = cgroup_bonding_kill(b, sig, sigcont, s)) < 0) {
165                         if (r == -EAGAIN || r == -ESRCH)
166                                 continue;
167
168                         ret = r;
169                         goto finish;
170                 }
171
172                 if (ret < 0 || r > 0)
173                         ret = r;
174         }
175
176 finish:
177         if (allocated_set)
178                 set_free(allocated_set);
179
180         return ret;
181 }
182
183 /* Returns 1 if the group is empty, 0 if it is not, -EAGAIN if we
184  * cannot know */
185 int cgroup_bonding_is_empty(CGroupBonding *b) {
186         int r;
187
188         assert(b);
189
190         if ((r = cg_is_empty_recursive(b->controller, b->path, true)) < 0)
191                 return r;
192
193         /* If it is empty it is empty */
194         if (r > 0)
195                 return 1;
196
197         /* It's not only us using this cgroup, so we just don't know */
198         return b->ours ? 0 : -EAGAIN;
199 }
200
201 int cgroup_bonding_is_empty_list(CGroupBonding *first) {
202         CGroupBonding *b;
203
204         LIST_FOREACH(by_unit, b, first) {
205                 int r;
206
207                 if ((r = cgroup_bonding_is_empty(b)) < 0) {
208                         /* If this returned -EAGAIN, then we don't know if the
209                          * group is empty, so let's see if another group can
210                          * tell us */
211
212                         if (r != -EAGAIN)
213                                 return r;
214                 } else
215                         return r;
216         }
217
218         return -EAGAIN;
219 }
220
221 int manager_setup_cgroup(Manager *m) {
222         char *current = NULL, *path = NULL;
223         int r;
224         char suffix[32];
225
226         assert(m);
227
228         /* 1. Determine hierarchy */
229         if ((r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, 0, &current)) < 0)
230                 goto finish;
231
232         if (m->running_as == MANAGER_SYSTEM)
233                 strcpy(suffix, "/system");
234         else {
235                 snprintf(suffix, sizeof(suffix), "/systemd-%lu", (unsigned long) getpid());
236                 char_array_0(suffix);
237         }
238
239         free(m->cgroup_hierarchy);
240         if (endswith(current, suffix)) {
241                 /* We probably got reexecuted and can continue to use our root cgroup */
242                 m->cgroup_hierarchy = current;
243                 current = NULL;
244
245         } else {
246                 /* We need a new root cgroup */
247                 m->cgroup_hierarchy = NULL;
248                 if (asprintf(&m->cgroup_hierarchy, "%s%s", streq(current, "/") ? "" : current, suffix) < 0) {
249                         r = -ENOMEM;
250                         goto finish;
251                 }
252         }
253
254         /* 2. Show data */
255         if ((r = cg_get_path(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_hierarchy, NULL, &path)) < 0)
256                 goto finish;
257
258         log_debug("Using cgroup controller " SYSTEMD_CGROUP_CONTROLLER ". File system hierarchy is at %s.", path);
259
260         /* 3. Install agent */
261         if ((r = cg_install_release_agent(SYSTEMD_CGROUP_CONTROLLER, SYSTEMD_CGROUP_AGENT_PATH)) < 0)
262                 log_warning("Failed to install release agent, ignoring: %s", strerror(-r));
263         else if (r > 0)
264                 log_debug("Installed release agent.");
265         else
266                 log_debug("Release agent already installed.");
267
268         /* 4. Realize the group */
269         if ((r = cg_create_and_attach(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_hierarchy, 0)) < 0) {
270                 log_error("Failed to create root cgroup hierarchy: %s", strerror(-r));
271                 goto finish;
272         }
273
274         /* 5. And pin it, so that it cannot be unmounted */
275         if (m->pin_cgroupfs_fd >= 0)
276                 close_nointr_nofail(m->pin_cgroupfs_fd);
277
278         if ((m->pin_cgroupfs_fd = open(path, O_RDONLY|O_CLOEXEC|O_DIRECTORY|O_NOCTTY|O_NONBLOCK)) < 0) {
279                 r = -errno;
280                 goto finish;
281         }
282
283         log_debug("Created root group.");
284
285 finish:
286         free(current);
287         free(path);
288
289         return r;
290 }
291
292 void manager_shutdown_cgroup(Manager *m, bool delete) {
293         assert(m);
294
295         if (delete && m->cgroup_hierarchy)
296                 cg_delete(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_hierarchy);
297
298         if (m->pin_cgroupfs_fd >= 0) {
299                 close_nointr_nofail(m->pin_cgroupfs_fd);
300                 m->pin_cgroupfs_fd = -1;
301         }
302
303         free(m->cgroup_hierarchy);
304         m->cgroup_hierarchy = NULL;
305 }
306
307 int cgroup_notify_empty(Manager *m, const char *group) {
308         CGroupBonding *l, *b;
309
310         assert(m);
311         assert(group);
312
313         if (!(l = hashmap_get(m->cgroup_bondings, group)))
314                 return 0;
315
316         LIST_FOREACH(by_path, b, l) {
317                 int t;
318
319                 if (!b->unit)
320                         continue;
321
322                 if ((t = cgroup_bonding_is_empty_list(b)) < 0) {
323
324                         /* If we don't know, we don't know */
325                         if (t != -EAGAIN)
326                                 log_warning("Failed to check whether cgroup is empty: %s", strerror(errno));
327
328                         continue;
329                 }
330
331                 if (t > 0)
332                         if (UNIT_VTABLE(b->unit)->cgroup_notify_empty)
333                                 UNIT_VTABLE(b->unit)->cgroup_notify_empty(b->unit);
334         }
335
336         return 0;
337 }
338
339 Unit* cgroup_unit_by_pid(Manager *m, pid_t pid) {
340         CGroupBonding *l, *b;
341         char *group = NULL;
342
343         assert(m);
344
345         if (pid <= 1)
346                 return NULL;
347
348         if (cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, pid, &group) < 0)
349                 return NULL;
350
351         l = hashmap_get(m->cgroup_bondings, group);
352
353         if (!l) {
354                 char *slash;
355
356                 while ((slash = strrchr(group, '/'))) {
357                         if (slash == group)
358                                 break;
359
360                         *slash = 0;
361
362                         if ((l = hashmap_get(m->cgroup_bondings, group)))
363                                 break;
364                 }
365         }
366
367         free(group);
368
369         LIST_FOREACH(by_path, b, l) {
370
371                 if (!b->unit)
372                         continue;
373
374                 if (b->ours)
375                         return b->unit;
376         }
377
378         return NULL;
379 }
380
381 CGroupBonding *cgroup_bonding_find_list(CGroupBonding *first, const char *controller) {
382         CGroupBonding *b;
383
384         assert(controller);
385
386         LIST_FOREACH(by_unit, b, first)
387                 if (streq(b->controller, controller))
388                         return b;
389
390         return NULL;
391 }
392
393 char *cgroup_bonding_to_string(CGroupBonding *b) {
394         char *r;
395
396         assert(b);
397
398         if (asprintf(&r, "%s:%s", b->controller, b->path) < 0)
399                 return NULL;
400
401         return r;
402 }
403
404 pid_t cgroup_bonding_search_main_pid(CGroupBonding *b) {
405         FILE *f;
406         pid_t pid = 0, npid, mypid;
407
408         assert(b);
409
410         if (!b->ours)
411                 return 0;
412
413         if (cg_enumerate_processes(b->controller, b->path, &f) < 0)
414                 return 0;
415
416         mypid = getpid();
417
418         while (cg_read_pid(f, &npid) > 0)  {
419                 pid_t ppid;
420
421                 if (npid == pid)
422                         continue;
423
424                 /* Ignore processes that aren't our kids */
425                 if (get_parent_of_pid(npid, &ppid) >= 0 && ppid != mypid)
426                         continue;
427
428                 if (pid != 0) {
429                         /* Dang, there's more than one daemonized PID
430                         in this group, so we don't know what process
431                         is the main process. */
432                         pid = 0;
433                         break;
434                 }
435
436                 pid = npid;
437         }
438
439         fclose(f);
440
441         return pid;
442 }
443
444 pid_t cgroup_bonding_search_main_pid_list(CGroupBonding *first) {
445         CGroupBonding *b;
446         pid_t pid;
447
448         /* Try to find a main pid from this cgroup, but checking if
449          * there's only one PID in the cgroup and returning it. Later
450          * on we might want to add additional, smarter heuristics
451          * here. */
452
453         LIST_FOREACH(by_unit, b, first)
454                 if ((pid = cgroup_bonding_search_main_pid(b)) != 0)
455                         return pid;
456
457         return 0;
458
459 }