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)
298 r = unit_patch_working_directory(UNIT(s), &s->exec_context);
303 return swap_verify(s);
306 static int swap_add_one(
309 const char *what_proc_swaps,
316 char *e = NULL, *wp = NULL;
324 assert(what_proc_swaps);
326 e = unit_name_from_path(what, ".swap");
330 u = manager_get_unit(m, e);
333 SWAP(u)->from_proc_swaps &&
334 !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps))
340 u = unit_new(m, sizeof(Swap));
346 r = unit_add_name(u, e);
350 SWAP(u)->what = strdup(what);
351 if (!SWAP(u)->what) {
356 unit_add_to_load_queue(u);
360 p = &SWAP(u)->parameters_proc_swaps;
363 if (!(wp = strdup(what_proc_swaps))) {
368 if (!m->swaps_by_proc_swaps)
369 if (!(m->swaps_by_proc_swaps = hashmap_new(string_hash_func, string_compare_func))) {
377 first = hashmap_get(m->swaps_by_proc_swaps, wp);
378 LIST_PREPEND(Swap, same_proc_swaps, first, SWAP(u));
380 if ((r = hashmap_replace(m->swaps_by_proc_swaps, wp, first)) < 0)
385 SWAP(u)->is_active = true;
386 SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
389 SWAP(u)->from_proc_swaps = true;
391 p->priority = priority;
395 unit_add_to_dbus_queue(u);
402 log_warning("Failed to load swap unit: %s", strerror(-r));
413 static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) {
419 if (stat(device, &st) >= 0 && S_ISBLK(st.st_mode)) {
420 struct udev_device *d;
422 struct udev_list_entry *item = NULL, *first = NULL;
424 /* So this is a proper swap device. Create swap units
425 * for all names this swap device is known under */
427 if (!(d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev)))
430 dn = udev_device_get_devnode(d);
432 r = swap_add_one(m, dn, device, prio, false, false, set_flags);
434 /* Add additional units for all symlinks */
435 first = udev_device_get_devlinks_list_entry(d);
436 udev_list_entry_foreach(item, first) {
439 /* Don't bother with the /dev/block links */
440 p = udev_list_entry_get_name(item);
442 if (path_startswith(p, "/dev/block/"))
445 if (stat(p, &st) >= 0)
446 if ((!S_ISBLK(st.st_mode)) || st.st_rdev != udev_device_get_devnum(d))
449 k = swap_add_one(m, p, device, prio, false, false, set_flags);
454 udev_device_unref(d);
457 k = swap_add_one(m, device, device, prio, false, false, set_flags);
464 static void swap_set_state(Swap *s, SwapState state) {
469 old_state = s->state;
472 if (state != SWAP_ACTIVATING &&
473 state != SWAP_ACTIVATING_SIGTERM &&
474 state != SWAP_ACTIVATING_SIGKILL &&
475 state != SWAP_DEACTIVATING &&
476 state != SWAP_DEACTIVATING_SIGTERM &&
477 state != SWAP_DEACTIVATING_SIGKILL) {
478 unit_unwatch_timer(UNIT(s), &s->timer_watch);
479 swap_unwatch_control_pid(s);
480 s->control_command = NULL;
481 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
484 if (state != old_state)
485 log_debug("%s changed %s -> %s",
487 swap_state_to_string(old_state),
488 swap_state_to_string(state));
490 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
493 static int swap_coldplug(Unit *u) {
495 SwapState new_state = SWAP_DEAD;
499 assert(s->state == SWAP_DEAD);
501 if (s->deserialized_state != s->state)
502 new_state = s->deserialized_state;
503 else if (s->from_proc_swaps)
504 new_state = SWAP_ACTIVE;
506 if (new_state != s->state) {
508 if (new_state == SWAP_ACTIVATING ||
509 new_state == SWAP_ACTIVATING_SIGTERM ||
510 new_state == SWAP_ACTIVATING_SIGKILL ||
511 new_state == SWAP_DEACTIVATING ||
512 new_state == SWAP_DEACTIVATING_SIGTERM ||
513 new_state == SWAP_DEACTIVATING_SIGKILL) {
515 if (s->control_pid <= 0)
518 if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
521 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
525 swap_set_state(s, new_state);
531 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
538 if (s->from_proc_swaps)
539 p = &s->parameters_proc_swaps;
540 else if (s->from_fragment)
541 p = &s->parameters_fragment;
549 "%sFrom /proc/swaps: %s\n"
550 "%sFrom fragment: %s\n",
551 prefix, swap_state_to_string(s->state),
552 prefix, swap_result_to_string(s->result),
554 prefix, yes_no(s->from_proc_swaps),
555 prefix, yes_no(s->from_fragment));
563 prefix, yes_no(p->noauto),
564 prefix, yes_no(p->nofail));
566 if (s->control_pid > 0)
568 "%sControl PID: %lu\n",
569 prefix, (unsigned long) s->control_pid);
571 exec_context_dump(&s->exec_context, f, prefix);
574 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
582 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
585 if ((r = exec_spawn(c,
589 UNIT(s)->manager->environment,
593 UNIT(s)->manager->confirm_spawn,
594 UNIT(s)->cgroup_bondings,
595 UNIT(s)->cgroup_attributes,
602 if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
603 /* FIXME: we need to do something here */
611 unit_unwatch_timer(UNIT(s), &s->timer_watch);
616 static void swap_enter_dead(Swap *s, SwapResult f) {
619 if (f != SWAP_SUCCESS)
622 swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
625 static void swap_enter_active(Swap *s, SwapResult f) {
628 if (f != SWAP_SUCCESS)
631 swap_set_state(s, SWAP_ACTIVE);
634 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
637 bool wait_for_exit = false;
641 if (f != SWAP_SUCCESS)
644 if (s->exec_context.kill_mode != KILL_NONE) {
645 int sig = (state == SWAP_ACTIVATING_SIGTERM ||
646 state == SWAP_DEACTIVATING_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
648 if (s->control_pid > 0) {
649 if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH)
651 log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
653 wait_for_exit = true;
656 if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
658 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
663 /* Exclude the control pid from being killed via the cgroup */
664 if (s->control_pid > 0)
665 if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
668 r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, false, pid_set, NULL);
670 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
671 log_warning("Failed to kill control group: %s", strerror(-r));
673 wait_for_exit = true;
681 if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
684 swap_set_state(s, state);
686 swap_enter_dead(s, SWAP_SUCCESS);
691 log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
693 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
699 static void swap_enter_activating(Swap *s) {
704 s->control_command_id = SWAP_EXEC_ACTIVATE;
705 s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
707 if (s->from_fragment)
708 priority = s->parameters_fragment.priority;
715 snprintf(p, sizeof(p), "%i", priority);
718 r = exec_command_set(
726 r = exec_command_set(
735 swap_unwatch_control_pid(s);
737 if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
740 swap_set_state(s, SWAP_ACTIVATING);
745 log_warning("%s failed to run 'swapon' task: %s", UNIT(s)->id, strerror(-r));
746 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
749 static void swap_enter_deactivating(Swap *s) {
754 s->control_command_id = SWAP_EXEC_DEACTIVATE;
755 s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
757 if ((r = exec_command_set(
764 swap_unwatch_control_pid(s);
766 if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
769 swap_set_state(s, SWAP_DEACTIVATING);
774 log_warning("%s failed to run 'swapoff' task: %s", UNIT(s)->id, strerror(-r));
775 swap_enter_active(s, SWAP_FAILURE_RESOURCES);
778 static int swap_start(Unit *u) {
783 /* We cannot fulfill this request right now, try again later
786 if (s->state == SWAP_DEACTIVATING ||
787 s->state == SWAP_DEACTIVATING_SIGTERM ||
788 s->state == SWAP_DEACTIVATING_SIGKILL ||
789 s->state == SWAP_ACTIVATING_SIGTERM ||
790 s->state == SWAP_ACTIVATING_SIGKILL)
793 if (s->state == SWAP_ACTIVATING)
796 assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
798 s->result = SWAP_SUCCESS;
799 swap_enter_activating(s);
803 static int swap_stop(Unit *u) {
808 if (s->state == SWAP_DEACTIVATING ||
809 s->state == SWAP_DEACTIVATING_SIGTERM ||
810 s->state == SWAP_DEACTIVATING_SIGKILL ||
811 s->state == SWAP_ACTIVATING_SIGTERM ||
812 s->state == SWAP_ACTIVATING_SIGKILL)
815 assert(s->state == SWAP_ACTIVATING ||
816 s->state == SWAP_ACTIVE);
818 swap_enter_deactivating(s);
822 static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
829 unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
830 unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
832 if (s->control_pid > 0)
833 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
835 if (s->control_command_id >= 0)
836 unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
841 static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
847 if (streq(key, "state")) {
850 if ((state = swap_state_from_string(value)) < 0)
851 log_debug("Failed to parse state value %s", value);
853 s->deserialized_state = state;
854 } else if (streq(key, "result")) {
857 f = swap_result_from_string(value);
859 log_debug("Failed to parse result value %s", value);
860 else if (f != SWAP_SUCCESS)
862 } else if (streq(key, "control-pid")) {
865 if (parse_pid(value, &pid) < 0)
866 log_debug("Failed to parse control-pid value %s", value);
868 s->control_pid = pid;
870 } else if (streq(key, "control-command")) {
873 if ((id = swap_exec_command_from_string(value)) < 0)
874 log_debug("Failed to parse exec-command value %s", value);
876 s->control_command_id = id;
877 s->control_command = s->exec_command + id;
881 log_debug("Unknown serialization key '%s'", key);
886 static UnitActiveState swap_active_state(Unit *u) {
889 return state_translation_table[SWAP(u)->state];
892 static const char *swap_sub_state_to_string(Unit *u) {
895 return swap_state_to_string(SWAP(u)->state);
898 static bool swap_check_gc(Unit *u) {
903 return s->from_proc_swaps;
906 static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
913 if (pid != s->control_pid)
918 if (is_clean_exit(code, status))
920 else if (code == CLD_EXITED)
921 f = SWAP_FAILURE_EXIT_CODE;
922 else if (code == CLD_KILLED)
923 f = SWAP_FAILURE_SIGNAL;
924 else if (code == CLD_DUMPED)
925 f = SWAP_FAILURE_CORE_DUMP;
927 assert_not_reached("Unknown code");
929 if (f != SWAP_SUCCESS)
932 if (s->control_command) {
933 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
935 s->control_command = NULL;
936 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
939 log_full(f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
940 "%s swap process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
944 case SWAP_ACTIVATING:
945 case SWAP_ACTIVATING_SIGTERM:
946 case SWAP_ACTIVATING_SIGKILL:
948 if (f == SWAP_SUCCESS)
949 swap_enter_active(s, f);
951 swap_enter_dead(s, f);
954 case SWAP_DEACTIVATING:
955 case SWAP_DEACTIVATING_SIGKILL:
956 case SWAP_DEACTIVATING_SIGTERM:
958 if (f == SWAP_SUCCESS)
959 swap_enter_dead(s, f);
961 swap_enter_dead(s, f);
965 assert_not_reached("Uh, control process died at wrong time.");
968 /* Notify clients about changed exit status */
969 unit_add_to_dbus_queue(u);
971 /* Request a reload of /proc/swaps, so that following units
972 * can follow our state change */
973 u->manager->request_reload = true;
976 static void swap_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
980 assert(elapsed == 1);
981 assert(w == &s->timer_watch);
985 case SWAP_ACTIVATING:
986 log_warning("%s activation timed out. Stopping.", u->id);
987 swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
990 case SWAP_DEACTIVATING:
991 log_warning("%s deactivation timed out. Stopping.", u->id);
992 swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
995 case SWAP_ACTIVATING_SIGTERM:
996 if (s->exec_context.send_sigkill) {
997 log_warning("%s activation timed out. Killing.", u->id);
998 swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1000 log_warning("%s activation timed out. Skipping SIGKILL. Ignoring.", u->id);
1001 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1005 case SWAP_DEACTIVATING_SIGTERM:
1006 if (s->exec_context.send_sigkill) {
1007 log_warning("%s deactivation timed out. Killing.", u->id);
1008 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1010 log_warning("%s deactivation timed out. Skipping SIGKILL. Ignoring.", u->id);
1011 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1015 case SWAP_ACTIVATING_SIGKILL:
1016 case SWAP_DEACTIVATING_SIGKILL:
1017 log_warning("%s swap process still around after SIGKILL. Ignoring.", u->id);
1018 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1022 assert_not_reached("Timeout at wrong time.");
1026 static int swap_load_proc_swaps(Manager *m, bool set_flags) {
1032 rewind(m->proc_swaps);
1034 (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
1037 char *dev = NULL, *d;
1040 if ((k = fscanf(m->proc_swaps,
1041 "%ms " /* device/file */
1042 "%*s " /* type of swap */
1043 "%*s " /* swap size */
1045 "%i\n", /* priority */
1046 &dev, &prio)) != 2) {
1051 log_warning("Failed to parse /proc/swaps:%u.", i);
1062 k = swap_process_new_swap(m, d, prio, set_flags);
1072 int swap_dispatch_reload(Manager *m) {
1073 /* This function should go as soon as the kernel properly notifies us */
1075 if (_likely_(!m->request_reload))
1078 m->request_reload = false;
1080 return swap_fd_event(m, EPOLLPRI);
1083 int swap_fd_event(Manager *m, int events) {
1088 assert(events & EPOLLPRI);
1090 if ((r = swap_load_proc_swaps(m, true)) < 0) {
1091 log_error("Failed to reread /proc/swaps: %s", strerror(-r));
1093 /* Reset flags, just in case, for late calls */
1094 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1095 Swap *swap = SWAP(u);
1097 swap->is_active = swap->just_activated = false;
1103 manager_dispatch_load_queue(m);
1105 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1106 Swap *swap = SWAP(u);
1108 if (!swap->is_active) {
1109 /* This has just been deactivated */
1111 swap->from_proc_swaps = false;
1112 swap_unset_proc_swaps(swap);
1114 switch (swap->state) {
1117 swap_enter_dead(swap, SWAP_SUCCESS);
1121 swap_set_state(swap, swap->state);
1125 } else if (swap->just_activated) {
1127 /* New swap entry */
1129 switch (swap->state) {
1133 swap_enter_active(swap, SWAP_SUCCESS);
1137 /* Nothing really changed, but let's
1138 * issue an notification call
1139 * nonetheless, in case somebody is
1140 * waiting for this. */
1141 swap_set_state(swap, swap->state);
1146 /* Reset the flags for later calls */
1147 swap->is_active = swap->just_activated = false;
1153 static Unit *swap_following(Unit *u) {
1155 Swap *other, *first = NULL;
1159 if (streq_ptr(s->what, s->parameters_proc_swaps.what))
1162 /* Make everybody follow the unit that's named after the swap
1163 * device in the kernel */
1165 LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1166 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1169 LIST_FOREACH_BEFORE(same_proc_swaps, other, s) {
1170 if (streq_ptr(other->what, other->parameters_proc_swaps.what))
1179 static int swap_following_set(Unit *u, Set **_set) {
1188 if (LIST_JUST_US(same_proc_swaps, s)) {
1193 if (!(set = set_new(NULL, NULL)))
1196 LIST_FOREACH_AFTER(same_proc_swaps, other, s)
1197 if ((r = set_put(set, other)) < 0)
1200 LIST_FOREACH_BEFORE(same_proc_swaps, other, s)
1201 if ((r = set_put(set, other)) < 0)
1212 static void swap_shutdown(Manager *m) {
1215 if (m->proc_swaps) {
1216 fclose(m->proc_swaps);
1217 m->proc_swaps = NULL;
1220 hashmap_free(m->swaps_by_proc_swaps);
1221 m->swaps_by_proc_swaps = NULL;
1224 static int swap_enumerate(Manager *m) {
1226 struct epoll_event ev;
1229 if (!m->proc_swaps) {
1230 if (!(m->proc_swaps = fopen("/proc/swaps", "re")))
1231 return (errno == ENOENT) ? 0 : -errno;
1233 m->swap_watch.type = WATCH_SWAP;
1234 m->swap_watch.fd = fileno(m->proc_swaps);
1237 ev.events = EPOLLPRI;
1238 ev.data.ptr = &m->swap_watch;
1240 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->swap_watch.fd, &ev) < 0)
1244 if ((r = swap_load_proc_swaps(m, false)) < 0)
1250 static void swap_reset_failed(Unit *u) {
1255 if (s->state == SWAP_FAILED)
1256 swap_set_state(s, SWAP_DEAD);
1258 s->result = SWAP_SUCCESS;
1261 static int swap_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1264 Set *pid_set = NULL;
1268 if (who == KILL_MAIN) {
1269 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Swap units have no main processes");
1273 if (s->control_pid <= 0 && who == KILL_CONTROL) {
1274 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1278 if (who == KILL_CONTROL || who == KILL_ALL)
1279 if (s->control_pid > 0)
1280 if (kill(s->control_pid, signo) < 0)
1283 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1286 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1289 /* Exclude the control pid from being killed via the cgroup */
1290 if (s->control_pid > 0)
1291 if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) {
1296 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
1298 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1309 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1310 [SWAP_DEAD] = "dead",
1311 [SWAP_ACTIVATING] = "activating",
1312 [SWAP_ACTIVE] = "active",
1313 [SWAP_DEACTIVATING] = "deactivating",
1314 [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1315 [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1316 [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1317 [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1318 [SWAP_FAILED] = "failed"
1321 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1323 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1324 [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1325 [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1328 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1330 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1331 [SWAP_SUCCESS] = "success",
1332 [SWAP_FAILURE_RESOURCES] = "resources",
1333 [SWAP_FAILURE_TIMEOUT] = "timeout",
1334 [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1335 [SWAP_FAILURE_SIGNAL] = "signal",
1336 [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1339 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1341 const UnitVTable swap_vtable = {
1342 .object_size = sizeof(Swap),
1349 .no_instances = true,
1355 .coldplug = swap_coldplug,
1359 .start = swap_start,
1364 .serialize = swap_serialize,
1365 .deserialize_item = swap_deserialize_item,
1367 .active_state = swap_active_state,
1368 .sub_state_to_string = swap_sub_state_to_string,
1370 .check_gc = swap_check_gc,
1372 .sigchld_event = swap_sigchld_event,
1373 .timer_event = swap_timer_event,
1375 .reset_failed = swap_reset_failed,
1377 .bus_interface = "org.freedesktop.systemd1.Swap",
1378 .bus_message_handler = bus_swap_message_handler,
1379 .bus_invalidating_properties = bus_swap_invalidating_properties,
1381 .following = swap_following,
1382 .following_set = swap_following_set,
1384 .enumerate = swap_enumerate,
1385 .shutdown = swap_shutdown,
1387 .status_message_formats = {
1388 .starting_stopping = {
1389 [0] = "Activating swap %s...",
1390 [1] = "Deactivating swap %s...",
1392 .finished_start_job = {
1393 [JOB_DONE] = "Activated swap %s.",
1394 [JOB_FAILED] = "Failed to activate swap %s.",
1395 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1396 [JOB_TIMEOUT] = "Timed out activating swap %s.",
1398 .finished_stop_job = {
1399 [JOB_DONE] = "Deactivated swap %s.",
1400 [JOB_FAILED] = "Failed deactivating swap %s.",
1401 [JOB_TIMEOUT] = "Timed out deactivating swap %s.",