1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
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.
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.
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/>.
26 #include <sys/epoll.h>
33 #include "load-fragment.h"
34 #include "load-dropin.h"
35 #include "unit-name.h"
36 #include "dbus-swap.h"
38 #include "bus-errors.h"
39 #include "exit-status.h"
41 #include "path-util.h"
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
55 static void swap_unset_proc_swaps(Swap *s) {
60 if (!s->parameters_proc_swaps.what)
63 /* Remove this unit from the chain of swaps which share the
64 * same kernel swap device. */
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);
70 hashmap_remove_and_replace(UNIT(s)->manager->swaps_by_proc_swaps, s->parameters_proc_swaps.what, first->parameters_proc_swaps.what, first);
72 hashmap_remove(UNIT(s)->manager->swaps_by_proc_swaps, s->parameters_proc_swaps.what);
74 free(s->parameters_proc_swaps.what);
75 s->parameters_proc_swaps.what = NULL;
78 static void swap_init(Unit *u) {
82 assert(UNIT(s)->load_state == UNIT_STUB);
84 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
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;
90 s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
92 s->timer_watch.type = WATCH_INVALID;
94 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
96 UNIT(s)->ignore_on_isolate = true;
99 static void swap_unwatch_control_pid(Swap *s) {
102 if (s->control_pid <= 0)
105 unit_unwatch_pid(UNIT(s), s->control_pid);
109 static void swap_done(Unit *u) {
114 swap_unset_proc_swaps(s);
119 free(s->parameters_fragment.what);
120 s->parameters_fragment.what = NULL;
122 exec_context_done(&s->exec_context);
123 exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
124 s->control_command = NULL;
126 swap_unwatch_control_pid(s);
128 unit_unwatch_timer(u, &s->timer_watch);
131 int swap_add_one_mount_link(Swap *s, Mount *m) {
137 if (UNIT(s)->load_state != UNIT_LOADED ||
138 UNIT(m)->load_state != UNIT_LOADED)
141 if (is_device_path(s->what))
144 if (!path_startswith(s->what, m->where))
147 if ((r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true)) < 0)
153 static int swap_add_mount_links(Swap *s) {
159 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT])
160 if ((r = swap_add_one_mount_link(s, MOUNT(other))) < 0)
166 static int swap_add_target_links(Swap *s) {
172 if (!s->from_fragment)
175 if ((r = manager_load_unit(UNIT(s)->manager, SPECIAL_SWAP_TARGET, NULL, NULL, &tu)) < 0)
178 return unit_add_dependency(UNIT(s), UNIT_BEFORE, tu, true);
181 static int swap_add_device_links(Swap *s) {
189 if (s->from_fragment)
190 p = &s->parameters_fragment;
194 if (is_device_path(s->what))
195 return unit_add_node_link(UNIT(s), s->what,
196 !p->noauto && p->nofail &&
197 UNIT(s)->manager->running_as == MANAGER_SYSTEM);
199 /* File based swap devices need to be ordered after
200 * systemd-remount-fs.service, since they might need a
201 * writable file system. */
202 return unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_REMOUNT_FS_SERVICE, NULL, true);
205 static int swap_add_default_dependencies(Swap *s) {
210 if (UNIT(s)->manager->running_as != MANAGER_SYSTEM)
213 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
220 static int swap_verify(Swap *s) {
224 if (UNIT(s)->load_state != UNIT_LOADED)
227 if (!(e = unit_name_from_path(s->what, ".swap")))
230 b = unit_has_name(UNIT(s), e);
234 log_error("%s: Value of \"What\" and unit name do not match, not loading.\n", UNIT(s)->id);
238 if (s->exec_context.pam_name && s->exec_context.kill_mode != KILL_CONTROL_GROUP) {
239 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
246 static int swap_load(Unit *u) {
251 assert(u->load_state == UNIT_STUB);
253 /* Load a .swap file */
254 if ((r = unit_load_fragment_and_dropin_optional(u)) < 0)
257 if (u->load_state == UNIT_LOADED) {
258 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
261 if (UNIT(s)->fragment_path)
262 s->from_fragment = true;
265 if (s->parameters_fragment.what)
266 s->what = strdup(s->parameters_fragment.what);
267 else if (s->parameters_proc_swaps.what)
268 s->what = strdup(s->parameters_proc_swaps.what);
270 s->what = unit_name_to_path(u->id);
276 path_kill_slashes(s->what);
278 if (!UNIT(s)->description)
279 if ((r = unit_set_description(u, s->what)) < 0)
282 if ((r = swap_add_device_links(s)) < 0)
285 if ((r = swap_add_mount_links(s)) < 0)
288 if ((r = swap_add_target_links(s)) < 0)
291 if ((r = unit_add_default_cgroups(u)) < 0)
294 if (UNIT(s)->default_dependencies)
295 if ((r = swap_add_default_dependencies(s)) < 0)
299 return swap_verify(s);
302 static int swap_add_one(
305 const char *what_proc_swaps,
312 char *e = NULL, *wp = NULL;
320 assert(what_proc_swaps);
322 e = unit_name_from_path(what, ".swap");
326 u = manager_get_unit(m, e);
329 SWAP(u)->from_proc_swaps &&
330 !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps))
336 u = unit_new(m, sizeof(Swap));
342 r = unit_add_name(u, e);
346 SWAP(u)->what = strdup(what);
347 if (!SWAP(u)->what) {
352 unit_add_to_load_queue(u);
356 p = &SWAP(u)->parameters_proc_swaps;
359 if (!(wp = strdup(what_proc_swaps))) {
364 if (!m->swaps_by_proc_swaps)
365 if (!(m->swaps_by_proc_swaps = hashmap_new(string_hash_func, string_compare_func))) {
373 first = hashmap_get(m->swaps_by_proc_swaps, wp);
374 LIST_PREPEND(Swap, same_proc_swaps, first, SWAP(u));
376 if ((r = hashmap_replace(m->swaps_by_proc_swaps, wp, first)) < 0)
381 SWAP(u)->is_active = true;
382 SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
385 SWAP(u)->from_proc_swaps = true;
387 p->priority = priority;
391 unit_add_to_dbus_queue(u);
398 log_warning("Failed to load swap unit: %s", strerror(-r));
409 static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) {
415 if (stat(device, &st) >= 0 && S_ISBLK(st.st_mode)) {
416 struct udev_device *d;
418 struct udev_list_entry *item = NULL, *first = NULL;
420 /* So this is a proper swap device. Create swap units
421 * for all names this swap device is known under */
423 if (!(d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev)))
426 dn = udev_device_get_devnode(d);
428 r = swap_add_one(m, dn, device, prio, false, false, set_flags);
430 /* Add additional units for all symlinks */
431 first = udev_device_get_devlinks_list_entry(d);
432 udev_list_entry_foreach(item, first) {
435 /* Don't bother with the /dev/block links */
436 p = udev_list_entry_get_name(item);
438 if (path_startswith(p, "/dev/block/"))
441 if (stat(p, &st) >= 0)
442 if ((!S_ISBLK(st.st_mode)) || st.st_rdev != udev_device_get_devnum(d))
445 k = swap_add_one(m, p, device, prio, false, false, set_flags);
450 udev_device_unref(d);
453 k = swap_add_one(m, device, device, prio, false, false, set_flags);
460 static void swap_set_state(Swap *s, SwapState state) {
465 old_state = s->state;
468 if (state != SWAP_ACTIVATING &&
469 state != SWAP_ACTIVATING_SIGTERM &&
470 state != SWAP_ACTIVATING_SIGKILL &&
471 state != SWAP_DEACTIVATING &&
472 state != SWAP_DEACTIVATING_SIGTERM &&
473 state != SWAP_DEACTIVATING_SIGKILL) {
474 unit_unwatch_timer(UNIT(s), &s->timer_watch);
475 swap_unwatch_control_pid(s);
476 s->control_command = NULL;
477 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
480 if (state != old_state)
481 log_debug("%s changed %s -> %s",
483 swap_state_to_string(old_state),
484 swap_state_to_string(state));
486 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
489 static int swap_coldplug(Unit *u) {
491 SwapState new_state = SWAP_DEAD;
495 assert(s->state == SWAP_DEAD);
497 if (s->deserialized_state != s->state)
498 new_state = s->deserialized_state;
499 else if (s->from_proc_swaps)
500 new_state = SWAP_ACTIVE;
502 if (new_state != s->state) {
504 if (new_state == SWAP_ACTIVATING ||
505 new_state == SWAP_ACTIVATING_SIGTERM ||
506 new_state == SWAP_ACTIVATING_SIGKILL ||
507 new_state == SWAP_DEACTIVATING ||
508 new_state == SWAP_DEACTIVATING_SIGTERM ||
509 new_state == SWAP_DEACTIVATING_SIGKILL) {
511 if (s->control_pid <= 0)
514 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
517 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
521 swap_set_state(s, new_state);
527 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
534 if (s->from_proc_swaps)
535 p = &s->parameters_proc_swaps;
536 else if (s->from_fragment)
537 p = &s->parameters_fragment;
545 "%sFrom /proc/swaps: %s\n"
546 "%sFrom fragment: %s\n",
547 prefix, swap_state_to_string(s->state),
548 prefix, swap_result_to_string(s->result),
550 prefix, yes_no(s->from_proc_swaps),
551 prefix, yes_no(s->from_fragment));
559 prefix, yes_no(p->noauto),
560 prefix, yes_no(p->nofail));
562 if (s->control_pid > 0)
564 "%sControl PID: %lu\n",
565 prefix, (unsigned long) s->control_pid);
567 exec_context_dump(&s->exec_context, f, prefix);
570 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
578 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
581 if ((r = exec_spawn(c,
585 UNIT(s)->manager->environment,
589 UNIT(s)->manager->confirm_spawn,
590 UNIT(s)->cgroup_bondings,
591 UNIT(s)->cgroup_attributes,
598 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
599 /* FIXME: we need to do something here */
607 unit_unwatch_timer(UNIT(s), &s->timer_watch);
612 static void swap_enter_dead(Swap *s, SwapResult f) {
615 if (f != SWAP_SUCCESS)
618 swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
621 static void swap_enter_active(Swap *s, SwapResult f) {
624 if (f != SWAP_SUCCESS)
627 swap_set_state(s, SWAP_ACTIVE);
630 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
633 bool wait_for_exit = false;
637 if (f != SWAP_SUCCESS)
640 if (s->exec_context.kill_mode != KILL_NONE) {
641 int sig = (state == SWAP_ACTIVATING_SIGTERM ||
642 state == SWAP_DEACTIVATING_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
644 if (s->control_pid > 0) {
645 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
647 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
649 wait_for_exit = true;
652 if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
654 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
659 /* Exclude the control pid from being killed via the cgroup */
660 if (s->control_pid > 0)
661 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
664 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
666 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
667 log_warning("Failed to kill control group: %s", strerror(-r));
669 wait_for_exit = true;
677 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
680 swap_set_state(s, state);
682 swap_enter_dead(s, SWAP_SUCCESS);
687 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
689 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
695 static void swap_enter_activating(Swap *s) {
700 s->control_command_id = SWAP_EXEC_ACTIVATE;
701 s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
703 if (s->from_fragment)
704 priority = s->parameters_fragment.priority;
711 snprintf(p, sizeof(p), "%i", priority);
714 r = exec_command_set(
722 r = exec_command_set(
731 swap_unwatch_control_pid(s);
733 if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
736 swap_set_state(s, SWAP_ACTIVATING);
741 log_warning("%s failed to run 'swapon' task: %s", UNIT(s)->id, strerror(-r));
742 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
745 static void swap_enter_deactivating(Swap *s) {
750 s->control_command_id = SWAP_EXEC_DEACTIVATE;
751 s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
753 if ((r = exec_command_set(
760 swap_unwatch_control_pid(s);
762 if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
765 swap_set_state(s, SWAP_DEACTIVATING);
770 log_warning("%s failed to run 'swapoff' task: %s", UNIT(s)->id, strerror(-r));
771 swap_enter_active(s, SWAP_FAILURE_RESOURCES);
774 static int swap_start(Unit *u) {
779 /* We cannot fulfill this request right now, try again later
782 if (s->state == SWAP_DEACTIVATING ||
783 s->state == SWAP_DEACTIVATING_SIGTERM ||
784 s->state == SWAP_DEACTIVATING_SIGKILL ||
785 s->state == SWAP_ACTIVATING_SIGTERM ||
786 s->state == SWAP_ACTIVATING_SIGKILL)
789 if (s->state == SWAP_ACTIVATING)
792 assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
794 s->result = SWAP_SUCCESS;
795 swap_enter_activating(s);
799 static int swap_stop(Unit *u) {
804 if (s->state == SWAP_DEACTIVATING ||
805 s->state == SWAP_DEACTIVATING_SIGTERM ||
806 s->state == SWAP_DEACTIVATING_SIGKILL ||
807 s->state == SWAP_ACTIVATING_SIGTERM ||
808 s->state == SWAP_ACTIVATING_SIGKILL)
811 assert(s->state == SWAP_ACTIVATING ||
812 s->state == SWAP_ACTIVE);
814 swap_enter_deactivating(s);
818 static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
825 unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
826 unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
828 if (s->control_pid > 0)
829 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
831 if (s->control_command_id >= 0)
832 unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
837 static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
843 if (streq(key, "state")) {
846 if ((state = swap_state_from_string(value)) < 0)
847 log_debug("Failed to parse state value %s", value);
849 s->deserialized_state = state;
850 } else if (streq(key, "result")) {
853 f = swap_result_from_string(value);
855 log_debug("Failed to parse result value %s", value);
856 else if (f != SWAP_SUCCESS)
858 } else if (streq(key, "control-pid")) {
861 if (parse_pid(value, &pid) < 0)
862 log_debug("Failed to parse control-pid value %s", value);
864 s->control_pid = pid;
866 } else if (streq(key, "control-command")) {
869 if ((id = swap_exec_command_from_string(value)) < 0)
870 log_debug("Failed to parse exec-command value %s", value);
872 s->control_command_id = id;
873 s->control_command = s->exec_command + id;
877 log_debug("Unknown serialization key '%s'", key);
882 static UnitActiveState swap_active_state(Unit *u) {
885 return state_translation_table[SWAP(u)->state];
888 static const char *swap_sub_state_to_string(Unit *u) {
891 return swap_state_to_string(SWAP(u)->state);
894 static bool swap_check_gc(Unit *u) {
899 return s->from_proc_swaps;
902 static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
909 if (pid != s->control_pid)
914 if (is_clean_exit(code, status))
916 else if (code == CLD_EXITED)
917 f = SWAP_FAILURE_EXIT_CODE;
918 else if (code == CLD_KILLED)
919 f = SWAP_FAILURE_SIGNAL;
920 else if (code == CLD_DUMPED)
921 f = SWAP_FAILURE_CORE_DUMP;
923 assert_not_reached("Unknown code");
925 if (f != SWAP_SUCCESS)
928 if (s->control_command) {
929 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
931 s->control_command = NULL;
932 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
935 log_full(f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
936 "%s swap process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
940 case SWAP_ACTIVATING:
941 case SWAP_ACTIVATING_SIGTERM:
942 case SWAP_ACTIVATING_SIGKILL:
944 if (f == SWAP_SUCCESS)
945 swap_enter_active(s, f);
947 swap_enter_dead(s, f);
950 case SWAP_DEACTIVATING:
951 case SWAP_DEACTIVATING_SIGKILL:
952 case SWAP_DEACTIVATING_SIGTERM:
954 if (f == SWAP_SUCCESS)
955 swap_enter_dead(s, f);
957 swap_enter_dead(s, f);
961 assert_not_reached("Uh, control process died at wrong time.");
964 /* Notify clients about changed exit status */
965 unit_add_to_dbus_queue(u);
967 /* Request a reload of /proc/swaps, so that following units
968 * can follow our state change */
969 u->manager->request_reload = true;
972 static void swap_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
976 assert(elapsed == 1);
977 assert(w == &s->timer_watch);
981 case SWAP_ACTIVATING:
982 log_warning("%s activation timed out. Stopping.", u->id);
983 swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
986 case SWAP_DEACTIVATING:
987 log_warning("%s deactivation timed out. Stopping.", u->id);
988 swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
991 case SWAP_ACTIVATING_SIGTERM:
992 if (s->exec_context.send_sigkill) {
993 log_warning("%s activation timed out. Killing.", u->id);
994 swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
996 log_warning("%s activation timed out. Skipping SIGKILL. Ignoring.", u->id);
997 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1001 case SWAP_DEACTIVATING_SIGTERM:
1002 if (s->exec_context.send_sigkill) {
1003 log_warning("%s deactivation timed out. Killing.", u->id);
1004 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1006 log_warning("%s deactivation timed out. Skipping SIGKILL. Ignoring.", u->id);
1007 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1011 case SWAP_ACTIVATING_SIGKILL:
1012 case SWAP_DEACTIVATING_SIGKILL:
1013 log_warning("%s swap process still around after SIGKILL. Ignoring.", u->id);
1014 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1018 assert_not_reached("Timeout at wrong time.");
1022 static int swap_load_proc_swaps(Manager *m, bool set_flags) {
1028 rewind(m->proc_swaps);
1030 (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
1033 char *dev = NULL, *d;
1036 if ((k = fscanf(m->proc_swaps,
1037 "%ms " /* device/file */
1038 "%*s " /* type of swap */
1039 "%*s " /* swap size */
1041 "%i\n", /* priority */
1042 &dev, &prio)) != 2) {
1047 log_warning("Failed to parse /proc/swaps:%u.", i);
1058 k = swap_process_new_swap(m, d, prio, set_flags);
1068 int swap_dispatch_reload(Manager *m) {
1069 /* This function should go as soon as the kernel properly notifies us */
1071 if (_likely_(!m->request_reload))
1074 m->request_reload = false;
1076 return swap_fd_event(m, EPOLLPRI);
1079 int swap_fd_event(Manager *m, int events) {
1084 assert(events & EPOLLPRI);
1086 if ((r = swap_load_proc_swaps(m, true)) < 0) {
1087 log_error("Failed to reread /proc/swaps: %s", strerror(-r));
1089 /* Reset flags, just in case, for late calls */
1090 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1091 Swap *swap = SWAP(u);
1093 swap->is_active = swap->just_activated = false;
1099 manager_dispatch_load_queue(m);
1101 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1102 Swap *swap = SWAP(u);
1104 if (!swap->is_active) {
1105 /* This has just been deactivated */
1107 swap->from_proc_swaps = false;
1108 swap_unset_proc_swaps(swap);
1110 switch (swap->state) {
1113 swap_enter_dead(swap, SWAP_SUCCESS);
1117 swap_set_state(swap, swap->state);
1121 } else if (swap->just_activated) {
1123 /* New swap entry */
1125 switch (swap->state) {
1129 swap_enter_active(swap, SWAP_SUCCESS);
1133 /* Nothing really changed, but let's
1134 * issue an notification call
1135 * nonetheless, in case somebody is
1136 * waiting for this. */
1137 swap_set_state(swap, swap->state);
1142 /* Reset the flags for later calls */
1143 swap->is_active = swap->just_activated = false;
1149 static Unit *swap_following(Unit *u) {
1151 Swap *other, *first = NULL;
1155 if (streq_ptr(s->what, s->parameters_proc_swaps.what))
1158 /* Make everybody follow the unit that's named after the swap
1159 * device in the kernel */
1161 LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1162 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1165 LIST_FOREACH_BEFORE(same_proc_swaps, other, s) {
1166 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1175 static int swap_following_set(Unit *u, Set **_set) {
1184 if (LIST_JUST_US(same_proc_swaps, s)) {
1189 if (!(set = set_new(NULL, NULL)))
1192 LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1193 if ((r = set_put(set, other)) < 0)
1196 LIST_FOREACH_BEFORE(same_proc_swaps, other, s)
1197 if ((r = set_put(set, other)) < 0)
1208 static void swap_shutdown(Manager *m) {
1211 if (m->proc_swaps) {
1212 fclose(m->proc_swaps);
1213 m->proc_swaps = NULL;
1216 hashmap_free(m->swaps_by_proc_swaps);
1217 m->swaps_by_proc_swaps = NULL;
1220 static int swap_enumerate(Manager *m) {
1222 struct epoll_event ev;
1225 if (!m->proc_swaps) {
1226 if (!(m->proc_swaps = fopen("/proc/swaps", "re")))
1227 return (errno == ENOENT) ? 0 : -errno;
1229 m->swap_watch.type = WATCH_SWAP;
1230 m->swap_watch.fd = fileno(m->proc_swaps);
1233 ev.events = EPOLLPRI;
1234 ev.data.ptr = &m->swap_watch;
1236 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->swap_watch.fd, &ev) < 0)
1240 if ((r = swap_load_proc_swaps(m, false)) < 0)
1246 static void swap_reset_failed(Unit *u) {
1251 if (s->state == SWAP_FAILED)
1252 swap_set_state(s, SWAP_DEAD);
1254 s->result = SWAP_SUCCESS;
1257 static int swap_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1260 Set *pid_set = NULL;
1264 if (who == KILL_MAIN) {
1265 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Swap units have no main processes");
1269 if (s->control_pid <= 0 && who == KILL_CONTROL) {
1270 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1274 if (who == KILL_CONTROL || who == KILL_ALL)
1275 if (s->control_pid > 0)
1276 if (kill(s->control_pid, signo) < 0)
1279 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1282 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1285 /* Exclude the control pid from being killed via the cgroup */
1286 if (s->control_pid > 0)
1287 if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
1292 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
1294 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1305 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1306 [SWAP_DEAD] = "dead",
1307 [SWAP_ACTIVATING] = "activating",
1308 [SWAP_ACTIVE] = "active",
1309 [SWAP_DEACTIVATING] = "deactivating",
1310 [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1311 [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1312 [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1313 [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1314 [SWAP_FAILED] = "failed"
1317 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1319 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1320 [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1321 [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1324 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1326 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1327 [SWAP_SUCCESS] = "success",
1328 [SWAP_FAILURE_RESOURCES] = "resources",
1329 [SWAP_FAILURE_TIMEOUT] = "timeout",
1330 [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1331 [SWAP_FAILURE_SIGNAL] = "signal",
1332 [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1335 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1337 const UnitVTable swap_vtable = {
1338 .object_size = sizeof(Swap),
1345 .no_instances = true,
1351 .coldplug = swap_coldplug,
1355 .start = swap_start,
1360 .serialize = swap_serialize,
1361 .deserialize_item = swap_deserialize_item,
1363 .active_state = swap_active_state,
1364 .sub_state_to_string = swap_sub_state_to_string,
1366 .check_gc = swap_check_gc,
1368 .sigchld_event = swap_sigchld_event,
1369 .timer_event = swap_timer_event,
1371 .reset_failed = swap_reset_failed,
1373 .bus_interface = "org.freedesktop.systemd1.Swap",
1374 .bus_message_handler = bus_swap_message_handler,
1375 .bus_invalidating_properties = bus_swap_invalidating_properties,
1377 .following = swap_following,
1378 .following_set = swap_following_set,
1380 .enumerate = swap_enumerate,
1381 .shutdown = swap_shutdown,
1383 .status_message_formats = {
1384 .starting_stopping = {
1385 [0] = "Activating swap %s...",
1386 [1] = "Deactivating swap %s...",
1388 .finished_start_job = {
1389 [JOB_DONE] = "Activated swap %s.",
1390 [JOB_FAILED] = "Failed to activate swap %s.",
1391 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1392 [JOB_TIMEOUT] = "Timed out activating swap %s.",
1394 .finished_stop_job = {
1395 [JOB_DONE] = "Deactivated swap %s.",
1396 [JOB_FAILED] = "Failed deactivating swap %s.",
1397 [JOB_TIMEOUT] = "Timed out deactivating swap %s.",