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"
44 static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
45 [SWAP_DEAD] = UNIT_INACTIVE,
46 [SWAP_ACTIVATING] = UNIT_ACTIVATING,
47 [SWAP_ACTIVE] = UNIT_ACTIVE,
48 [SWAP_DEACTIVATING] = UNIT_DEACTIVATING,
49 [SWAP_ACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
50 [SWAP_ACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
51 [SWAP_DEACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
52 [SWAP_DEACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
53 [SWAP_FAILED] = UNIT_FAILED
56 static void swap_unset_proc_swaps(Swap *s) {
62 if (!s->parameters_proc_swaps.what)
65 /* Remove this unit from the chain of swaps which share the
66 * same kernel swap device. */
67 swaps = UNIT(s)->manager->swaps_by_proc_swaps;
68 first = hashmap_get(swaps, s->parameters_proc_swaps.what);
69 LIST_REMOVE(Swap, same_proc_swaps, first, s);
72 hashmap_remove_and_replace(swaps,
73 s->parameters_proc_swaps.what,
74 first->parameters_proc_swaps.what,
77 hashmap_remove(swaps, s->parameters_proc_swaps.what);
79 free(s->parameters_proc_swaps.what);
80 s->parameters_proc_swaps.what = NULL;
83 static void swap_init(Unit *u) {
87 assert(UNIT(s)->load_state == UNIT_STUB);
89 s->timeout_usec = DEFAULT_TIMEOUT_USEC;
91 exec_context_init(&s->exec_context);
92 s->exec_context.std_output = u->manager->default_std_output;
93 s->exec_context.std_error = u->manager->default_std_error;
94 kill_context_init(&s->kill_context);
96 s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
98 s->timer_watch.type = WATCH_INVALID;
100 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
102 UNIT(s)->ignore_on_isolate = true;
105 static void swap_unwatch_control_pid(Swap *s) {
108 if (s->control_pid <= 0)
111 unit_unwatch_pid(UNIT(s), s->control_pid);
115 static void swap_done(Unit *u) {
120 swap_unset_proc_swaps(s);
125 free(s->parameters_fragment.what);
126 s->parameters_fragment.what = NULL;
128 exec_context_done(&s->exec_context);
129 exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
130 s->control_command = NULL;
132 swap_unwatch_control_pid(s);
134 unit_unwatch_timer(u, &s->timer_watch);
137 int swap_add_one_mount_link(Swap *s, Mount *m) {
143 if (UNIT(s)->load_state != UNIT_LOADED ||
144 UNIT(m)->load_state != UNIT_LOADED)
147 if (is_device_path(s->what))
150 if (!path_startswith(s->what, m->where))
153 if ((r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true)) < 0)
159 static int swap_add_mount_links(Swap *s) {
165 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT])
166 if ((r = swap_add_one_mount_link(s, MOUNT(other))) < 0)
172 static int swap_add_device_links(Swap *s) {
180 if (s->from_fragment)
181 p = &s->parameters_fragment;
185 if (is_device_path(s->what))
186 return unit_add_node_link(UNIT(s), s->what,
187 !p->noauto && p->nofail &&
188 UNIT(s)->manager->running_as == SYSTEMD_SYSTEM);
190 /* File based swap devices need to be ordered after
191 * systemd-remount-fs.service, since they might need a
192 * writable file system. */
193 return unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_REMOUNT_FS_SERVICE, NULL, true);
196 static int swap_add_default_dependencies(Swap *s) {
201 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
204 if (detect_container(NULL) > 0)
207 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
214 static int swap_verify(Swap *s) {
216 char _cleanup_free_ *e = NULL;
218 if (UNIT(s)->load_state != UNIT_LOADED)
221 e = unit_name_from_path(s->what, ".swap");
225 b = unit_has_name(UNIT(s), e);
227 log_error("%s: Value of \"What\" and unit name do not match, not loading.\n", UNIT(s)->id);
231 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
232 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
239 static int swap_load(Unit *u) {
244 assert(u->load_state == UNIT_STUB);
246 /* Load a .swap file */
247 if ((r = unit_load_fragment_and_dropin_optional(u)) < 0)
250 if (u->load_state == UNIT_LOADED) {
251 if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
254 if (UNIT(s)->fragment_path)
255 s->from_fragment = true;
258 if (s->parameters_fragment.what)
259 s->what = strdup(s->parameters_fragment.what);
260 else if (s->parameters_proc_swaps.what)
261 s->what = strdup(s->parameters_proc_swaps.what);
263 s->what = unit_name_to_path(u->id);
269 path_kill_slashes(s->what);
271 if (!UNIT(s)->description)
272 if ((r = unit_set_description(u, s->what)) < 0)
275 if ((r = swap_add_device_links(s)) < 0)
278 if ((r = swap_add_mount_links(s)) < 0)
281 if ((r = unit_add_default_cgroups(u)) < 0)
284 if (UNIT(s)->default_dependencies)
285 if ((r = swap_add_default_dependencies(s)) < 0)
288 r = unit_exec_context_defaults(u, &s->exec_context);
293 return swap_verify(s);
296 static int swap_add_one(
299 const char *what_proc_swaps,
306 char _cleanup_free_ *e = NULL;
315 assert(what_proc_swaps);
317 e = unit_name_from_path(what, ".swap");
321 u = manager_get_unit(m, e);
324 SWAP(u)->from_proc_swaps &&
325 !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps))
331 u = unit_new(m, sizeof(Swap));
335 r = unit_add_name(u, e);
339 SWAP(u)->what = strdup(what);
340 if (!SWAP(u)->what) {
345 unit_add_to_load_queue(u);
349 p = &SWAP(u)->parameters_proc_swaps;
352 if (!(wp = strdup(what_proc_swaps))) {
357 if (!m->swaps_by_proc_swaps)
358 if (!(m->swaps_by_proc_swaps = hashmap_new(string_hash_func, string_compare_func))) {
366 first = hashmap_get(m->swaps_by_proc_swaps, wp);
367 LIST_PREPEND(Swap, same_proc_swaps, first, SWAP(u));
369 if ((r = hashmap_replace(m->swaps_by_proc_swaps, wp, first)) < 0)
374 SWAP(u)->is_active = true;
375 SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
378 SWAP(u)->from_proc_swaps = true;
380 p->priority = priority;
384 unit_add_to_dbus_queue(u);
389 log_warning("Failed to load swap unit: %s", strerror(-r));
399 static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) {
405 if (stat(device, &st) >= 0 && S_ISBLK(st.st_mode)) {
406 struct udev_device *d;
408 struct udev_list_entry *item = NULL, *first = NULL;
410 /* So this is a proper swap device. Create swap units
411 * for all names this swap device is known under */
413 if (!(d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev)))
416 dn = udev_device_get_devnode(d);
418 r = swap_add_one(m, dn, device, prio, false, false, set_flags);
420 /* Add additional units for all symlinks */
421 first = udev_device_get_devlinks_list_entry(d);
422 udev_list_entry_foreach(item, first) {
425 /* Don't bother with the /dev/block links */
426 p = udev_list_entry_get_name(item);
428 if (path_startswith(p, "/dev/block/"))
431 if (stat(p, &st) >= 0)
432 if ((!S_ISBLK(st.st_mode)) || st.st_rdev != udev_device_get_devnum(d))
435 k = swap_add_one(m, p, device, prio, false, false, set_flags);
440 udev_device_unref(d);
443 k = swap_add_one(m, device, device, prio, false, false, set_flags);
450 static void swap_set_state(Swap *s, SwapState state) {
455 old_state = s->state;
458 if (state != SWAP_ACTIVATING &&
459 state != SWAP_ACTIVATING_SIGTERM &&
460 state != SWAP_ACTIVATING_SIGKILL &&
461 state != SWAP_DEACTIVATING &&
462 state != SWAP_DEACTIVATING_SIGTERM &&
463 state != SWAP_DEACTIVATING_SIGKILL) {
464 unit_unwatch_timer(UNIT(s), &s->timer_watch);
465 swap_unwatch_control_pid(s);
466 s->control_command = NULL;
467 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
470 if (state != old_state)
471 log_debug("%s changed %s -> %s",
473 swap_state_to_string(old_state),
474 swap_state_to_string(state));
476 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
479 static int swap_coldplug(Unit *u) {
481 SwapState new_state = SWAP_DEAD;
485 assert(s->state == SWAP_DEAD);
487 if (s->deserialized_state != s->state)
488 new_state = s->deserialized_state;
489 else if (s->from_proc_swaps)
490 new_state = SWAP_ACTIVE;
492 if (new_state != s->state) {
494 if (new_state == SWAP_ACTIVATING ||
495 new_state == SWAP_ACTIVATING_SIGTERM ||
496 new_state == SWAP_ACTIVATING_SIGKILL ||
497 new_state == SWAP_DEACTIVATING ||
498 new_state == SWAP_DEACTIVATING_SIGTERM ||
499 new_state == SWAP_DEACTIVATING_SIGKILL) {
501 if (s->control_pid <= 0)
504 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
507 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
511 swap_set_state(s, new_state);
517 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
524 if (s->from_proc_swaps)
525 p = &s->parameters_proc_swaps;
526 else if (s->from_fragment)
527 p = &s->parameters_fragment;
535 "%sFrom /proc/swaps: %s\n"
536 "%sFrom fragment: %s\n",
537 prefix, swap_state_to_string(s->state),
538 prefix, swap_result_to_string(s->result),
540 prefix, yes_no(s->from_proc_swaps),
541 prefix, yes_no(s->from_fragment));
549 prefix, yes_no(p->noauto),
550 prefix, yes_no(p->nofail));
552 if (s->control_pid > 0)
554 "%sControl PID: %lu\n",
555 prefix, (unsigned long) s->control_pid);
557 exec_context_dump(&s->exec_context, f, prefix);
558 kill_context_dump(&s->kill_context, f, prefix);
561 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
569 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
572 if ((r = exec_spawn(c,
576 UNIT(s)->manager->environment,
580 UNIT(s)->manager->confirm_spawn,
581 UNIT(s)->cgroup_bondings,
582 UNIT(s)->cgroup_attributes,
589 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
590 /* FIXME: we need to do something here */
598 unit_unwatch_timer(UNIT(s), &s->timer_watch);
603 static void swap_enter_dead(Swap *s, SwapResult f) {
606 if (f != SWAP_SUCCESS)
609 swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
612 static void swap_enter_active(Swap *s, SwapResult f) {
615 if (f != SWAP_SUCCESS)
618 swap_set_state(s, SWAP_ACTIVE);
621 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
624 bool wait_for_exit = false;
628 if (f != SWAP_SUCCESS)
631 if (s->kill_context.kill_mode != KILL_NONE) {
632 int sig = (state == SWAP_ACTIVATING_SIGTERM ||
633 state == SWAP_DEACTIVATING_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
635 if (s->control_pid > 0) {
636 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
638 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
640 wait_for_exit = true;
643 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
645 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
650 /* Exclude the control pid from being killed via the cgroup */
651 if (s->control_pid > 0)
652 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
655 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
657 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
658 log_warning("Failed to kill control group: %s", strerror(-r));
660 wait_for_exit = true;
668 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
671 swap_set_state(s, state);
673 swap_enter_dead(s, SWAP_SUCCESS);
678 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
680 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
686 static void swap_enter_activating(Swap *s) {
691 s->control_command_id = SWAP_EXEC_ACTIVATE;
692 s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
694 if (s->from_fragment)
695 priority = s->parameters_fragment.priority;
702 snprintf(p, sizeof(p), "%i", priority);
705 r = exec_command_set(
713 r = exec_command_set(
722 swap_unwatch_control_pid(s);
724 if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
727 swap_set_state(s, SWAP_ACTIVATING);
732 log_warning("%s failed to run 'swapon' task: %s", UNIT(s)->id, strerror(-r));
733 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
736 static void swap_enter_deactivating(Swap *s) {
741 s->control_command_id = SWAP_EXEC_DEACTIVATE;
742 s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
744 if ((r = exec_command_set(
751 swap_unwatch_control_pid(s);
753 if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
756 swap_set_state(s, SWAP_DEACTIVATING);
761 log_warning("%s failed to run 'swapoff' task: %s", UNIT(s)->id, strerror(-r));
762 swap_enter_active(s, SWAP_FAILURE_RESOURCES);
765 static int swap_start(Unit *u) {
770 /* We cannot fulfill this request right now, try again later
773 if (s->state == SWAP_DEACTIVATING ||
774 s->state == SWAP_DEACTIVATING_SIGTERM ||
775 s->state == SWAP_DEACTIVATING_SIGKILL ||
776 s->state == SWAP_ACTIVATING_SIGTERM ||
777 s->state == SWAP_ACTIVATING_SIGKILL)
780 if (s->state == SWAP_ACTIVATING)
783 assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
785 if (detect_container(NULL) > 0)
788 s->result = SWAP_SUCCESS;
789 swap_enter_activating(s);
793 static int swap_stop(Unit *u) {
798 if (s->state == SWAP_DEACTIVATING ||
799 s->state == SWAP_DEACTIVATING_SIGTERM ||
800 s->state == SWAP_DEACTIVATING_SIGKILL ||
801 s->state == SWAP_ACTIVATING_SIGTERM ||
802 s->state == SWAP_ACTIVATING_SIGKILL)
805 assert(s->state == SWAP_ACTIVATING ||
806 s->state == SWAP_ACTIVE);
808 if (detect_container(NULL) > 0)
811 swap_enter_deactivating(s);
815 static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
822 unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
823 unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
825 if (s->control_pid > 0)
826 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
828 if (s->control_command_id >= 0)
829 unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
834 static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
840 if (streq(key, "state")) {
843 if ((state = swap_state_from_string(value)) < 0)
844 log_debug("Failed to parse state value %s", value);
846 s->deserialized_state = state;
847 } else if (streq(key, "result")) {
850 f = swap_result_from_string(value);
852 log_debug("Failed to parse result value %s", value);
853 else if (f != SWAP_SUCCESS)
855 } else if (streq(key, "control-pid")) {
858 if (parse_pid(value, &pid) < 0)
859 log_debug("Failed to parse control-pid value %s", value);
861 s->control_pid = pid;
863 } else if (streq(key, "control-command")) {
866 if ((id = swap_exec_command_from_string(value)) < 0)
867 log_debug("Failed to parse exec-command value %s", value);
869 s->control_command_id = id;
870 s->control_command = s->exec_command + id;
874 log_debug("Unknown serialization key '%s'", key);
879 static UnitActiveState swap_active_state(Unit *u) {
882 return state_translation_table[SWAP(u)->state];
885 static const char *swap_sub_state_to_string(Unit *u) {
888 return swap_state_to_string(SWAP(u)->state);
891 static bool swap_check_gc(Unit *u) {
896 return s->from_proc_swaps;
899 static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
906 if (pid != s->control_pid)
911 if (is_clean_exit(code, status, NULL))
913 else if (code == CLD_EXITED)
914 f = SWAP_FAILURE_EXIT_CODE;
915 else if (code == CLD_KILLED)
916 f = SWAP_FAILURE_SIGNAL;
917 else if (code == CLD_DUMPED)
918 f = SWAP_FAILURE_CORE_DUMP;
920 assert_not_reached("Unknown code");
922 if (f != SWAP_SUCCESS)
925 if (s->control_command) {
926 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
928 s->control_command = NULL;
929 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
932 log_full(f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
933 "%s swap process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
937 case SWAP_ACTIVATING:
938 case SWAP_ACTIVATING_SIGTERM:
939 case SWAP_ACTIVATING_SIGKILL:
941 if (f == SWAP_SUCCESS)
942 swap_enter_active(s, f);
944 swap_enter_dead(s, f);
947 case SWAP_DEACTIVATING:
948 case SWAP_DEACTIVATING_SIGKILL:
949 case SWAP_DEACTIVATING_SIGTERM:
951 if (f == SWAP_SUCCESS)
952 swap_enter_dead(s, f);
954 swap_enter_dead(s, f);
958 assert_not_reached("Uh, control process died at wrong time.");
961 /* Notify clients about changed exit status */
962 unit_add_to_dbus_queue(u);
964 /* Request a reload of /proc/swaps, so that following units
965 * can follow our state change */
966 u->manager->request_reload = true;
969 static void swap_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
973 assert(elapsed == 1);
974 assert(w == &s->timer_watch);
978 case SWAP_ACTIVATING:
979 log_warning("%s activation timed out. Stopping.", u->id);
980 swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
983 case SWAP_DEACTIVATING:
984 log_warning("%s deactivation timed out. Stopping.", u->id);
985 swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
988 case SWAP_ACTIVATING_SIGTERM:
989 if (s->kill_context.send_sigkill) {
990 log_warning("%s activation timed out. Killing.", u->id);
991 swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
993 log_warning("%s activation timed out. Skipping SIGKILL. Ignoring.", u->id);
994 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
998 case SWAP_DEACTIVATING_SIGTERM:
999 if (s->kill_context.send_sigkill) {
1000 log_warning("%s deactivation timed out. Killing.", u->id);
1001 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1003 log_warning("%s deactivation timed out. Skipping SIGKILL. Ignoring.", u->id);
1004 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1008 case SWAP_ACTIVATING_SIGKILL:
1009 case SWAP_DEACTIVATING_SIGKILL:
1010 log_warning("%s swap process still around after SIGKILL. Ignoring.", u->id);
1011 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1015 assert_not_reached("Timeout at wrong time.");
1019 static int swap_load_proc_swaps(Manager *m, bool set_flags) {
1025 rewind(m->proc_swaps);
1027 (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
1030 char *dev = NULL, *d;
1033 if ((k = fscanf(m->proc_swaps,
1034 "%ms " /* device/file */
1035 "%*s " /* type of swap */
1036 "%*s " /* swap size */
1038 "%i\n", /* priority */
1039 &dev, &prio)) != 2) {
1044 log_warning("Failed to parse /proc/swaps:%u.", i);
1055 k = swap_process_new_swap(m, d, prio, set_flags);
1065 int swap_dispatch_reload(Manager *m) {
1066 /* This function should go as soon as the kernel properly notifies us */
1068 if (_likely_(!m->request_reload))
1071 m->request_reload = false;
1073 return swap_fd_event(m, EPOLLPRI);
1076 int swap_fd_event(Manager *m, int events) {
1081 assert(events & EPOLLPRI);
1083 if ((r = swap_load_proc_swaps(m, true)) < 0) {
1084 log_error("Failed to reread /proc/swaps: %s", strerror(-r));
1086 /* Reset flags, just in case, for late calls */
1087 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1088 Swap *swap = SWAP(u);
1090 swap->is_active = swap->just_activated = false;
1096 manager_dispatch_load_queue(m);
1098 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1099 Swap *swap = SWAP(u);
1101 if (!swap->is_active) {
1102 /* This has just been deactivated */
1104 swap->from_proc_swaps = false;
1105 swap_unset_proc_swaps(swap);
1107 switch (swap->state) {
1110 swap_enter_dead(swap, SWAP_SUCCESS);
1114 swap_set_state(swap, swap->state);
1118 } else if (swap->just_activated) {
1120 /* New swap entry */
1122 switch (swap->state) {
1126 swap_enter_active(swap, SWAP_SUCCESS);
1130 /* Nothing really changed, but let's
1131 * issue an notification call
1132 * nonetheless, in case somebody is
1133 * waiting for this. */
1134 swap_set_state(swap, swap->state);
1139 /* Reset the flags for later calls */
1140 swap->is_active = swap->just_activated = false;
1146 static Unit *swap_following(Unit *u) {
1148 Swap *other, *first = NULL;
1152 if (streq_ptr(s->what, s->parameters_proc_swaps.what))
1155 /* Make everybody follow the unit that's named after the swap
1156 * device in the kernel */
1158 LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1159 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1162 LIST_FOREACH_BEFORE(same_proc_swaps, other, s) {
1163 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1172 static int swap_following_set(Unit *u, Set **_set) {
1181 if (LIST_JUST_US(same_proc_swaps, s)) {
1186 if (!(set = set_new(NULL, NULL)))
1189 LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1190 if ((r = set_put(set, other)) < 0)
1193 LIST_FOREACH_BEFORE(same_proc_swaps, other, s)
1194 if ((r = set_put(set, other)) < 0)
1205 static void swap_shutdown(Manager *m) {
1208 if (m->proc_swaps) {
1209 fclose(m->proc_swaps);
1210 m->proc_swaps = NULL;
1213 hashmap_free(m->swaps_by_proc_swaps);
1214 m->swaps_by_proc_swaps = NULL;
1217 static int swap_enumerate(Manager *m) {
1219 struct epoll_event ev;
1222 if (!m->proc_swaps) {
1223 if (!(m->proc_swaps = fopen("/proc/swaps", "re")))
1224 return (errno == ENOENT) ? 0 : -errno;
1226 m->swap_watch.type = WATCH_SWAP;
1227 m->swap_watch.fd = fileno(m->proc_swaps);
1230 ev.events = EPOLLPRI;
1231 ev.data.ptr = &m->swap_watch;
1233 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->swap_watch.fd, &ev) < 0)
1237 if ((r = swap_load_proc_swaps(m, false)) < 0)
1243 static void swap_reset_failed(Unit *u) {
1248 if (s->state == SWAP_FAILED)
1249 swap_set_state(s, SWAP_DEAD);
1251 s->result = SWAP_SUCCESS;
1254 static int swap_kill(Unit *u, KillWho who, int signo, DBusError *error) {
1257 Set *pid_set = NULL;
1261 if (who == KILL_MAIN) {
1262 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Swap units have no main processes");
1266 if (s->control_pid <= 0 && who == KILL_CONTROL) {
1267 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1271 if (who == KILL_CONTROL || who == KILL_ALL)
1272 if (s->control_pid > 0)
1273 if (kill(s->control_pid, signo) < 0)
1276 if (who == KILL_ALL) {
1279 pid_set = set_new(trivial_hash_func, trivial_compare_func);
1283 /* Exclude the control pid from being killed via the cgroup */
1284 if (s->control_pid > 0) {
1285 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
1292 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
1293 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1304 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1305 [SWAP_DEAD] = "dead",
1306 [SWAP_ACTIVATING] = "activating",
1307 [SWAP_ACTIVE] = "active",
1308 [SWAP_DEACTIVATING] = "deactivating",
1309 [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1310 [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1311 [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1312 [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1313 [SWAP_FAILED] = "failed"
1316 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1318 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1319 [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1320 [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1323 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1325 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1326 [SWAP_SUCCESS] = "success",
1327 [SWAP_FAILURE_RESOURCES] = "resources",
1328 [SWAP_FAILURE_TIMEOUT] = "timeout",
1329 [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1330 [SWAP_FAILURE_SIGNAL] = "signal",
1331 [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1334 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1336 const UnitVTable swap_vtable = {
1337 .object_size = sizeof(Swap),
1338 .exec_context_offset = offsetof(Swap, exec_context),
1346 .no_instances = true,
1352 .coldplug = swap_coldplug,
1356 .start = swap_start,
1361 .serialize = swap_serialize,
1362 .deserialize_item = swap_deserialize_item,
1364 .active_state = swap_active_state,
1365 .sub_state_to_string = swap_sub_state_to_string,
1367 .check_gc = swap_check_gc,
1369 .sigchld_event = swap_sigchld_event,
1370 .timer_event = swap_timer_event,
1372 .reset_failed = swap_reset_failed,
1374 .bus_interface = "org.freedesktop.systemd1.Swap",
1375 .bus_message_handler = bus_swap_message_handler,
1376 .bus_invalidating_properties = bus_swap_invalidating_properties,
1378 .following = swap_following,
1379 .following_set = swap_following_set,
1381 .enumerate = swap_enumerate,
1382 .shutdown = swap_shutdown,
1384 .status_message_formats = {
1385 .starting_stopping = {
1386 [0] = "Activating swap %s...",
1387 [1] = "Deactivating swap %s...",
1389 .finished_start_job = {
1390 [JOB_DONE] = "Activated swap %s.",
1391 [JOB_FAILED] = "Failed to activate swap %s.",
1392 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1393 [JOB_TIMEOUT] = "Timed out activating swap %s.",
1395 .finished_stop_job = {
1396 [JOB_DONE] = "Deactivated swap %s.",
1397 [JOB_FAILED] = "Failed deactivating swap %s.",
1398 [JOB_TIMEOUT] = "Timed out deactivating swap %s.",