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 r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
160 static int swap_add_mount_links(Swap *s) {
166 LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT])
167 if ((r = swap_add_one_mount_link(s, MOUNT(other))) < 0)
173 static int swap_add_device_links(Swap *s) {
181 if (s->from_fragment)
182 p = &s->parameters_fragment;
186 if (is_device_path(s->what))
187 return unit_add_node_link(UNIT(s), s->what,
188 !p->noauto && p->nofail &&
189 UNIT(s)->manager->running_as == SYSTEMD_SYSTEM);
191 /* File based swap devices need to be ordered after
192 * systemd-remount-fs.service, since they might need a
193 * writable file system. */
194 return unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_REMOUNT_FS_SERVICE, NULL, true);
197 static int swap_add_default_dependencies(Swap *s) {
202 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
205 if (detect_container(NULL) > 0)
208 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
215 static int swap_verify(Swap *s) {
217 char _cleanup_free_ *e = NULL;
219 if (UNIT(s)->load_state != UNIT_LOADED)
222 e = unit_name_from_path(s->what, ".swap");
226 b = unit_has_name(UNIT(s), e);
228 log_error_unit(UNIT(s)->id,
229 "%s: Value of \"What\" and unit name do not match, not loading.",
234 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
235 log_error_unit(UNIT(s)->id,
236 "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.",
244 static int swap_load(Unit *u) {
249 assert(u->load_state == UNIT_STUB);
251 /* Load a .swap file */
252 r = unit_load_fragment_and_dropin_optional(u);
256 if (u->load_state == UNIT_LOADED) {
257 r = unit_add_exec_dependencies(u, &s->exec_context);
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 r = swap_add_device_links(s);
286 r = swap_add_mount_links(s);
290 r = unit_add_default_cgroups(u);
294 if (UNIT(s)->default_dependencies) {
295 r = swap_add_default_dependencies(s);
300 r = unit_exec_context_defaults(u, &s->exec_context);
305 return swap_verify(s);
308 static int swap_add_one(
311 const char *what_proc_swaps,
318 char _cleanup_free_ *e = NULL;
327 assert(what_proc_swaps);
329 e = unit_name_from_path(what, ".swap");
333 u = manager_get_unit(m, e);
336 SWAP(u)->from_proc_swaps &&
337 !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps))
343 u = unit_new(m, sizeof(Swap));
347 r = unit_add_name(u, e);
351 SWAP(u)->what = strdup(what);
352 if (!SWAP(u)->what) {
357 unit_add_to_load_queue(u);
361 p = &SWAP(u)->parameters_proc_swaps;
364 wp = strdup(what_proc_swaps);
370 if (!m->swaps_by_proc_swaps) {
371 m->swaps_by_proc_swaps = hashmap_new(string_hash_func, string_compare_func);
372 if (!m->swaps_by_proc_swaps) {
381 first = hashmap_get(m->swaps_by_proc_swaps, wp);
382 LIST_PREPEND(Swap, same_proc_swaps, first, SWAP(u));
384 r = hashmap_replace(m->swaps_by_proc_swaps, wp, first);
390 SWAP(u)->is_active = true;
391 SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
394 SWAP(u)->from_proc_swaps = true;
396 p->priority = priority;
400 unit_add_to_dbus_queue(u);
405 log_warning_unit(e, "Failed to load swap unit: %s", strerror(-r));
415 static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) {
421 if (stat(device, &st) >= 0 && S_ISBLK(st.st_mode)) {
422 struct udev_device *d;
424 struct udev_list_entry *item = NULL, *first = NULL;
426 /* So this is a proper swap device. Create swap units
427 * for all names this swap device is known under */
429 d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev);
433 dn = udev_device_get_devnode(d);
434 /* Skip dn==device, since that case will be handled below */
435 if (dn && !streq(dn, device))
436 r = swap_add_one(m, dn, device, prio, false, false, set_flags);
438 /* Add additional units for all symlinks */
439 first = udev_device_get_devlinks_list_entry(d);
440 udev_list_entry_foreach(item, first) {
443 /* Don't bother with the /dev/block links */
444 p = udev_list_entry_get_name(item);
446 if (path_startswith(p, "/dev/block/"))
449 if (stat(p, &st) >= 0)
450 if ((!S_ISBLK(st.st_mode)) ||
451 st.st_rdev != udev_device_get_devnum(d))
454 k = swap_add_one(m, p, device, prio, false, false, set_flags);
459 udev_device_unref(d);
462 k = swap_add_one(m, device, device, prio, false, false, set_flags);
469 static void swap_set_state(Swap *s, SwapState state) {
474 old_state = s->state;
477 if (state != SWAP_ACTIVATING &&
478 state != SWAP_ACTIVATING_SIGTERM &&
479 state != SWAP_ACTIVATING_SIGKILL &&
480 state != SWAP_DEACTIVATING &&
481 state != SWAP_DEACTIVATING_SIGTERM &&
482 state != SWAP_DEACTIVATING_SIGKILL) {
483 unit_unwatch_timer(UNIT(s), &s->timer_watch);
484 swap_unwatch_control_pid(s);
485 s->control_command = NULL;
486 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
489 if (state != old_state)
490 log_debug_unit(UNIT(s)->id,
491 "%s changed %s -> %s",
493 swap_state_to_string(old_state),
494 swap_state_to_string(state));
496 unit_notify(UNIT(s), state_translation_table[old_state],
497 state_translation_table[state], true);
500 static int swap_coldplug(Unit *u) {
502 SwapState new_state = SWAP_DEAD;
506 assert(s->state == SWAP_DEAD);
508 if (s->deserialized_state != s->state)
509 new_state = s->deserialized_state;
510 else if (s->from_proc_swaps)
511 new_state = SWAP_ACTIVE;
513 if (new_state != s->state) {
515 if (new_state == SWAP_ACTIVATING ||
516 new_state == SWAP_ACTIVATING_SIGTERM ||
517 new_state == SWAP_ACTIVATING_SIGKILL ||
518 new_state == SWAP_DEACTIVATING ||
519 new_state == SWAP_DEACTIVATING_SIGTERM ||
520 new_state == SWAP_DEACTIVATING_SIGKILL) {
522 if (s->control_pid <= 0)
525 r = unit_watch_pid(UNIT(s), s->control_pid);
529 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
534 swap_set_state(s, new_state);
540 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
547 if (s->from_proc_swaps)
548 p = &s->parameters_proc_swaps;
549 else if (s->from_fragment)
550 p = &s->parameters_fragment;
558 "%sFrom /proc/swaps: %s\n"
559 "%sFrom fragment: %s\n",
560 prefix, swap_state_to_string(s->state),
561 prefix, swap_result_to_string(s->result),
563 prefix, yes_no(s->from_proc_swaps),
564 prefix, yes_no(s->from_fragment));
572 prefix, yes_no(p->noauto),
573 prefix, yes_no(p->nofail));
575 if (s->control_pid > 0)
577 "%sControl PID: %lu\n",
578 prefix, (unsigned long) s->control_pid);
580 exec_context_dump(&s->exec_context, f, prefix);
581 kill_context_dump(&s->kill_context, f, prefix);
584 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
592 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
600 UNIT(s)->manager->environment,
604 UNIT(s)->manager->confirm_spawn,
605 UNIT(s)->cgroup_bondings,
606 UNIT(s)->cgroup_attributes,
614 r = unit_watch_pid(UNIT(s), pid);
616 /* FIXME: we need to do something here */
624 unit_unwatch_timer(UNIT(s), &s->timer_watch);
629 static void swap_enter_dead(Swap *s, SwapResult f) {
632 if (f != SWAP_SUCCESS)
635 swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
638 static void swap_enter_active(Swap *s, SwapResult f) {
641 if (f != SWAP_SUCCESS)
644 swap_set_state(s, SWAP_ACTIVE);
647 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
650 bool wait_for_exit = false;
654 if (f != SWAP_SUCCESS)
657 if (s->kill_context.kill_mode != KILL_NONE) {
658 int sig = (state == SWAP_ACTIVATING_SIGTERM ||
659 state == SWAP_DEACTIVATING_SIGTERM) ? s->kill_context.kill_signal : SIGKILL;
661 if (s->control_pid > 0) {
662 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
664 log_warning_unit(UNIT(s)->id,
665 "Failed to kill control process %li: %m",
666 (long) s->control_pid);
668 wait_for_exit = true;
671 if (s->kill_context.kill_mode == KILL_CONTROL_GROUP) {
673 pid_set = set_new(trivial_hash_func, trivial_compare_func);
679 /* Exclude the control pid from being killed via the cgroup */
680 if (s->control_pid > 0) {
681 r = set_put(pid_set, LONG_TO_PTR(s->control_pid));
686 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
688 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
689 log_warning_unit(UNIT(s)->id,
690 "Failed to kill control group: %s", strerror(-r));
692 wait_for_exit = true;
700 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
704 swap_set_state(s, state);
706 swap_enter_dead(s, SWAP_SUCCESS);
711 log_warning_unit(UNIT(s)->id,
712 "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
714 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
720 static void swap_enter_activating(Swap *s) {
725 s->control_command_id = SWAP_EXEC_ACTIVATE;
726 s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
728 if (s->from_fragment)
729 priority = s->parameters_fragment.priority;
736 snprintf(p, sizeof(p), "%i", priority);
739 r = exec_command_set(
747 r = exec_command_set(
756 swap_unwatch_control_pid(s);
758 r = swap_spawn(s, s->control_command, &s->control_pid);
762 swap_set_state(s, SWAP_ACTIVATING);
767 log_warning_unit(UNIT(s)->id,
768 "%s failed to run 'swapon' task: %s",
769 UNIT(s)->id, strerror(-r));
770 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
773 static void swap_enter_deactivating(Swap *s) {
778 s->control_command_id = SWAP_EXEC_DEACTIVATE;
779 s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
781 r = exec_command_set(s->control_command,
788 swap_unwatch_control_pid(s);
790 r = swap_spawn(s, s->control_command, &s->control_pid);
794 swap_set_state(s, SWAP_DEACTIVATING);
799 log_warning_unit(UNIT(s)->id,
800 "%s failed to run 'swapoff' task: %s",
801 UNIT(s)->id, strerror(-r));
802 swap_enter_active(s, SWAP_FAILURE_RESOURCES);
805 static int swap_start(Unit *u) {
810 /* We cannot fulfill this request right now, try again later
813 if (s->state == SWAP_DEACTIVATING ||
814 s->state == SWAP_DEACTIVATING_SIGTERM ||
815 s->state == SWAP_DEACTIVATING_SIGKILL ||
816 s->state == SWAP_ACTIVATING_SIGTERM ||
817 s->state == SWAP_ACTIVATING_SIGKILL)
820 if (s->state == SWAP_ACTIVATING)
823 assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
825 if (detect_container(NULL) > 0)
828 s->result = SWAP_SUCCESS;
829 swap_enter_activating(s);
833 static int swap_stop(Unit *u) {
838 if (s->state == SWAP_DEACTIVATING ||
839 s->state == SWAP_DEACTIVATING_SIGTERM ||
840 s->state == SWAP_DEACTIVATING_SIGKILL ||
841 s->state == SWAP_ACTIVATING_SIGTERM ||
842 s->state == SWAP_ACTIVATING_SIGKILL)
845 assert(s->state == SWAP_ACTIVATING ||
846 s->state == SWAP_ACTIVE);
848 if (detect_container(NULL) > 0)
851 swap_enter_deactivating(s);
855 static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
862 unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
863 unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
865 if (s->control_pid > 0)
866 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
868 if (s->control_command_id >= 0)
869 unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
874 static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
880 if (streq(key, "state")) {
883 state = swap_state_from_string(value);
885 log_debug_unit(u->id, "Failed to parse state value %s", value);
887 s->deserialized_state = state;
888 } else if (streq(key, "result")) {
891 f = swap_result_from_string(value);
893 log_debug_unit(u->id, "Failed to parse result value %s", value);
894 else if (f != SWAP_SUCCESS)
896 } else if (streq(key, "control-pid")) {
899 if (parse_pid(value, &pid) < 0)
900 log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
902 s->control_pid = pid;
904 } else if (streq(key, "control-command")) {
907 id = swap_exec_command_from_string(value);
909 log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
911 s->control_command_id = id;
912 s->control_command = s->exec_command + id;
916 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
921 static UnitActiveState swap_active_state(Unit *u) {
924 return state_translation_table[SWAP(u)->state];
927 static const char *swap_sub_state_to_string(Unit *u) {
930 return swap_state_to_string(SWAP(u)->state);
933 static bool swap_check_gc(Unit *u) {
938 return s->from_proc_swaps;
941 static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
948 if (pid != s->control_pid)
953 if (is_clean_exit(code, status, NULL))
955 else if (code == CLD_EXITED)
956 f = SWAP_FAILURE_EXIT_CODE;
957 else if (code == CLD_KILLED)
958 f = SWAP_FAILURE_SIGNAL;
959 else if (code == CLD_DUMPED)
960 f = SWAP_FAILURE_CORE_DUMP;
962 assert_not_reached("Unknown code");
964 if (f != SWAP_SUCCESS)
967 if (s->control_command) {
968 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
970 s->control_command = NULL;
971 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
974 log_full_unit(f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
976 "%s swap process exited, code=%s status=%i",
977 u->id, sigchld_code_to_string(code), status);
981 case SWAP_ACTIVATING:
982 case SWAP_ACTIVATING_SIGTERM:
983 case SWAP_ACTIVATING_SIGKILL:
985 if (f == SWAP_SUCCESS)
986 swap_enter_active(s, f);
988 swap_enter_dead(s, f);
991 case SWAP_DEACTIVATING:
992 case SWAP_DEACTIVATING_SIGKILL:
993 case SWAP_DEACTIVATING_SIGTERM:
995 if (f == SWAP_SUCCESS)
996 swap_enter_dead(s, f);
998 swap_enter_dead(s, f);
1002 assert_not_reached("Uh, control process died at wrong time.");
1005 /* Notify clients about changed exit status */
1006 unit_add_to_dbus_queue(u);
1008 /* Request a reload of /proc/swaps, so that following units
1009 * can follow our state change */
1010 u->manager->request_reload = true;
1013 static void swap_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1017 assert(elapsed == 1);
1018 assert(w == &s->timer_watch);
1022 case SWAP_ACTIVATING:
1023 log_warning_unit(u->id, "%s activation timed out. Stopping.", u->id);
1024 swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1027 case SWAP_DEACTIVATING:
1028 log_warning_unit(u->id, "%s deactivation timed out. Stopping.", u->id);
1029 swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1032 case SWAP_ACTIVATING_SIGTERM:
1033 if (s->kill_context.send_sigkill) {
1034 log_warning_unit(u->id, "%s activation timed out. Killing.", u->id);
1035 swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1037 log_warning_unit(u->id, "%s activation timed out. Skipping SIGKILL. Ignoring.", u->id);
1038 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1042 case SWAP_DEACTIVATING_SIGTERM:
1043 if (s->kill_context.send_sigkill) {
1044 log_warning_unit(u->id, "%s deactivation timed out. Killing.", u->id);
1045 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1047 log_warning_unit(u->id, "%s deactivation timed out. Skipping SIGKILL. Ignoring.", u->id);
1048 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1052 case SWAP_ACTIVATING_SIGKILL:
1053 case SWAP_DEACTIVATING_SIGKILL:
1054 log_warning_unit(u->id, "%s swap process still around after SIGKILL. Ignoring.", u->id);
1055 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1059 assert_not_reached("Timeout at wrong time.");
1063 static int swap_load_proc_swaps(Manager *m, bool set_flags) {
1069 rewind(m->proc_swaps);
1071 (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
1074 char *dev = NULL, *d;
1077 k = fscanf(m->proc_swaps,
1078 "%ms " /* device/file */
1079 "%*s " /* type of swap */
1080 "%*s " /* swap size */
1082 "%i\n", /* priority */
1088 log_warning("Failed to parse /proc/swaps:%u", i);
1099 k = swap_process_new_swap(m, d, prio, set_flags);
1109 int swap_dispatch_reload(Manager *m) {
1110 /* This function should go as soon as the kernel properly notifies us */
1112 if (_likely_(!m->request_reload))
1115 m->request_reload = false;
1117 return swap_fd_event(m, EPOLLPRI);
1120 int swap_fd_event(Manager *m, int events) {
1125 assert(events & EPOLLPRI);
1127 r = swap_load_proc_swaps(m, true);
1129 log_error("Failed to reread /proc/swaps: %s", strerror(-r));
1131 /* Reset flags, just in case, for late calls */
1132 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1133 Swap *swap = SWAP(u);
1135 swap->is_active = swap->just_activated = false;
1141 manager_dispatch_load_queue(m);
1143 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1144 Swap *swap = SWAP(u);
1146 if (!swap->is_active) {
1147 /* This has just been deactivated */
1149 swap->from_proc_swaps = false;
1150 swap_unset_proc_swaps(swap);
1152 switch (swap->state) {
1155 swap_enter_dead(swap, SWAP_SUCCESS);
1159 swap_set_state(swap, swap->state);
1163 } else if (swap->just_activated) {
1165 /* New swap entry */
1167 switch (swap->state) {
1171 swap_enter_active(swap, SWAP_SUCCESS);
1175 /* Nothing really changed, but let's
1176 * issue an notification call
1177 * nonetheless, in case somebody is
1178 * waiting for this. */
1179 swap_set_state(swap, swap->state);
1184 /* Reset the flags for later calls */
1185 swap->is_active = swap->just_activated = false;
1191 static Unit *swap_following(Unit *u) {
1193 Swap *other, *first = NULL;
1197 if (streq_ptr(s->what, s->parameters_proc_swaps.what))
1200 /* Make everybody follow the unit that's named after the swap
1201 * device in the kernel */
1203 LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1204 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1207 LIST_FOREACH_BEFORE(same_proc_swaps, other, s) {
1208 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1217 static int swap_following_set(Unit *u, Set **_set) {
1226 if (LIST_JUST_US(same_proc_swaps, s)) {
1231 if (!(set = set_new(NULL, NULL)))
1234 LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1235 if ((r = set_put(set, other)) < 0)
1238 LIST_FOREACH_BEFORE(same_proc_swaps, other, s)
1239 if ((r = set_put(set, other)) < 0)
1250 static void swap_shutdown(Manager *m) {
1253 if (m->proc_swaps) {
1254 fclose(m->proc_swaps);
1255 m->proc_swaps = NULL;
1258 hashmap_free(m->swaps_by_proc_swaps);
1259 m->swaps_by_proc_swaps = NULL;
1262 static int swap_enumerate(Manager *m) {
1264 struct epoll_event ev;
1267 if (!m->proc_swaps) {
1268 m->proc_swaps = fopen("/proc/swaps", "re");
1270 return (errno == ENOENT) ? 0 : -errno;
1272 m->swap_watch.type = WATCH_SWAP;
1273 m->swap_watch.fd = fileno(m->proc_swaps);
1276 ev.events = EPOLLPRI;
1277 ev.data.ptr = &m->swap_watch;
1279 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->swap_watch.fd, &ev) < 0)
1283 r = swap_load_proc_swaps(m, false);
1290 static void swap_reset_failed(Unit *u) {
1295 if (s->state == SWAP_FAILED)
1296 swap_set_state(s, SWAP_DEAD);
1298 s->result = SWAP_SUCCESS;
1301 static int swap_kill(Unit *u, KillWho who, int signo, DBusError *error) {
1304 Set *pid_set = NULL;
1308 if (who == KILL_MAIN) {
1309 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Swap units have no main processes");
1313 if (s->control_pid <= 0 && who == KILL_CONTROL) {
1314 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1318 if (who == KILL_CONTROL || who == KILL_ALL)
1319 if (s->control_pid > 0)
1320 if (kill(s->control_pid, signo) < 0)
1323 if (who == KILL_ALL) {
1326 pid_set = set_new(trivial_hash_func, trivial_compare_func);
1330 /* Exclude the control pid from being killed via the cgroup */
1331 if (s->control_pid > 0) {
1332 q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
1339 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
1340 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1351 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1352 [SWAP_DEAD] = "dead",
1353 [SWAP_ACTIVATING] = "activating",
1354 [SWAP_ACTIVE] = "active",
1355 [SWAP_DEACTIVATING] = "deactivating",
1356 [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1357 [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1358 [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1359 [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1360 [SWAP_FAILED] = "failed"
1363 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1365 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1366 [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1367 [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1370 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1372 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1373 [SWAP_SUCCESS] = "success",
1374 [SWAP_FAILURE_RESOURCES] = "resources",
1375 [SWAP_FAILURE_TIMEOUT] = "timeout",
1376 [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1377 [SWAP_FAILURE_SIGNAL] = "signal",
1378 [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1381 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1383 const UnitVTable swap_vtable = {
1384 .object_size = sizeof(Swap),
1385 .exec_context_offset = offsetof(Swap, exec_context),
1393 .no_instances = true,
1399 .coldplug = swap_coldplug,
1403 .start = swap_start,
1408 .serialize = swap_serialize,
1409 .deserialize_item = swap_deserialize_item,
1411 .active_state = swap_active_state,
1412 .sub_state_to_string = swap_sub_state_to_string,
1414 .check_gc = swap_check_gc,
1416 .sigchld_event = swap_sigchld_event,
1417 .timer_event = swap_timer_event,
1419 .reset_failed = swap_reset_failed,
1421 .bus_interface = "org.freedesktop.systemd1.Swap",
1422 .bus_message_handler = bus_swap_message_handler,
1423 .bus_invalidating_properties = bus_swap_invalidating_properties,
1425 .following = swap_following,
1426 .following_set = swap_following_set,
1428 .enumerate = swap_enumerate,
1429 .shutdown = swap_shutdown,
1431 .status_message_formats = {
1432 .starting_stopping = {
1433 [0] = "Activating swap %s...",
1434 [1] = "Deactivating swap %s...",
1436 .finished_start_job = {
1437 [JOB_DONE] = "Activated swap %s.",
1438 [JOB_FAILED] = "Failed to activate swap %s.",
1439 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1440 [JOB_TIMEOUT] = "Timed out activating swap %s.",
1442 .finished_stop_job = {
1443 [JOB_DONE] = "Deactivated swap %s.",
1444 [JOB_FAILED] = "Failed deactivating swap %s.",
1445 [JOB_TIMEOUT] = "Timed out deactivating swap %s.",