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 #include "udev-util.h"
45 static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
46 [SWAP_DEAD] = UNIT_INACTIVE,
47 [SWAP_ACTIVATING] = UNIT_ACTIVATING,
48 [SWAP_ACTIVATING_DONE] = UNIT_ACTIVE,
49 [SWAP_ACTIVE] = UNIT_ACTIVE,
50 [SWAP_DEACTIVATING] = UNIT_DEACTIVATING,
51 [SWAP_ACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
52 [SWAP_ACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
53 [SWAP_DEACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
54 [SWAP_DEACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
55 [SWAP_FAILED] = UNIT_FAILED
58 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
59 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
61 static void swap_unset_proc_swaps(Swap *s) {
64 if (!s->from_proc_swaps)
67 free(s->parameters_proc_swaps.what);
68 s->parameters_proc_swaps.what = NULL;
70 s->from_proc_swaps = false;
73 static int swap_set_devnode(Swap *s, const char *devnode) {
80 r = hashmap_ensure_allocated(&UNIT(s)->manager->swaps_by_devnode, &string_hash_ops);
84 swaps = UNIT(s)->manager->swaps_by_devnode;
87 first = hashmap_get(swaps, s->devnode);
89 LIST_REMOVE(same_devnode, first, s);
91 hashmap_replace(swaps, first->devnode, first);
93 hashmap_remove(swaps, s->devnode);
100 s->devnode = strdup(devnode);
104 first = hashmap_get(swaps, s->devnode);
105 LIST_PREPEND(same_devnode, first, s);
107 return hashmap_replace(swaps, first->devnode, first);
113 static void swap_init(Unit *u) {
117 assert(UNIT(s)->load_state == UNIT_STUB);
119 s->timeout_usec = u->manager->default_timeout_start_usec;
121 s->exec_context.std_output = u->manager->default_std_output;
122 s->exec_context.std_error = u->manager->default_std_error;
124 s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
126 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
128 u->ignore_on_isolate = true;
131 static void swap_unwatch_control_pid(Swap *s) {
134 if (s->control_pid <= 0)
137 unit_unwatch_pid(UNIT(s), s->control_pid);
141 static void swap_done(Unit *u) {
146 swap_unset_proc_swaps(s);
147 swap_set_devnode(s, NULL);
152 free(s->parameters_fragment.what);
153 s->parameters_fragment.what = NULL;
155 free(s->parameters_fragment.options);
156 s->parameters_fragment.options = NULL;
158 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
159 exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
160 s->control_command = NULL;
162 swap_unwatch_control_pid(s);
164 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
167 static int swap_arm_timer(Swap *s) {
172 if (s->timeout_usec <= 0) {
173 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
177 if (s->timer_event_source) {
178 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
182 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
185 return sd_event_add_time(
186 UNIT(s)->manager->event,
187 &s->timer_event_source,
189 now(CLOCK_MONOTONIC) + s->timeout_usec, 0,
190 swap_dispatch_timer, s);
193 static int swap_add_device_links(Swap *s) {
199 if (!s->from_fragment)
202 if (is_device_path(s->what))
203 return unit_add_node_link(UNIT(s), s->what, UNIT(s)->manager->running_as == SYSTEMD_SYSTEM);
205 /* File based swap devices need to be ordered after
206 * systemd-remount-fs.service, since they might need a
207 * writable file system. */
208 return unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_REMOUNT_FS_SERVICE, NULL, true);
211 static int swap_add_default_dependencies(Swap *s) {
214 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
217 if (detect_container(NULL) > 0)
220 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
223 static int swap_verify(Swap *s) {
225 _cleanup_free_ char *e = NULL;
227 if (UNIT(s)->load_state != UNIT_LOADED)
230 e = unit_name_from_path(s->what, ".swap");
234 b = unit_has_name(UNIT(s), e);
236 log_unit_error(UNIT(s)->id, "%s: Value of \"What\" and unit name do not match, not loading.", UNIT(s)->id);
240 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
241 log_unit_error(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.", UNIT(s)->id);
248 static int swap_load_devnode(Swap *s) {
249 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
255 if (stat(s->what, &st) < 0 || !S_ISBLK(st.st_mode))
258 d = udev_device_new_from_devnum(UNIT(s)->manager->udev, 'b', st.st_rdev);
262 p = udev_device_get_devnode(d);
266 return swap_set_devnode(s, p);
269 static int swap_load(Unit *u) {
274 assert(u->load_state == UNIT_STUB);
276 /* Load a .swap file */
277 r = unit_load_fragment_and_dropin_optional(u);
281 if (u->load_state == UNIT_LOADED) {
283 if (UNIT(s)->fragment_path)
284 s->from_fragment = true;
287 if (s->parameters_fragment.what)
288 s->what = strdup(s->parameters_fragment.what);
289 else if (s->parameters_proc_swaps.what)
290 s->what = strdup(s->parameters_proc_swaps.what);
292 s->what = unit_name_to_path(u->id);
298 path_kill_slashes(s->what);
300 if (!UNIT(s)->description) {
301 r = unit_set_description(u, s->what);
306 r = unit_require_mounts_for(UNIT(s), s->what);
310 r = swap_add_device_links(s);
314 r = swap_load_devnode(s);
318 r = unit_patch_contexts(u);
322 r = unit_add_exec_dependencies(u, &s->exec_context);
326 r = unit_add_default_slice(u, &s->cgroup_context);
330 if (UNIT(s)->default_dependencies) {
331 r = swap_add_default_dependencies(s);
337 return swap_verify(s);
340 static int swap_add_one(
343 const char *what_proc_swaps,
347 _cleanup_free_ char *e = NULL;
355 assert(what_proc_swaps);
357 e = unit_name_from_path(what, ".swap");
361 u = manager_get_unit(m, e);
364 SWAP(u)->from_proc_swaps &&
365 !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps))
371 u = unit_new(m, sizeof(Swap));
375 r = unit_add_name(u, e);
379 SWAP(u)->what = strdup(what);
380 if (!SWAP(u)->what) {
385 unit_add_to_load_queue(u);
389 p = &SWAP(u)->parameters_proc_swaps;
392 p->what = strdup(what_proc_swaps);
400 SWAP(u)->is_active = true;
401 SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
404 SWAP(u)->from_proc_swaps = true;
406 p->priority = priority;
408 unit_add_to_dbus_queue(u);
413 log_unit_warning_errno(e, r, "Failed to load swap unit: %m");
421 static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) {
422 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
423 struct udev_list_entry *item = NULL, *first = NULL;
430 r = swap_add_one(m, device, device, prio, set_flags);
434 /* If this is a block device, then let's add duplicates for
435 * all other names of this block device */
436 if (stat(device, &st) < 0 || !S_ISBLK(st.st_mode))
439 d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev);
443 /* Add the main device node */
444 dn = udev_device_get_devnode(d);
445 if (dn && !streq(dn, device))
446 swap_add_one(m, dn, device, prio, set_flags);
448 /* Add additional units for all symlinks */
449 first = udev_device_get_devlinks_list_entry(d);
450 udev_list_entry_foreach(item, first) {
453 /* Don't bother with the /dev/block links */
454 p = udev_list_entry_get_name(item);
456 if (streq(p, device))
459 if (path_startswith(p, "/dev/block/"))
462 if (stat(p, &st) >= 0)
463 if (!S_ISBLK(st.st_mode) ||
464 st.st_rdev != udev_device_get_devnum(d))
467 swap_add_one(m, p, device, prio, set_flags);
473 static void swap_set_state(Swap *s, SwapState state) {
478 old_state = s->state;
481 if (state != SWAP_ACTIVATING &&
482 state != SWAP_ACTIVATING_SIGTERM &&
483 state != SWAP_ACTIVATING_SIGKILL &&
484 state != SWAP_ACTIVATING_DONE &&
485 state != SWAP_DEACTIVATING &&
486 state != SWAP_DEACTIVATING_SIGTERM &&
487 state != SWAP_DEACTIVATING_SIGKILL) {
488 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
489 swap_unwatch_control_pid(s);
490 s->control_command = NULL;
491 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
494 if (state != old_state)
495 log_unit_debug(UNIT(s)->id,
496 "%s changed %s -> %s",
498 swap_state_to_string(old_state),
499 swap_state_to_string(state));
501 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
504 static int swap_coldplug(Unit *u) {
506 SwapState new_state = SWAP_DEAD;
510 assert(s->state == SWAP_DEAD);
512 if (s->deserialized_state != s->state)
513 new_state = s->deserialized_state;
514 else if (s->from_proc_swaps)
515 new_state = SWAP_ACTIVE;
517 if (new_state == s->state)
520 if (new_state == SWAP_ACTIVATING ||
521 new_state == SWAP_ACTIVATING_SIGTERM ||
522 new_state == SWAP_ACTIVATING_SIGKILL ||
523 new_state == SWAP_ACTIVATING_DONE ||
524 new_state == SWAP_DEACTIVATING ||
525 new_state == SWAP_DEACTIVATING_SIGTERM ||
526 new_state == SWAP_DEACTIVATING_SIGKILL) {
528 if (s->control_pid <= 0)
531 r = unit_watch_pid(UNIT(s), s->control_pid);
535 r = swap_arm_timer(s);
540 swap_set_state(s, new_state);
544 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
551 if (s->from_proc_swaps)
552 p = &s->parameters_proc_swaps;
553 else if (s->from_fragment)
554 p = &s->parameters_fragment;
562 "%sFrom /proc/swaps: %s\n"
563 "%sFrom fragment: %s\n",
564 prefix, swap_state_to_string(s->state),
565 prefix, swap_result_to_string(s->result),
567 prefix, yes_no(s->from_proc_swaps),
568 prefix, yes_no(s->from_fragment));
571 fprintf(f, "%sDevice Node: %s\n", prefix, s->devnode);
578 prefix, strempty(p->options));
580 if (s->control_pid > 0)
582 "%sControl PID: "PID_FMT"\n",
583 prefix, s->control_pid);
585 exec_context_dump(&s->exec_context, f, prefix);
586 kill_context_dump(&s->kill_context, f, prefix);
589 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
592 ExecParameters exec_params = {
593 .apply_permissions = true,
594 .apply_chroot = true,
595 .apply_tty_stdin = true,
602 unit_realize_cgroup(UNIT(s));
604 r = unit_setup_exec_runtime(UNIT(s));
608 r = swap_arm_timer(s);
612 exec_params.environment = UNIT(s)->manager->environment;
613 exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn;
614 exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported;
615 exec_params.cgroup_path = UNIT(s)->cgroup_path;
616 exec_params.cgroup_delegate = s->cgroup_context.delegate;
617 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager);
618 exec_params.unit_id = UNIT(s)->id;
628 r = unit_watch_pid(UNIT(s), pid);
630 /* FIXME: we need to do something here */
638 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
643 static void swap_enter_dead(Swap *s, SwapResult f) {
646 if (f != SWAP_SUCCESS)
649 exec_runtime_destroy(s->exec_runtime);
650 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
652 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
654 swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
657 static void swap_enter_active(Swap *s, SwapResult f) {
660 if (f != SWAP_SUCCESS)
663 swap_set_state(s, SWAP_ACTIVE);
666 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
671 if (f != SWAP_SUCCESS)
674 r = unit_kill_context(
677 (state != SWAP_ACTIVATING_SIGTERM && state != SWAP_DEACTIVATING_SIGTERM) ?
678 KILL_KILL : KILL_TERMINATE,
686 r = swap_arm_timer(s);
690 swap_set_state(s, state);
691 } else if (state == SWAP_ACTIVATING_SIGTERM)
692 swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_SUCCESS);
693 else if (state == SWAP_DEACTIVATING_SIGTERM)
694 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_SUCCESS);
696 swap_enter_dead(s, SWAP_SUCCESS);
701 log_unit_warning(UNIT(s)->id,
702 "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
704 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
707 static int mount_find_pri(const char *options, int *ret) {
717 opt = mount_test_option(options, "pri");
721 opt += strlen("pri");
726 r = strtoul(opt + 1, &end, 10);
730 if (end == opt + 1 || (*end != ',' && *end != 0))
737 static int mount_find_discard(const char *options, char **ret) {
747 opt = mount_test_option(options, "discard");
751 opt += strlen("discard");
752 if (*opt == ',' || *opt == '\0')
758 len = strcspn(opt + 1, ",");
762 ans = strndup(opt + 1, len);
772 static void swap_enter_activating(Swap *s) {
773 _cleanup_free_ char *discard = NULL;
774 int r, priority = -1;
778 s->control_command_id = SWAP_EXEC_ACTIVATE;
779 s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
781 if (s->from_fragment) {
782 mount_find_discard(s->parameters_fragment.options, &discard);
784 priority = s->parameters_fragment.priority;
786 mount_find_pri(s->parameters_fragment.options, &priority);
789 r = exec_command_set(s->control_command, "/sbin/swapon", NULL);
794 char p[DECIMAL_STR_MAX(int)];
796 sprintf(p, "%i", priority);
797 r = exec_command_append(s->control_command, "-p", p, NULL);
802 if (discard && !streq(discard, "none")) {
803 const char *discard_arg;
805 if (streq(discard, "all"))
806 discard_arg = "--discard";
808 discard_arg = strappenda("--discard=", discard);
810 r = exec_command_append(s->control_command, discard_arg, NULL);
815 r = exec_command_append(s->control_command, s->what, NULL);
819 swap_unwatch_control_pid(s);
821 r = swap_spawn(s, s->control_command, &s->control_pid);
825 swap_set_state(s, SWAP_ACTIVATING);
830 log_unit_warning(UNIT(s)->id,
831 "%s failed to run 'swapon' task: %s",
832 UNIT(s)->id, strerror(-r));
833 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
836 static void swap_enter_deactivating(Swap *s) {
841 s->control_command_id = SWAP_EXEC_DEACTIVATE;
842 s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
844 r = exec_command_set(s->control_command,
851 swap_unwatch_control_pid(s);
853 r = swap_spawn(s, s->control_command, &s->control_pid);
857 swap_set_state(s, SWAP_DEACTIVATING);
862 log_unit_warning(UNIT(s)->id,
863 "%s failed to run 'swapoff' task: %s",
864 UNIT(s)->id, strerror(-r));
865 swap_enter_active(s, SWAP_FAILURE_RESOURCES);
868 static int swap_start(Unit *u) {
873 /* We cannot fulfill this request right now, try again later
876 if (s->state == SWAP_DEACTIVATING ||
877 s->state == SWAP_DEACTIVATING_SIGTERM ||
878 s->state == SWAP_DEACTIVATING_SIGKILL ||
879 s->state == SWAP_ACTIVATING_SIGTERM ||
880 s->state == SWAP_ACTIVATING_SIGKILL)
883 if (s->state == SWAP_ACTIVATING)
886 assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
888 if (detect_container(NULL) > 0)
891 s->result = SWAP_SUCCESS;
892 swap_enter_activating(s);
896 static int swap_stop(Unit *u) {
901 if (s->state == SWAP_DEACTIVATING ||
902 s->state == SWAP_DEACTIVATING_SIGTERM ||
903 s->state == SWAP_DEACTIVATING_SIGKILL ||
904 s->state == SWAP_ACTIVATING_SIGTERM ||
905 s->state == SWAP_ACTIVATING_SIGKILL)
908 assert(s->state == SWAP_ACTIVATING ||
909 s->state == SWAP_ACTIVATING_DONE ||
910 s->state == SWAP_ACTIVE);
912 if (detect_container(NULL) > 0)
915 swap_enter_deactivating(s);
919 static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
926 unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
927 unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
929 if (s->control_pid > 0)
930 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
932 if (s->control_command_id >= 0)
933 unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
938 static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
944 if (streq(key, "state")) {
947 state = swap_state_from_string(value);
949 log_unit_debug(u->id, "Failed to parse state value %s", value);
951 s->deserialized_state = state;
952 } else if (streq(key, "result")) {
955 f = swap_result_from_string(value);
957 log_unit_debug(u->id, "Failed to parse result value %s", value);
958 else if (f != SWAP_SUCCESS)
960 } else if (streq(key, "control-pid")) {
963 if (parse_pid(value, &pid) < 0)
964 log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
966 s->control_pid = pid;
968 } else if (streq(key, "control-command")) {
971 id = swap_exec_command_from_string(value);
973 log_unit_debug(u->id, "Failed to parse exec-command value %s", value);
975 s->control_command_id = id;
976 s->control_command = s->exec_command + id;
979 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
984 _pure_ static UnitActiveState swap_active_state(Unit *u) {
987 return state_translation_table[SWAP(u)->state];
990 _pure_ static const char *swap_sub_state_to_string(Unit *u) {
993 return swap_state_to_string(SWAP(u)->state);
996 _pure_ static bool swap_check_gc(Unit *u) {
1001 return s->from_proc_swaps;
1004 static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1011 if (pid != s->control_pid)
1016 if (is_clean_exit(code, status, NULL))
1018 else if (code == CLD_EXITED)
1019 f = SWAP_FAILURE_EXIT_CODE;
1020 else if (code == CLD_KILLED)
1021 f = SWAP_FAILURE_SIGNAL;
1022 else if (code == CLD_DUMPED)
1023 f = SWAP_FAILURE_CORE_DUMP;
1025 assert_not_reached("Unknown code");
1027 if (f != SWAP_SUCCESS)
1030 if (s->control_command) {
1031 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1033 s->control_command = NULL;
1034 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
1037 log_unit_full(u->id,
1038 f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1039 "%s swap process exited, code=%s status=%i",
1040 u->id, sigchld_code_to_string(code), status);
1044 case SWAP_ACTIVATING:
1045 case SWAP_ACTIVATING_DONE:
1046 case SWAP_ACTIVATING_SIGTERM:
1047 case SWAP_ACTIVATING_SIGKILL:
1049 if (f == SWAP_SUCCESS)
1050 swap_enter_active(s, f);
1052 swap_enter_dead(s, f);
1055 case SWAP_DEACTIVATING:
1056 case SWAP_DEACTIVATING_SIGKILL:
1057 case SWAP_DEACTIVATING_SIGTERM:
1059 swap_enter_dead(s, f);
1063 assert_not_reached("Uh, control process died at wrong time.");
1066 /* Notify clients about changed exit status */
1067 unit_add_to_dbus_queue(u);
1070 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1071 Swap *s = SWAP(userdata);
1074 assert(s->timer_event_source == source);
1078 case SWAP_ACTIVATING:
1079 case SWAP_ACTIVATING_DONE:
1080 log_unit_warning(UNIT(s)->id, "%s activation timed out. Stopping.", UNIT(s)->id);
1081 swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1084 case SWAP_DEACTIVATING:
1085 log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Stopping.", UNIT(s)->id);
1086 swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1089 case SWAP_ACTIVATING_SIGTERM:
1090 if (s->kill_context.send_sigkill) {
1091 log_unit_warning(UNIT(s)->id, "%s activation timed out. Killing.", UNIT(s)->id);
1092 swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1094 log_unit_warning(UNIT(s)->id, "%s activation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1095 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1099 case SWAP_DEACTIVATING_SIGTERM:
1100 if (s->kill_context.send_sigkill) {
1101 log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Killing.", UNIT(s)->id);
1102 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1104 log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1105 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1109 case SWAP_ACTIVATING_SIGKILL:
1110 case SWAP_DEACTIVATING_SIGKILL:
1111 log_unit_warning(UNIT(s)->id, "%s swap process still around after SIGKILL. Ignoring.", UNIT(s)->id);
1112 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1116 assert_not_reached("Timeout at wrong time.");
1122 static int swap_load_proc_swaps(Manager *m, bool set_flags) {
1128 rewind(m->proc_swaps);
1130 (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
1133 _cleanup_free_ char *dev = NULL, *d = NULL;
1136 k = fscanf(m->proc_swaps,
1137 "%ms " /* device/file */
1138 "%*s " /* type of swap */
1139 "%*s " /* swap size */
1141 "%i\n", /* priority */
1147 log_warning("Failed to parse /proc/swaps:%u", i);
1155 k = swap_process_new_swap(m, d, prio, set_flags);
1163 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1164 Manager *m = userdata;
1169 assert(revents & EPOLLPRI);
1171 r = swap_load_proc_swaps(m, true);
1173 log_error_errno(r, "Failed to reread /proc/swaps: %m");
1175 /* Reset flags, just in case, for late calls */
1176 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1177 Swap *swap = SWAP(u);
1179 swap->is_active = swap->just_activated = false;
1185 manager_dispatch_load_queue(m);
1187 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1188 Swap *swap = SWAP(u);
1190 if (!swap->is_active) {
1191 /* This has just been deactivated */
1193 swap_unset_proc_swaps(swap);
1195 switch (swap->state) {
1198 swap_enter_dead(swap, SWAP_SUCCESS);
1203 swap_set_state(swap, swap->state);
1207 } else if (swap->just_activated) {
1209 /* New swap entry */
1211 switch (swap->state) {
1215 swap_enter_active(swap, SWAP_SUCCESS);
1218 case SWAP_ACTIVATING:
1219 swap_set_state(swap, SWAP_ACTIVATING_DONE);
1223 /* Nothing really changed, but let's
1224 * issue an notification call
1225 * nonetheless, in case somebody is
1226 * waiting for this. */
1227 swap_set_state(swap, swap->state);
1232 /* Reset the flags for later calls */
1233 swap->is_active = swap->just_activated = false;
1239 static Unit *swap_following(Unit *u) {
1241 Swap *other, *first = NULL;
1245 /* If the user configured the swap through /etc/fstab or
1246 * a device unit, follow that. */
1248 if (s->from_fragment)
1251 LIST_FOREACH_AFTER(same_devnode, other, s)
1252 if (other->from_fragment)
1255 LIST_FOREACH_BEFORE(same_devnode, other, s)
1256 if (other->from_fragment)
1259 /* Otherwise make everybody follow the unit that's named after
1260 * the swap device in the kernel */
1262 if (streq_ptr(s->what, s->devnode))
1265 LIST_FOREACH_AFTER(same_devnode, other, s)
1266 if (streq_ptr(other->what, other->devnode))
1269 LIST_FOREACH_BEFORE(same_devnode, other, s) {
1270 if (streq_ptr(other->what, other->devnode))
1276 /* Fall back to the first on the list */
1280 static int swap_following_set(Unit *u, Set **_set) {
1281 Swap *s = SWAP(u), *other;
1288 if (LIST_JUST_US(same_devnode, s)) {
1293 set = set_new(NULL);
1297 LIST_FOREACH_AFTER(same_devnode, other, s) {
1298 r = set_put(set, other);
1303 LIST_FOREACH_BEFORE(same_devnode, other, s) {
1304 r = set_put(set, other);
1317 static void swap_shutdown(Manager *m) {
1320 m->swap_event_source = sd_event_source_unref(m->swap_event_source);
1322 if (m->proc_swaps) {
1323 fclose(m->proc_swaps);
1324 m->proc_swaps = NULL;
1327 hashmap_free(m->swaps_by_devnode);
1328 m->swaps_by_devnode = NULL;
1331 static int swap_enumerate(Manager *m) {
1336 if (!m->proc_swaps) {
1337 m->proc_swaps = fopen("/proc/swaps", "re");
1339 return errno == ENOENT ? 0 : -errno;
1341 r = sd_event_add_io(m->event, &m->swap_event_source, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m);
1345 /* Dispatch this before we dispatch SIGCHLD, so that
1346 * we always get the events from /proc/swaps before
1347 * the SIGCHLD of /sbin/swapon. */
1348 r = sd_event_source_set_priority(m->swap_event_source, -10);
1353 r = swap_load_proc_swaps(m, false);
1364 int swap_process_new_device(Manager *m, struct udev_device *dev) {
1365 struct udev_list_entry *item = NULL, *first = NULL;
1366 _cleanup_free_ char *e = NULL;
1374 dn = udev_device_get_devnode(dev);
1378 e = unit_name_from_path(dn, ".swap");
1382 s = hashmap_get(m->units, e);
1384 r = swap_set_devnode(s, dn);
1386 first = udev_device_get_devlinks_list_entry(dev);
1387 udev_list_entry_foreach(item, first) {
1388 _cleanup_free_ char *n = NULL;
1390 n = unit_name_from_path(udev_list_entry_get_name(item), ".swap");
1394 s = hashmap_get(m->units, n);
1398 q = swap_set_devnode(s, dn);
1407 int swap_process_removed_device(Manager *m, struct udev_device *dev) {
1412 dn = udev_device_get_devnode(dev);
1416 while ((s = hashmap_get(m->swaps_by_devnode, dn))) {
1419 q = swap_set_devnode(s, NULL);
1427 static void swap_reset_failed(Unit *u) {
1432 if (s->state == SWAP_FAILED)
1433 swap_set_state(s, SWAP_DEAD);
1435 s->result = SWAP_SUCCESS;
1438 static int swap_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1439 return unit_kill_common(u, who, signo, -1, SWAP(u)->control_pid, error);
1442 static int swap_get_timeout(Unit *u, uint64_t *timeout) {
1446 if (!s->timer_event_source)
1449 r = sd_event_source_get_time(s->timer_event_source, timeout);
1456 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1457 [SWAP_DEAD] = "dead",
1458 [SWAP_ACTIVATING] = "activating",
1459 [SWAP_ACTIVATING_DONE] = "activating-done",
1460 [SWAP_ACTIVE] = "active",
1461 [SWAP_DEACTIVATING] = "deactivating",
1462 [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1463 [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1464 [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1465 [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1466 [SWAP_FAILED] = "failed"
1469 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1471 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1472 [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1473 [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1476 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1478 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1479 [SWAP_SUCCESS] = "success",
1480 [SWAP_FAILURE_RESOURCES] = "resources",
1481 [SWAP_FAILURE_TIMEOUT] = "timeout",
1482 [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1483 [SWAP_FAILURE_SIGNAL] = "signal",
1484 [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1487 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1489 const UnitVTable swap_vtable = {
1490 .object_size = sizeof(Swap),
1491 .exec_context_offset = offsetof(Swap, exec_context),
1492 .cgroup_context_offset = offsetof(Swap, cgroup_context),
1493 .kill_context_offset = offsetof(Swap, kill_context),
1494 .exec_runtime_offset = offsetof(Swap, exec_runtime),
1500 .private_section = "Swap",
1503 .no_instances = true,
1509 .coldplug = swap_coldplug,
1513 .start = swap_start,
1518 .get_timeout = swap_get_timeout,
1520 .serialize = swap_serialize,
1521 .deserialize_item = swap_deserialize_item,
1523 .active_state = swap_active_state,
1524 .sub_state_to_string = swap_sub_state_to_string,
1526 .check_gc = swap_check_gc,
1528 .sigchld_event = swap_sigchld_event,
1530 .reset_failed = swap_reset_failed,
1532 .bus_interface = "org.freedesktop.systemd1.Swap",
1533 .bus_vtable = bus_swap_vtable,
1534 .bus_set_property = bus_swap_set_property,
1535 .bus_commit_properties = bus_swap_commit_properties,
1537 .following = swap_following,
1538 .following_set = swap_following_set,
1540 .enumerate = swap_enumerate,
1541 .shutdown = swap_shutdown,
1543 .status_message_formats = {
1544 .starting_stopping = {
1545 [0] = "Activating swap %s...",
1546 [1] = "Deactivating swap %s...",
1548 .finished_start_job = {
1549 [JOB_DONE] = "Activated swap %s.",
1550 [JOB_FAILED] = "Failed to activate swap %s.",
1551 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1552 [JOB_TIMEOUT] = "Timed out activating swap %s.",
1554 .finished_stop_job = {
1555 [JOB_DONE] = "Deactivated swap %s.",
1556 [JOB_FAILED] = "Failed deactivating swap %s.",
1557 [JOB_TIMEOUT] = "Timed out deactivating swap %s.",