chiark / gitweb /
units: apply default resource limits to socket/mount/swap processes too
[elogind.git] / src / core / swap.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 <errno.h>
23 #include <limits.h>
24 #include <unistd.h>
25 #include <fcntl.h>
26 #include <sys/epoll.h>
27 #include <sys/stat.h>
28 #include <sys/swap.h>
29 #include <libudev.h>
30
31 #include "unit.h"
32 #include "swap.h"
33 #include "load-fragment.h"
34 #include "load-dropin.h"
35 #include "unit-name.h"
36 #include "dbus-swap.h"
37 #include "special.h"
38 #include "bus-errors.h"
39 #include "exit-status.h"
40 #include "def.h"
41 #include "path-util.h"
42
43 static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
44         [SWAP_DEAD] = UNIT_INACTIVE,
45         [SWAP_ACTIVATING] = UNIT_ACTIVATING,
46         [SWAP_ACTIVE] = UNIT_ACTIVE,
47         [SWAP_DEACTIVATING] = UNIT_DEACTIVATING,
48         [SWAP_ACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
49         [SWAP_ACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
50         [SWAP_DEACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
51         [SWAP_DEACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
52         [SWAP_FAILED] = UNIT_FAILED
53 };
54
55 static void swap_unset_proc_swaps(Swap *s) {
56         Swap *first;
57
58         assert(s);
59
60         if (!s->parameters_proc_swaps.what)
61                 return;
62
63         /* Remove this unit from the chain of swaps which share the
64          * same kernel swap device. */
65
66         first = hashmap_get(UNIT(s)->manager->swaps_by_proc_swaps, s->parameters_proc_swaps.what);
67         LIST_REMOVE(Swap, same_proc_swaps, first, s);
68
69         if (first)
70                 hashmap_remove_and_replace(UNIT(s)->manager->swaps_by_proc_swaps, s->parameters_proc_swaps.what, first->parameters_proc_swaps.what, first);
71         else
72                 hashmap_remove(UNIT(s)->manager->swaps_by_proc_swaps, s->parameters_proc_swaps.what);
73
74         free(s->parameters_proc_swaps.what);
75         s->parameters_proc_swaps.what = NULL;
76 }
77
78 static void swap_init(Unit *u) {
79         Swap *s = SWAP(u);
80
81         assert(s);
82         assert(UNIT(s)->load_state == UNIT_STUB);
83
84         s->timeout_usec = DEFAULT_TIMEOUT_USEC;
85
86         exec_context_init(&s->exec_context);
87         s->exec_context.std_output = u->manager->default_std_output;
88         s->exec_context.std_error = u->manager->default_std_error;
89         kill_context_init(&s->kill_context);
90
91         s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
92
93         s->timer_watch.type = WATCH_INVALID;
94
95         s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
96
97         UNIT(s)->ignore_on_isolate = true;
98 }
99
100 static void swap_unwatch_control_pid(Swap *s) {
101         assert(s);
102
103         if (s->control_pid <= 0)
104                 return;
105
106         unit_unwatch_pid(UNIT(s), s->control_pid);
107         s->control_pid = 0;
108 }
109
110 static void swap_done(Unit *u) {
111         Swap *s = SWAP(u);
112
113         assert(s);
114
115         swap_unset_proc_swaps(s);
116
117         free(s->what);
118         s->what = NULL;
119
120         free(s->parameters_fragment.what);
121         s->parameters_fragment.what = NULL;
122
123         exec_context_done(&s->exec_context);
124         exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
125         s->control_command = NULL;
126
127         swap_unwatch_control_pid(s);
128
129         unit_unwatch_timer(u, &s->timer_watch);
130 }
131
132 int swap_add_one_mount_link(Swap *s, Mount *m) {
133          int r;
134
135         assert(s);
136         assert(m);
137
138         if (UNIT(s)->load_state != UNIT_LOADED ||
139             UNIT(m)->load_state != UNIT_LOADED)
140                 return 0;
141
142         if (is_device_path(s->what))
143                 return 0;
144
145         if (!path_startswith(s->what, m->where))
146                 return 0;
147
148         if ((r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true)) < 0)
149                 return r;
150
151         return 0;
152 }
153
154 static int swap_add_mount_links(Swap *s) {
155         Unit *other;
156         int r;
157
158         assert(s);
159
160         LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT])
161                 if ((r = swap_add_one_mount_link(s, MOUNT(other))) < 0)
162                         return r;
163
164         return 0;
165 }
166
167 static int swap_add_target_links(Swap *s) {
168         Unit *tu;
169         int r;
170
171         assert(s);
172
173         if (!s->from_fragment)
174                 return 0;
175
176         if ((r = manager_load_unit(UNIT(s)->manager, SPECIAL_SWAP_TARGET, NULL, NULL, &tu)) < 0)
177                 return r;
178
179         return unit_add_dependency(UNIT(s), UNIT_BEFORE, tu, true);
180 }
181
182 static int swap_add_device_links(Swap *s) {
183         SwapParameters *p;
184
185         assert(s);
186
187         if (!s->what)
188                 return 0;
189
190         if (s->from_fragment)
191                 p = &s->parameters_fragment;
192         else
193                 return 0;
194
195         if (is_device_path(s->what))
196                 return unit_add_node_link(UNIT(s), s->what,
197                                           !p->noauto && p->nofail &&
198                                           UNIT(s)->manager->running_as == MANAGER_SYSTEM);
199         else
200                 /* File based swap devices need to be ordered after
201                  * systemd-remount-fs.service, since they might need a
202                  * writable file system. */
203                 return unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_REMOUNT_FS_SERVICE, NULL, true);
204 }
205
206 static int swap_add_default_dependencies(Swap *s) {
207         int r;
208
209         assert(s);
210
211         if (UNIT(s)->manager->running_as != MANAGER_SYSTEM)
212                 return 0;
213
214         r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
215         if (r < 0)
216                 return r;
217
218         return 0;
219 }
220
221 static int swap_verify(Swap *s) {
222         bool b;
223         char *e;
224
225         if (UNIT(s)->load_state != UNIT_LOADED)
226                   return 0;
227
228         if (!(e = unit_name_from_path(s->what, ".swap")))
229                   return -ENOMEM;
230
231         b = unit_has_name(UNIT(s), e);
232         free(e);
233
234         if (!b) {
235                 log_error("%s: Value of \"What\" and unit name do not match, not loading.\n", UNIT(s)->id);
236                 return -EINVAL;
237         }
238
239         if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
240                 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
241                 return -EINVAL;
242         }
243
244         return 0;
245 }
246
247 static int swap_load(Unit *u) {
248         int r;
249         Swap *s = SWAP(u);
250
251         assert(s);
252         assert(u->load_state == UNIT_STUB);
253
254         /* Load a .swap file */
255         if ((r = unit_load_fragment_and_dropin_optional(u)) < 0)
256                 return r;
257
258         if (u->load_state == UNIT_LOADED) {
259                 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
260                         return r;
261
262                 if (UNIT(s)->fragment_path)
263                         s->from_fragment = true;
264
265                 if (!s->what) {
266                         if (s->parameters_fragment.what)
267                                 s->what = strdup(s->parameters_fragment.what);
268                         else if (s->parameters_proc_swaps.what)
269                                 s->what = strdup(s->parameters_proc_swaps.what);
270                         else
271                                 s->what = unit_name_to_path(u->id);
272
273                         if (!s->what)
274                                 return -ENOMEM;
275                 }
276
277                 path_kill_slashes(s->what);
278
279                 if (!UNIT(s)->description)
280                         if ((r = unit_set_description(u, s->what)) < 0)
281                                 return r;
282
283                 if ((r = swap_add_device_links(s)) < 0)
284                         return r;
285
286                 if ((r = swap_add_mount_links(s)) < 0)
287                         return r;
288
289                 if ((r = swap_add_target_links(s)) < 0)
290                         return r;
291
292                 if ((r = unit_add_default_cgroups(u)) < 0)
293                         return r;
294
295                 if (UNIT(s)->default_dependencies)
296                         if ((r = swap_add_default_dependencies(s)) < 0)
297                                 return r;
298
299                 r = unit_exec_context_defaults(u, &s->exec_context);
300                 if (r < 0)
301                         return r;
302         }
303
304         return swap_verify(s);
305 }
306
307 static int swap_add_one(
308                 Manager *m,
309                 const char *what,
310                 const char *what_proc_swaps,
311                 int priority,
312                 bool noauto,
313                 bool nofail,
314                 bool set_flags) {
315
316         Unit *u = NULL;
317         char *e = NULL, *wp = NULL;
318         bool delete = false;
319         int r;
320         SwapParameters *p;
321         Swap *first;
322
323         assert(m);
324         assert(what);
325         assert(what_proc_swaps);
326
327         e = unit_name_from_path(what, ".swap");
328         if (!e)
329                 return -ENOMEM;
330
331         u = manager_get_unit(m, e);
332
333         if (u &&
334             SWAP(u)->from_proc_swaps &&
335             !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps))
336                 return -EEXIST;
337
338         if (!u) {
339                 delete = true;
340
341                 u = unit_new(m, sizeof(Swap));
342                 if (!u) {
343                         free(e);
344                         return -ENOMEM;
345                 }
346
347                 r = unit_add_name(u, e);
348                 if (r < 0)
349                         goto fail;
350
351                 SWAP(u)->what = strdup(what);
352                 if (!SWAP(u)->what) {
353                         r = -ENOMEM;
354                         goto fail;
355                 }
356
357                 unit_add_to_load_queue(u);
358         } else
359                 delete = false;
360
361         p = &SWAP(u)->parameters_proc_swaps;
362
363         if (!p->what) {
364                 if (!(wp = strdup(what_proc_swaps))) {
365                         r = -ENOMEM;
366                         goto fail;
367                 }
368
369                 if (!m->swaps_by_proc_swaps)
370                         if (!(m->swaps_by_proc_swaps = hashmap_new(string_hash_func, string_compare_func))) {
371                                 r = -ENOMEM;
372                                 goto fail;
373                         }
374
375                 free(p->what);
376                 p->what = wp;
377
378                 first = hashmap_get(m->swaps_by_proc_swaps, wp);
379                 LIST_PREPEND(Swap, same_proc_swaps, first, SWAP(u));
380
381                 if ((r = hashmap_replace(m->swaps_by_proc_swaps, wp, first)) < 0)
382                         goto fail;
383         }
384
385         if (set_flags) {
386                 SWAP(u)->is_active = true;
387                 SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
388         }
389
390         SWAP(u)->from_proc_swaps = true;
391
392         p->priority = priority;
393         p->noauto = noauto;
394         p->nofail = nofail;
395
396         unit_add_to_dbus_queue(u);
397
398         free(e);
399
400         return 0;
401
402 fail:
403         log_warning("Failed to load swap unit: %s", strerror(-r));
404
405         free(wp);
406         free(e);
407
408         if (delete && u)
409                 unit_free(u);
410
411         return r;
412 }
413
414 static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) {
415         struct stat st;
416         int r = 0, k;
417
418         assert(m);
419
420         if (stat(device, &st) >= 0 && S_ISBLK(st.st_mode)) {
421                 struct udev_device *d;
422                 const char *dn;
423                 struct udev_list_entry *item = NULL, *first = NULL;
424
425                 /* So this is a proper swap device. Create swap units
426                  * for all names this swap device is known under */
427
428                 if (!(d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev)))
429                         return -ENOMEM;
430
431                 dn = udev_device_get_devnode(d);
432                 if (dn)
433                         r = swap_add_one(m, dn, device, prio, false, false, set_flags);
434
435                 /* Add additional units for all symlinks */
436                 first = udev_device_get_devlinks_list_entry(d);
437                 udev_list_entry_foreach(item, first) {
438                         const char *p;
439
440                         /* Don't bother with the /dev/block links */
441                         p = udev_list_entry_get_name(item);
442
443                         if (path_startswith(p, "/dev/block/"))
444                                 continue;
445
446                         if (stat(p, &st) >= 0)
447                                 if ((!S_ISBLK(st.st_mode)) || st.st_rdev != udev_device_get_devnum(d))
448                                         continue;
449
450                         k = swap_add_one(m, p, device, prio, false, false, set_flags);
451                         if (k < 0)
452                                 r = k;
453                 }
454
455                 udev_device_unref(d);
456         }
457
458         k = swap_add_one(m, device, device, prio, false, false, set_flags);
459         if (k < 0)
460                 r = k;
461
462         return r;
463 }
464
465 static void swap_set_state(Swap *s, SwapState state) {
466         SwapState old_state;
467
468         assert(s);
469
470         old_state = s->state;
471         s->state = state;
472
473         if (state != SWAP_ACTIVATING &&
474             state != SWAP_ACTIVATING_SIGTERM &&
475             state != SWAP_ACTIVATING_SIGKILL &&
476             state != SWAP_DEACTIVATING &&
477             state != SWAP_DEACTIVATING_SIGTERM &&
478             state != SWAP_DEACTIVATING_SIGKILL) {
479                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
480                 swap_unwatch_control_pid(s);
481                 s->control_command = NULL;
482                 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
483         }
484
485         if (state != old_state)
486                 log_debug("%s changed %s -> %s",
487                           UNIT(s)->id,
488                           swap_state_to_string(old_state),
489                           swap_state_to_string(state));
490
491         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
492 }
493
494 static int swap_coldplug(Unit *u) {
495         Swap *s = SWAP(u);
496         SwapState new_state = SWAP_DEAD;
497         int r;
498
499         assert(s);
500         assert(s->state == SWAP_DEAD);
501
502         if (s->deserialized_state != s->state)
503                 new_state = s->deserialized_state;
504         else if (s->from_proc_swaps)
505                 new_state = SWAP_ACTIVE;
506
507         if (new_state != s->state) {
508
509                 if (new_state == SWAP_ACTIVATING ||
510                     new_state == SWAP_ACTIVATING_SIGTERM ||
511                     new_state == SWAP_ACTIVATING_SIGKILL ||
512                     new_state == SWAP_DEACTIVATING ||
513                     new_state == SWAP_DEACTIVATING_SIGTERM ||
514                     new_state == SWAP_DEACTIVATING_SIGKILL) {
515
516                         if (s->control_pid <= 0)
517                                 return -EBADMSG;
518
519                         if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
520                                 return r;
521
522                         if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
523                                 return r;
524                 }
525
526                 swap_set_state(s, new_state);
527         }
528
529         return 0;
530 }
531
532 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
533         Swap *s = SWAP(u);
534         SwapParameters *p;
535
536         assert(s);
537         assert(f);
538
539         if (s->from_proc_swaps)
540                 p = &s->parameters_proc_swaps;
541         else if (s->from_fragment)
542                 p = &s->parameters_fragment;
543         else
544                 p = NULL;
545
546         fprintf(f,
547                 "%sSwap State: %s\n"
548                 "%sResult: %s\n"
549                 "%sWhat: %s\n"
550                 "%sFrom /proc/swaps: %s\n"
551                 "%sFrom fragment: %s\n",
552                 prefix, swap_state_to_string(s->state),
553                 prefix, swap_result_to_string(s->result),
554                 prefix, s->what,
555                 prefix, yes_no(s->from_proc_swaps),
556                 prefix, yes_no(s->from_fragment));
557
558         if (p)
559                 fprintf(f,
560                         "%sPriority: %i\n"
561                         "%sNoAuto: %s\n"
562                         "%sNoFail: %s\n",
563                         prefix, p->priority,
564                         prefix, yes_no(p->noauto),
565                         prefix, yes_no(p->nofail));
566
567         if (s->control_pid > 0)
568                 fprintf(f,
569                         "%sControl PID: %lu\n",
570                         prefix, (unsigned long) s->control_pid);
571
572         exec_context_dump(&s->exec_context, f, prefix);
573         kill_context_dump(&s->kill_context, f, prefix);
574 }
575
576 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
577         pid_t pid;
578         int r;
579
580         assert(s);
581         assert(c);
582         assert(_pid);
583
584         if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
585                 goto fail;
586
587         if ((r = exec_spawn(c,
588                             NULL,
589                             &s->exec_context,
590                             NULL, 0,
591                             UNIT(s)->manager->environment,
592                             true,
593                             true,
594                             true,
595                             UNIT(s)->manager->confirm_spawn,
596                             UNIT(s)->cgroup_bondings,
597                             UNIT(s)->cgroup_attributes,
598                             NULL,
599                             UNIT(s)->id,
600                             NULL,
601                             &pid)) < 0)
602                 goto fail;
603
604         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
605                 /* FIXME: we need to do something here */
606                 goto fail;
607
608         *_pid = pid;
609
610         return 0;
611
612 fail:
613         unit_unwatch_timer(UNIT(s), &s->timer_watch);
614
615         return r;
616 }
617
618 static void swap_enter_dead(Swap *s, SwapResult f) {
619         assert(s);
620
621         if (f != SWAP_SUCCESS)
622                 s->result = f;
623
624         swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
625 }
626
627 static void swap_enter_active(Swap *s, SwapResult f) {
628         assert(s);
629
630         if (f != SWAP_SUCCESS)
631                 s->result = f;
632
633         swap_set_state(s, SWAP_ACTIVE);
634 }
635
636 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
637         int r;
638         Set *pid_set = NULL;
639         bool wait_for_exit = false;
640
641         assert(s);
642
643         if (f != SWAP_SUCCESS)
644                 s->result = f;
645
646         if (s->kill_context.kill_mode != KILL_NONE) {
647                 int sig = (state == SWAP_ACTIVATING_SIGTERM ||
648                            state == SWAP_DEACTIVATING_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
649
650                 if (s->control_pid > 0) {
651                         if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
652
653                                 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
654                         else
655                                 wait_for_exit = true;
656                 }
657
658                 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
659
660                         if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
661                                 r = -ENOMEM;
662                                 goto fail;
663                         }
664
665                         /* Exclude the control pid from being killed via the cgroup */
666                         if (s->control_pid > 0)
667                                 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
668                                         goto fail;
669
670                         r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
671                         if (r < 0) {
672                                 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
673                                         log_warning("Failed to kill control group: %s", strerror(-r));
674                         } else if (r > 0)
675                                 wait_for_exit = true;
676
677                         set_free(pid_set);
678                         pid_set = NULL;
679                 }
680         }
681
682         if (wait_for_exit) {
683                 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
684                         goto fail;
685
686                 swap_set_state(s, state);
687         } else
688                 swap_enter_dead(s, SWAP_SUCCESS);
689
690         return;
691
692 fail:
693         log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
694
695         swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
696
697         if (pid_set)
698                 set_free(pid_set);
699 }
700
701 static void swap_enter_activating(Swap *s) {
702         int r, priority;
703
704         assert(s);
705
706         s->control_command_id = SWAP_EXEC_ACTIVATE;
707         s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
708
709         if (s->from_fragment)
710                 priority = s->parameters_fragment.priority;
711         else
712                 priority = -1;
713
714         if (priority >= 0) {
715                 char p[LINE_MAX];
716
717                 snprintf(p, sizeof(p), "%i", priority);
718                 char_array_0(p);
719
720                 r = exec_command_set(
721                                 s->control_command,
722                                 "/sbin/swapon",
723                                 "-p",
724                                 p,
725                                 s->what,
726                                 NULL);
727         } else
728                 r = exec_command_set(
729                                 s->control_command,
730                                 "/sbin/swapon",
731                                 s->what,
732                                 NULL);
733
734         if (r < 0)
735                 goto fail;
736
737         swap_unwatch_control_pid(s);
738
739         if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
740                 goto fail;
741
742         swap_set_state(s, SWAP_ACTIVATING);
743
744         return;
745
746 fail:
747         log_warning("%s failed to run 'swapon' task: %s", UNIT(s)->id, strerror(-r));
748         swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
749 }
750
751 static void swap_enter_deactivating(Swap *s) {
752         int r;
753
754         assert(s);
755
756         s->control_command_id = SWAP_EXEC_DEACTIVATE;
757         s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
758
759         if ((r = exec_command_set(
760                              s->control_command,
761                              "/sbin/swapoff",
762                              s->what,
763                              NULL)) < 0)
764                 goto fail;
765
766         swap_unwatch_control_pid(s);
767
768         if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
769                 goto fail;
770
771         swap_set_state(s, SWAP_DEACTIVATING);
772
773         return;
774
775 fail:
776         log_warning("%s failed to run 'swapoff' task: %s", UNIT(s)->id, strerror(-r));
777         swap_enter_active(s, SWAP_FAILURE_RESOURCES);
778 }
779
780 static int swap_start(Unit *u) {
781         Swap *s = SWAP(u);
782
783         assert(s);
784
785         /* We cannot fulfill this request right now, try again later
786          * please! */
787
788         if (s->state == SWAP_DEACTIVATING ||
789             s->state == SWAP_DEACTIVATING_SIGTERM ||
790             s->state == SWAP_DEACTIVATING_SIGKILL ||
791             s->state == SWAP_ACTIVATING_SIGTERM ||
792             s->state == SWAP_ACTIVATING_SIGKILL)
793                 return -EAGAIN;
794
795         if (s->state == SWAP_ACTIVATING)
796                 return 0;
797
798         assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
799
800         s->result = SWAP_SUCCESS;
801         swap_enter_activating(s);
802         return 0;
803 }
804
805 static int swap_stop(Unit *u) {
806         Swap *s = SWAP(u);
807
808         assert(s);
809
810         if (s->state == SWAP_DEACTIVATING ||
811             s->state == SWAP_DEACTIVATING_SIGTERM ||
812             s->state == SWAP_DEACTIVATING_SIGKILL ||
813             s->state == SWAP_ACTIVATING_SIGTERM ||
814             s->state == SWAP_ACTIVATING_SIGKILL)
815                 return 0;
816
817         assert(s->state == SWAP_ACTIVATING ||
818                s->state == SWAP_ACTIVE);
819
820         swap_enter_deactivating(s);
821         return 0;
822 }
823
824 static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
825         Swap *s = SWAP(u);
826
827         assert(s);
828         assert(f);
829         assert(fds);
830
831         unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
832         unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
833
834         if (s->control_pid > 0)
835                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
836
837         if (s->control_command_id >= 0)
838                 unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
839
840         return 0;
841 }
842
843 static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
844         Swap *s = SWAP(u);
845
846         assert(s);
847         assert(fds);
848
849         if (streq(key, "state")) {
850                 SwapState state;
851
852                 if ((state = swap_state_from_string(value)) < 0)
853                         log_debug("Failed to parse state value %s", value);
854                 else
855                         s->deserialized_state = state;
856         } else if (streq(key, "result")) {
857                 SwapResult f;
858
859                 f = swap_result_from_string(value);
860                 if (f < 0)
861                         log_debug("Failed to parse result value %s", value);
862                 else if (f != SWAP_SUCCESS)
863                         s->result = f;
864         } else if (streq(key, "control-pid")) {
865                 pid_t pid;
866
867                 if (parse_pid(value, &pid) < 0)
868                         log_debug("Failed to parse control-pid value %s", value);
869                 else
870                         s->control_pid = pid;
871
872         } else if (streq(key, "control-command")) {
873                 SwapExecCommand id;
874
875                 if ((id = swap_exec_command_from_string(value)) < 0)
876                         log_debug("Failed to parse exec-command value %s", value);
877                 else {
878                         s->control_command_id = id;
879                         s->control_command = s->exec_command + id;
880                 }
881
882         } else
883                 log_debug("Unknown serialization key '%s'", key);
884
885         return 0;
886 }
887
888 static UnitActiveState swap_active_state(Unit *u) {
889         assert(u);
890
891         return state_translation_table[SWAP(u)->state];
892 }
893
894 static const char *swap_sub_state_to_string(Unit *u) {
895         assert(u);
896
897         return swap_state_to_string(SWAP(u)->state);
898 }
899
900 static bool swap_check_gc(Unit *u) {
901         Swap *s = SWAP(u);
902
903         assert(s);
904
905         return s->from_proc_swaps;
906 }
907
908 static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
909         Swap *s = SWAP(u);
910         SwapResult f;
911
912         assert(s);
913         assert(pid >= 0);
914
915         if (pid != s->control_pid)
916                 return;
917
918         s->control_pid = 0;
919
920         if (is_clean_exit(code, status))
921                 f = SWAP_SUCCESS;
922         else if (code == CLD_EXITED)
923                 f = SWAP_FAILURE_EXIT_CODE;
924         else if (code == CLD_KILLED)
925                 f = SWAP_FAILURE_SIGNAL;
926         else if (code == CLD_DUMPED)
927                 f = SWAP_FAILURE_CORE_DUMP;
928         else
929                 assert_not_reached("Unknown code");
930
931         if (f != SWAP_SUCCESS)
932                 s->result = f;
933
934         if (s->control_command) {
935                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
936
937                 s->control_command = NULL;
938                 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
939         }
940
941         log_full(f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
942                  "%s swap process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
943
944         switch (s->state) {
945
946         case SWAP_ACTIVATING:
947         case SWAP_ACTIVATING_SIGTERM:
948         case SWAP_ACTIVATING_SIGKILL:
949
950                 if (f == SWAP_SUCCESS)
951                         swap_enter_active(s, f);
952                 else
953                         swap_enter_dead(s, f);
954                 break;
955
956         case SWAP_DEACTIVATING:
957         case SWAP_DEACTIVATING_SIGKILL:
958         case SWAP_DEACTIVATING_SIGTERM:
959
960                 if (f == SWAP_SUCCESS)
961                         swap_enter_dead(s, f);
962                 else
963                         swap_enter_dead(s, f);
964                 break;
965
966         default:
967                 assert_not_reached("Uh, control process died at wrong time.");
968         }
969
970         /* Notify clients about changed exit status */
971         unit_add_to_dbus_queue(u);
972
973         /* Request a reload of /proc/swaps, so that following units
974          * can follow our state change */
975         u->manager->request_reload = true;
976 }
977
978 static void swap_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
979         Swap *s = SWAP(u);
980
981         assert(s);
982         assert(elapsed == 1);
983         assert(w == &s->timer_watch);
984
985         switch (s->state) {
986
987         case SWAP_ACTIVATING:
988                 log_warning("%s activation timed out. Stopping.", u->id);
989                 swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
990                 break;
991
992         case SWAP_DEACTIVATING:
993                 log_warning("%s deactivation timed out. Stopping.", u->id);
994                 swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
995                 break;
996
997         case SWAP_ACTIVATING_SIGTERM:
998                 if (s->kill_context.send_sigkill) {
999                         log_warning("%s activation timed out. Killing.", u->id);
1000                         swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1001                 } else {
1002                         log_warning("%s activation timed out. Skipping SIGKILL. Ignoring.", u->id);
1003                         swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1004                 }
1005                 break;
1006
1007         case SWAP_DEACTIVATING_SIGTERM:
1008                 if (s->kill_context.send_sigkill) {
1009                         log_warning("%s deactivation timed out. Killing.", u->id);
1010                         swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1011                 } else {
1012                         log_warning("%s deactivation timed out. Skipping SIGKILL. Ignoring.", u->id);
1013                         swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1014                 }
1015                 break;
1016
1017         case SWAP_ACTIVATING_SIGKILL:
1018         case SWAP_DEACTIVATING_SIGKILL:
1019                 log_warning("%s swap process still around after SIGKILL. Ignoring.", u->id);
1020                 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1021                 break;
1022
1023         default:
1024                 assert_not_reached("Timeout at wrong time.");
1025         }
1026 }
1027
1028 static int swap_load_proc_swaps(Manager *m, bool set_flags) {
1029         unsigned i;
1030         int r = 0;
1031
1032         assert(m);
1033
1034         rewind(m->proc_swaps);
1035
1036         (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
1037
1038         for (i = 1;; i++) {
1039                 char *dev = NULL, *d;
1040                 int prio = 0, k;
1041
1042                 if ((k = fscanf(m->proc_swaps,
1043                                 "%ms "  /* device/file */
1044                                 "%*s "  /* type of swap */
1045                                 "%*s "  /* swap size */
1046                                 "%*s "  /* used */
1047                                 "%i\n", /* priority */
1048                                 &dev, &prio)) != 2) {
1049
1050                         if (k == EOF)
1051                                 break;
1052
1053                         log_warning("Failed to parse /proc/swaps:%u.", i);
1054                         free(dev);
1055                         continue;
1056                 }
1057
1058                 d = cunescape(dev);
1059                 free(dev);
1060
1061                 if (!d)
1062                         return -ENOMEM;
1063
1064                 k = swap_process_new_swap(m, d, prio, set_flags);
1065                 free(d);
1066
1067                 if (k < 0)
1068                         r = k;
1069         }
1070
1071         return r;
1072 }
1073
1074 int swap_dispatch_reload(Manager *m) {
1075         /* This function should go as soon as the kernel properly notifies us */
1076
1077         if (_likely_(!m->request_reload))
1078                 return 0;
1079
1080         m->request_reload = false;
1081
1082         return swap_fd_event(m, EPOLLPRI);
1083 }
1084
1085 int swap_fd_event(Manager *m, int events) {
1086         Unit *u;
1087         int r;
1088
1089         assert(m);
1090         assert(events & EPOLLPRI);
1091
1092         if ((r = swap_load_proc_swaps(m, true)) < 0) {
1093                 log_error("Failed to reread /proc/swaps: %s", strerror(-r));
1094
1095                 /* Reset flags, just in case, for late calls */
1096                 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1097                         Swap *swap = SWAP(u);
1098
1099                         swap->is_active = swap->just_activated = false;
1100                 }
1101
1102                 return 0;
1103         }
1104
1105         manager_dispatch_load_queue(m);
1106
1107         LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1108                 Swap *swap = SWAP(u);
1109
1110                 if (!swap->is_active) {
1111                         /* This has just been deactivated */
1112
1113                         swap->from_proc_swaps = false;
1114                         swap_unset_proc_swaps(swap);
1115
1116                         switch (swap->state) {
1117
1118                         case SWAP_ACTIVE:
1119                                 swap_enter_dead(swap, SWAP_SUCCESS);
1120                                 break;
1121
1122                         default:
1123                                 swap_set_state(swap, swap->state);
1124                                 break;
1125                         }
1126
1127                 } else if (swap->just_activated) {
1128
1129                         /* New swap entry */
1130
1131                         switch (swap->state) {
1132
1133                         case SWAP_DEAD:
1134                         case SWAP_FAILED:
1135                                 swap_enter_active(swap, SWAP_SUCCESS);
1136                                 break;
1137
1138                         default:
1139                                 /* Nothing really changed, but let's
1140                                  * issue an notification call
1141                                  * nonetheless, in case somebody is
1142                                  * waiting for this. */
1143                                 swap_set_state(swap, swap->state);
1144                                 break;
1145                         }
1146                 }
1147
1148                 /* Reset the flags for later calls */
1149                 swap->is_active = swap->just_activated = false;
1150         }
1151
1152         return 1;
1153 }
1154
1155 static Unit *swap_following(Unit *u) {
1156         Swap *s = SWAP(u);
1157         Swap *other, *first = NULL;
1158
1159         assert(s);
1160
1161         if (streq_ptr(s->what, s->parameters_proc_swaps.what))
1162                 return NULL;
1163
1164         /* Make everybody follow the unit that's named after the swap
1165          * device in the kernel */
1166
1167         LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1168                 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1169                         return UNIT(other);
1170
1171         LIST_FOREACH_BEFORE(same_proc_swaps, other, s) {
1172                 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1173                         return UNIT(other);
1174
1175                 first = other;
1176         }
1177
1178         return UNIT(first);
1179 }
1180
1181 static int swap_following_set(Unit *u, Set **_set) {
1182         Swap *s = SWAP(u);
1183         Swap *other;
1184         Set *set;
1185         int r;
1186
1187         assert(s);
1188         assert(_set);
1189
1190         if (LIST_JUST_US(same_proc_swaps, s)) {
1191                 *_set = NULL;
1192                 return 0;
1193         }
1194
1195         if (!(set = set_new(NULL, NULL)))
1196                 return -ENOMEM;
1197
1198         LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1199                 if ((r = set_put(set, other)) < 0)
1200                         goto fail;
1201
1202         LIST_FOREACH_BEFORE(same_proc_swaps, other, s)
1203                 if ((r = set_put(set, other)) < 0)
1204                         goto fail;
1205
1206         *_set = set;
1207         return 1;
1208
1209 fail:
1210         set_free(set);
1211         return r;
1212 }
1213
1214 static void swap_shutdown(Manager *m) {
1215         assert(m);
1216
1217         if (m->proc_swaps) {
1218                 fclose(m->proc_swaps);
1219                 m->proc_swaps = NULL;
1220         }
1221
1222         hashmap_free(m->swaps_by_proc_swaps);
1223         m->swaps_by_proc_swaps = NULL;
1224 }
1225
1226 static int swap_enumerate(Manager *m) {
1227         int r;
1228         struct epoll_event ev;
1229         assert(m);
1230
1231         if (!m->proc_swaps) {
1232                 if (!(m->proc_swaps = fopen("/proc/swaps", "re")))
1233                         return (errno == ENOENT) ? 0 : -errno;
1234
1235                 m->swap_watch.type = WATCH_SWAP;
1236                 m->swap_watch.fd = fileno(m->proc_swaps);
1237
1238                 zero(ev);
1239                 ev.events = EPOLLPRI;
1240                 ev.data.ptr = &m->swap_watch;
1241
1242                 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->swap_watch.fd, &ev) < 0)
1243                         return -errno;
1244         }
1245
1246         if ((r = swap_load_proc_swaps(m, false)) < 0)
1247                 swap_shutdown(m);
1248
1249         return r;
1250 }
1251
1252 static void swap_reset_failed(Unit *u) {
1253         Swap *s = SWAP(u);
1254
1255         assert(s);
1256
1257         if (s->state == SWAP_FAILED)
1258                 swap_set_state(s, SWAP_DEAD);
1259
1260         s->result = SWAP_SUCCESS;
1261 }
1262
1263 static int swap_kill(Unit *u, KillWho who, int signo, DBusError *error) {
1264         Swap *s = SWAP(u);
1265         int r = 0;
1266         Set *pid_set = NULL;
1267
1268         assert(s);
1269
1270         if (who == KILL_MAIN) {
1271                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Swap units have no main processes");
1272                 return -ESRCH;
1273         }
1274
1275         if (s->control_pid <= 0 && who == KILL_CONTROL) {
1276                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1277                 return -ESRCH;
1278         }
1279
1280         if (who == KILL_CONTROL || who == KILL_ALL)
1281                 if (s->control_pid > 0)
1282                         if (kill(s->control_pid, signo) < 0)
1283                                 r = -errno;
1284
1285         if (who == KILL_ALL) {
1286                 int q;
1287
1288                 pid_set = set_new(trivial_hash_func, trivial_compare_func);
1289                 if (!pid_set)
1290                         return -ENOMEM;
1291
1292                 /* Exclude the control pid from being killed via the cgroup */
1293                 if (s->control_pid > 0) {
1294                         q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
1295                         if (q < 0) {
1296                                 r = q;
1297                                 goto finish;
1298                         }
1299                 }
1300
1301                 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
1302                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1303                         r = q;
1304         }
1305
1306 finish:
1307         if (pid_set)
1308                 set_free(pid_set);
1309
1310         return r;
1311 }
1312
1313 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1314         [SWAP_DEAD] = "dead",
1315         [SWAP_ACTIVATING] = "activating",
1316         [SWAP_ACTIVE] = "active",
1317         [SWAP_DEACTIVATING] = "deactivating",
1318         [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1319         [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1320         [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1321         [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1322         [SWAP_FAILED] = "failed"
1323 };
1324
1325 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1326
1327 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1328         [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1329         [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1330 };
1331
1332 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1333
1334 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1335         [SWAP_SUCCESS] = "success",
1336         [SWAP_FAILURE_RESOURCES] = "resources",
1337         [SWAP_FAILURE_TIMEOUT] = "timeout",
1338         [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1339         [SWAP_FAILURE_SIGNAL] = "signal",
1340         [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1341 };
1342
1343 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1344
1345 const UnitVTable swap_vtable = {
1346         .object_size = sizeof(Swap),
1347         .sections =
1348                 "Unit\0"
1349                 "Swap\0"
1350                 "Install\0",
1351
1352         .no_alias = true,
1353         .no_instances = true,
1354
1355         .init = swap_init,
1356         .load = swap_load,
1357         .done = swap_done,
1358
1359         .coldplug = swap_coldplug,
1360
1361         .dump = swap_dump,
1362
1363         .start = swap_start,
1364         .stop = swap_stop,
1365
1366         .kill = swap_kill,
1367
1368         .serialize = swap_serialize,
1369         .deserialize_item = swap_deserialize_item,
1370
1371         .active_state = swap_active_state,
1372         .sub_state_to_string = swap_sub_state_to_string,
1373
1374         .check_gc = swap_check_gc,
1375
1376         .sigchld_event = swap_sigchld_event,
1377         .timer_event = swap_timer_event,
1378
1379         .reset_failed = swap_reset_failed,
1380
1381         .bus_interface = "org.freedesktop.systemd1.Swap",
1382         .bus_message_handler = bus_swap_message_handler,
1383         .bus_invalidating_properties =  bus_swap_invalidating_properties,
1384
1385         .following = swap_following,
1386         .following_set = swap_following_set,
1387
1388         .enumerate = swap_enumerate,
1389         .shutdown = swap_shutdown,
1390
1391         .status_message_formats = {
1392                 .starting_stopping = {
1393                         [0] = "Activating swap %s...",
1394                         [1] = "Deactivating swap %s...",
1395                 },
1396                 .finished_start_job = {
1397                         [JOB_DONE]       = "Activated swap %s.",
1398                         [JOB_FAILED]     = "Failed to activate swap %s.",
1399                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
1400                         [JOB_TIMEOUT]    = "Timed out activating swap %s.",
1401                 },
1402                 .finished_stop_job = {
1403                         [JOB_DONE]       = "Deactivated swap %s.",
1404                         [JOB_FAILED]     = "Failed deactivating swap %s.",
1405                         [JOB_TIMEOUT]    = "Timed out deactivating swap %s.",
1406                 },
1407         },
1408 };