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-common-errors.h"
39 #include "exit-status.h"
41 #include "path-util.h"
43 #include "udev-util.h"
44 #include "fstab-util.h"
46 static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
47 [SWAP_DEAD] = UNIT_INACTIVE,
48 [SWAP_ACTIVATING] = UNIT_ACTIVATING,
49 [SWAP_ACTIVATING_DONE] = UNIT_ACTIVE,
50 [SWAP_ACTIVE] = UNIT_ACTIVE,
51 [SWAP_DEACTIVATING] = UNIT_DEACTIVATING,
52 [SWAP_ACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
53 [SWAP_ACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
54 [SWAP_DEACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
55 [SWAP_DEACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
56 [SWAP_FAILED] = UNIT_FAILED
59 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
60 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
62 static void swap_unset_proc_swaps(Swap *s) {
65 if (!s->from_proc_swaps)
68 free(s->parameters_proc_swaps.what);
69 s->parameters_proc_swaps.what = NULL;
71 s->from_proc_swaps = false;
74 static int swap_set_devnode(Swap *s, const char *devnode) {
81 r = hashmap_ensure_allocated(&UNIT(s)->manager->swaps_by_devnode, &string_hash_ops);
85 swaps = UNIT(s)->manager->swaps_by_devnode;
88 first = hashmap_get(swaps, s->devnode);
90 LIST_REMOVE(same_devnode, first, s);
92 hashmap_replace(swaps, first->devnode, first);
94 hashmap_remove(swaps, s->devnode);
101 s->devnode = strdup(devnode);
105 first = hashmap_get(swaps, s->devnode);
106 LIST_PREPEND(same_devnode, first, s);
108 return hashmap_replace(swaps, first->devnode, first);
114 static void swap_init(Unit *u) {
118 assert(UNIT(s)->load_state == UNIT_STUB);
120 s->timeout_usec = u->manager->default_timeout_start_usec;
122 s->exec_context.std_output = u->manager->default_std_output;
123 s->exec_context.std_error = u->manager->default_std_error;
125 s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
127 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
129 u->ignore_on_isolate = true;
132 static void swap_unwatch_control_pid(Swap *s) {
135 if (s->control_pid <= 0)
138 unit_unwatch_pid(UNIT(s), s->control_pid);
142 static void swap_done(Unit *u) {
147 swap_unset_proc_swaps(s);
148 swap_set_devnode(s, NULL);
153 free(s->parameters_fragment.what);
154 s->parameters_fragment.what = NULL;
156 free(s->parameters_fragment.options);
157 s->parameters_fragment.options = NULL;
159 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
160 exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
161 s->control_command = NULL;
163 swap_unwatch_control_pid(s);
165 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
168 static int swap_arm_timer(Swap *s) {
173 if (s->timeout_usec <= 0) {
174 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
178 if (s->timer_event_source) {
179 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
183 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
186 return sd_event_add_time(
187 UNIT(s)->manager->event,
188 &s->timer_event_source,
190 now(CLOCK_MONOTONIC) + s->timeout_usec, 0,
191 swap_dispatch_timer, s);
194 static int swap_add_device_links(Swap *s) {
200 if (!s->from_fragment)
203 if (is_device_path(s->what))
204 return unit_add_node_link(UNIT(s), s->what, UNIT(s)->manager->running_as == SYSTEMD_SYSTEM);
206 /* File based swap devices need to be ordered after
207 * systemd-remount-fs.service, since they might need a
208 * writable file system. */
209 return unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_REMOUNT_FS_SERVICE, NULL, true);
212 static int swap_add_default_dependencies(Swap *s) {
215 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
218 if (detect_container(NULL) > 0)
221 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
224 static int swap_verify(Swap *s) {
226 _cleanup_free_ char *e = NULL;
228 if (UNIT(s)->load_state != UNIT_LOADED)
231 e = unit_name_from_path(s->what, ".swap");
235 b = unit_has_name(UNIT(s), e);
237 log_unit_error(UNIT(s)->id, "%s: Value of \"What\" and unit name do not match, not loading.", UNIT(s)->id);
241 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
242 log_unit_error(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.", UNIT(s)->id);
249 static int swap_load_devnode(Swap *s) {
250 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
256 if (stat(s->what, &st) < 0 || !S_ISBLK(st.st_mode))
259 d = udev_device_new_from_devnum(UNIT(s)->manager->udev, 'b', st.st_rdev);
263 p = udev_device_get_devnode(d);
267 return swap_set_devnode(s, p);
270 static int swap_load(Unit *u) {
275 assert(u->load_state == UNIT_STUB);
277 /* Load a .swap file */
278 r = unit_load_fragment_and_dropin_optional(u);
282 if (u->load_state == UNIT_LOADED) {
284 if (UNIT(s)->fragment_path)
285 s->from_fragment = true;
288 if (s->parameters_fragment.what)
289 s->what = strdup(s->parameters_fragment.what);
290 else if (s->parameters_proc_swaps.what)
291 s->what = strdup(s->parameters_proc_swaps.what);
293 s->what = unit_name_to_path(u->id);
299 path_kill_slashes(s->what);
301 if (!UNIT(s)->description) {
302 r = unit_set_description(u, s->what);
307 r = unit_require_mounts_for(UNIT(s), s->what);
311 r = swap_add_device_links(s);
315 r = swap_load_devnode(s);
319 r = unit_patch_contexts(u);
323 r = unit_add_exec_dependencies(u, &s->exec_context);
327 r = unit_add_default_slice(u, &s->cgroup_context);
331 if (UNIT(s)->default_dependencies) {
332 r = swap_add_default_dependencies(s);
338 return swap_verify(s);
341 static int swap_add_one(
344 const char *what_proc_swaps,
348 _cleanup_free_ char *e = NULL;
356 assert(what_proc_swaps);
358 e = unit_name_from_path(what, ".swap");
362 u = manager_get_unit(m, e);
365 SWAP(u)->from_proc_swaps &&
366 !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps))
372 u = unit_new(m, sizeof(Swap));
376 r = unit_add_name(u, e);
380 SWAP(u)->what = strdup(what);
381 if (!SWAP(u)->what) {
386 unit_add_to_load_queue(u);
390 p = &SWAP(u)->parameters_proc_swaps;
393 p->what = strdup(what_proc_swaps);
401 SWAP(u)->is_active = true;
402 SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
405 SWAP(u)->from_proc_swaps = true;
407 p->priority = priority;
409 unit_add_to_dbus_queue(u);
414 log_unit_warning_errno(e, r, "Failed to load swap unit: %m");
422 static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) {
423 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
424 struct udev_list_entry *item = NULL, *first = NULL;
431 r = swap_add_one(m, device, device, prio, set_flags);
435 /* If this is a block device, then let's add duplicates for
436 * all other names of this block device */
437 if (stat(device, &st) < 0 || !S_ISBLK(st.st_mode))
440 d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev);
444 /* Add the main device node */
445 dn = udev_device_get_devnode(d);
446 if (dn && !streq(dn, device))
447 swap_add_one(m, dn, device, prio, set_flags);
449 /* Add additional units for all symlinks */
450 first = udev_device_get_devlinks_list_entry(d);
451 udev_list_entry_foreach(item, first) {
454 /* Don't bother with the /dev/block links */
455 p = udev_list_entry_get_name(item);
457 if (streq(p, device))
460 if (path_startswith(p, "/dev/block/"))
463 if (stat(p, &st) >= 0)
464 if (!S_ISBLK(st.st_mode) ||
465 st.st_rdev != udev_device_get_devnum(d))
468 swap_add_one(m, p, device, prio, set_flags);
474 static void swap_set_state(Swap *s, SwapState state) {
480 old_state = s->state;
483 if (state != SWAP_ACTIVATING &&
484 state != SWAP_ACTIVATING_SIGTERM &&
485 state != SWAP_ACTIVATING_SIGKILL &&
486 state != SWAP_ACTIVATING_DONE &&
487 state != SWAP_DEACTIVATING &&
488 state != SWAP_DEACTIVATING_SIGTERM &&
489 state != SWAP_DEACTIVATING_SIGKILL) {
490 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
491 swap_unwatch_control_pid(s);
492 s->control_command = NULL;
493 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
496 if (state != old_state)
497 log_unit_debug(UNIT(s)->id,
498 "%s changed %s -> %s",
500 swap_state_to_string(old_state),
501 swap_state_to_string(state));
503 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
505 /* If there other units for the same device node have a job
506 queued it might be worth checking again if it is runnable
507 now. This is necessary, since swap_start() refuses
508 operation with EAGAIN if there's already another job for
509 the same device node queued. */
510 LIST_FOREACH_OTHERS(same_devnode, other, s)
511 if (UNIT(other)->job)
512 job_add_to_run_queue(UNIT(other)->job);
515 static int swap_coldplug(Unit *u) {
517 SwapState new_state = SWAP_DEAD;
521 assert(s->state == SWAP_DEAD);
523 if (s->deserialized_state != s->state)
524 new_state = s->deserialized_state;
525 else if (s->from_proc_swaps)
526 new_state = SWAP_ACTIVE;
528 if (new_state == s->state)
531 if (new_state == SWAP_ACTIVATING ||
532 new_state == SWAP_ACTIVATING_SIGTERM ||
533 new_state == SWAP_ACTIVATING_SIGKILL ||
534 new_state == SWAP_ACTIVATING_DONE ||
535 new_state == SWAP_DEACTIVATING ||
536 new_state == SWAP_DEACTIVATING_SIGTERM ||
537 new_state == SWAP_DEACTIVATING_SIGKILL) {
539 if (s->control_pid <= 0)
542 r = unit_watch_pid(UNIT(s), s->control_pid);
546 r = swap_arm_timer(s);
551 swap_set_state(s, new_state);
555 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
562 if (s->from_proc_swaps)
563 p = &s->parameters_proc_swaps;
564 else if (s->from_fragment)
565 p = &s->parameters_fragment;
573 "%sFrom /proc/swaps: %s\n"
574 "%sFrom fragment: %s\n",
575 prefix, swap_state_to_string(s->state),
576 prefix, swap_result_to_string(s->result),
578 prefix, yes_no(s->from_proc_swaps),
579 prefix, yes_no(s->from_fragment));
582 fprintf(f, "%sDevice Node: %s\n", prefix, s->devnode);
589 prefix, strempty(p->options));
591 if (s->control_pid > 0)
593 "%sControl PID: "PID_FMT"\n",
594 prefix, s->control_pid);
596 exec_context_dump(&s->exec_context, f, prefix);
597 kill_context_dump(&s->kill_context, f, prefix);
600 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
603 ExecParameters exec_params = {
604 .apply_permissions = true,
605 .apply_chroot = true,
606 .apply_tty_stdin = true,
613 unit_realize_cgroup(UNIT(s));
615 r = unit_setup_exec_runtime(UNIT(s));
619 r = swap_arm_timer(s);
623 exec_params.environment = UNIT(s)->manager->environment;
624 exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn;
625 exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported;
626 exec_params.cgroup_path = UNIT(s)->cgroup_path;
627 exec_params.cgroup_delegate = s->cgroup_context.delegate;
628 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager);
629 exec_params.unit_id = UNIT(s)->id;
639 r = unit_watch_pid(UNIT(s), pid);
641 /* FIXME: we need to do something here */
649 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
653 static void swap_enter_dead(Swap *s, SwapResult f) {
656 if (f != SWAP_SUCCESS)
659 exec_runtime_destroy(s->exec_runtime);
660 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
662 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
664 swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
667 static void swap_enter_active(Swap *s, SwapResult f) {
670 if (f != SWAP_SUCCESS)
673 swap_set_state(s, SWAP_ACTIVE);
676 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
681 if (f != SWAP_SUCCESS)
684 r = unit_kill_context(
687 (state != SWAP_ACTIVATING_SIGTERM && state != SWAP_DEACTIVATING_SIGTERM) ?
688 KILL_KILL : KILL_TERMINATE,
696 r = swap_arm_timer(s);
700 swap_set_state(s, state);
701 } else if (state == SWAP_ACTIVATING_SIGTERM)
702 swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_SUCCESS);
703 else if (state == SWAP_DEACTIVATING_SIGTERM)
704 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_SUCCESS);
706 swap_enter_dead(s, SWAP_SUCCESS);
711 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to kill processes: %m", UNIT(s)->id);
712 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
715 static void swap_enter_activating(Swap *s) {
716 _cleanup_free_ char *discard = NULL;
717 int r, priority = -1;
721 s->control_command_id = SWAP_EXEC_ACTIVATE;
722 s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
724 if (s->from_fragment) {
725 fstab_filter_options(s->parameters_fragment.options, "discard\0",
726 NULL, &discard, NULL);
728 priority = s->parameters_fragment.priority;
730 fstab_find_pri(s->parameters_fragment.options, &priority);
733 r = exec_command_set(s->control_command, "/sbin/swapon", NULL);
738 char p[DECIMAL_STR_MAX(int)];
740 sprintf(p, "%i", priority);
741 r = exec_command_append(s->control_command, "-p", p, NULL);
746 if (discard && !streq(discard, "none")) {
747 const char *discard_arg;
749 if (streq(discard, "all"))
750 discard_arg = "--discard";
752 discard_arg = strjoina("--discard=", discard);
754 r = exec_command_append(s->control_command, discard_arg, NULL);
759 r = exec_command_append(s->control_command, s->what, NULL);
763 swap_unwatch_control_pid(s);
765 r = swap_spawn(s, s->control_command, &s->control_pid);
769 swap_set_state(s, SWAP_ACTIVATING);
774 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'swapon' task: %m", UNIT(s)->id);
775 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
778 static void swap_enter_deactivating(Swap *s) {
783 s->control_command_id = SWAP_EXEC_DEACTIVATE;
784 s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
786 r = exec_command_set(s->control_command,
793 swap_unwatch_control_pid(s);
795 r = swap_spawn(s, s->control_command, &s->control_pid);
799 swap_set_state(s, SWAP_DEACTIVATING);
804 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'swapoff' task: %m", UNIT(s)->id);
805 swap_enter_active(s, SWAP_FAILURE_RESOURCES);
808 static int swap_start(Unit *u) {
809 Swap *s = SWAP(u), *other;
813 /* We cannot fulfill this request right now, try again later
816 if (s->state == SWAP_DEACTIVATING ||
817 s->state == SWAP_DEACTIVATING_SIGTERM ||
818 s->state == SWAP_DEACTIVATING_SIGKILL ||
819 s->state == SWAP_ACTIVATING_SIGTERM ||
820 s->state == SWAP_ACTIVATING_SIGKILL)
823 if (s->state == SWAP_ACTIVATING)
826 assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
828 if (detect_container(NULL) > 0)
831 /* If there's a job for another swap unit for the same node
832 * running, then let's not dispatch this one for now, and wait
833 * until that other job has finished. */
834 LIST_FOREACH_OTHERS(same_devnode, other, s)
835 if (UNIT(other)->job && UNIT(other)->job->state == JOB_RUNNING)
838 s->result = SWAP_SUCCESS;
839 swap_enter_activating(s);
843 static int swap_stop(Unit *u) {
848 if (s->state == SWAP_DEACTIVATING ||
849 s->state == SWAP_DEACTIVATING_SIGTERM ||
850 s->state == SWAP_DEACTIVATING_SIGKILL ||
851 s->state == SWAP_ACTIVATING_SIGTERM ||
852 s->state == SWAP_ACTIVATING_SIGKILL)
855 assert(s->state == SWAP_ACTIVATING ||
856 s->state == SWAP_ACTIVATING_DONE ||
857 s->state == SWAP_ACTIVE);
859 if (detect_container(NULL) > 0)
862 swap_enter_deactivating(s);
866 static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
873 unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
874 unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
876 if (s->control_pid > 0)
877 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
879 if (s->control_command_id >= 0)
880 unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
885 static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
891 if (streq(key, "state")) {
894 state = swap_state_from_string(value);
896 log_unit_debug(u->id, "Failed to parse state value %s", value);
898 s->deserialized_state = state;
899 } else if (streq(key, "result")) {
902 f = swap_result_from_string(value);
904 log_unit_debug(u->id, "Failed to parse result value %s", value);
905 else if (f != SWAP_SUCCESS)
907 } else if (streq(key, "control-pid")) {
910 if (parse_pid(value, &pid) < 0)
911 log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
913 s->control_pid = pid;
915 } else if (streq(key, "control-command")) {
918 id = swap_exec_command_from_string(value);
920 log_unit_debug(u->id, "Failed to parse exec-command value %s", value);
922 s->control_command_id = id;
923 s->control_command = s->exec_command + id;
926 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
931 _pure_ static UnitActiveState swap_active_state(Unit *u) {
934 return state_translation_table[SWAP(u)->state];
937 _pure_ static const char *swap_sub_state_to_string(Unit *u) {
940 return swap_state_to_string(SWAP(u)->state);
943 _pure_ static bool swap_check_gc(Unit *u) {
948 return s->from_proc_swaps;
951 static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
958 if (pid != s->control_pid)
963 if (is_clean_exit(code, status, NULL))
965 else if (code == CLD_EXITED)
966 f = SWAP_FAILURE_EXIT_CODE;
967 else if (code == CLD_KILLED)
968 f = SWAP_FAILURE_SIGNAL;
969 else if (code == CLD_DUMPED)
970 f = SWAP_FAILURE_CORE_DUMP;
972 assert_not_reached("Unknown code");
974 if (f != SWAP_SUCCESS)
977 if (s->control_command) {
978 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
980 s->control_command = NULL;
981 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
985 f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
986 "%s swap process exited, code=%s status=%i",
987 u->id, sigchld_code_to_string(code), status);
991 case SWAP_ACTIVATING:
992 case SWAP_ACTIVATING_DONE:
993 case SWAP_ACTIVATING_SIGTERM:
994 case SWAP_ACTIVATING_SIGKILL:
996 if (f == SWAP_SUCCESS)
997 swap_enter_active(s, f);
999 swap_enter_dead(s, f);
1002 case SWAP_DEACTIVATING:
1003 case SWAP_DEACTIVATING_SIGKILL:
1004 case SWAP_DEACTIVATING_SIGTERM:
1006 swap_enter_dead(s, f);
1010 assert_not_reached("Uh, control process died at wrong time.");
1013 /* Notify clients about changed exit status */
1014 unit_add_to_dbus_queue(u);
1017 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1018 Swap *s = SWAP(userdata);
1021 assert(s->timer_event_source == source);
1025 case SWAP_ACTIVATING:
1026 case SWAP_ACTIVATING_DONE:
1027 log_unit_warning(UNIT(s)->id, "%s activation timed out. Stopping.", UNIT(s)->id);
1028 swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1031 case SWAP_DEACTIVATING:
1032 log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Stopping.", UNIT(s)->id);
1033 swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1036 case SWAP_ACTIVATING_SIGTERM:
1037 if (s->kill_context.send_sigkill) {
1038 log_unit_warning(UNIT(s)->id, "%s activation timed out. Killing.", UNIT(s)->id);
1039 swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1041 log_unit_warning(UNIT(s)->id, "%s activation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1042 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1046 case SWAP_DEACTIVATING_SIGTERM:
1047 if (s->kill_context.send_sigkill) {
1048 log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Killing.", UNIT(s)->id);
1049 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1051 log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1052 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1056 case SWAP_ACTIVATING_SIGKILL:
1057 case SWAP_DEACTIVATING_SIGKILL:
1058 log_unit_warning(UNIT(s)->id, "%s swap process still around after SIGKILL. Ignoring.", UNIT(s)->id);
1059 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1063 assert_not_reached("Timeout at wrong time.");
1069 static int swap_load_proc_swaps(Manager *m, bool set_flags) {
1075 rewind(m->proc_swaps);
1077 (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
1080 _cleanup_free_ char *dev = NULL, *d = NULL;
1083 k = fscanf(m->proc_swaps,
1084 "%ms " /* device/file */
1085 "%*s " /* type of swap */
1086 "%*s " /* swap size */
1088 "%i\n", /* priority */
1094 log_warning("Failed to parse /proc/swaps:%u", i);
1102 k = swap_process_new_swap(m, d, prio, set_flags);
1110 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1111 Manager *m = userdata;
1116 assert(revents & EPOLLPRI);
1118 r = swap_load_proc_swaps(m, true);
1120 log_error_errno(r, "Failed to reread /proc/swaps: %m");
1122 /* Reset flags, just in case, for late calls */
1123 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1124 Swap *swap = SWAP(u);
1126 swap->is_active = swap->just_activated = false;
1132 manager_dispatch_load_queue(m);
1134 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1135 Swap *swap = SWAP(u);
1137 if (!swap->is_active) {
1138 /* This has just been deactivated */
1140 swap_unset_proc_swaps(swap);
1142 switch (swap->state) {
1145 swap_enter_dead(swap, SWAP_SUCCESS);
1150 swap_set_state(swap, swap->state);
1154 } else if (swap->just_activated) {
1156 /* New swap entry */
1158 switch (swap->state) {
1162 swap_enter_active(swap, SWAP_SUCCESS);
1165 case SWAP_ACTIVATING:
1166 swap_set_state(swap, SWAP_ACTIVATING_DONE);
1170 /* Nothing really changed, but let's
1171 * issue an notification call
1172 * nonetheless, in case somebody is
1173 * waiting for this. */
1174 swap_set_state(swap, swap->state);
1179 /* Reset the flags for later calls */
1180 swap->is_active = swap->just_activated = false;
1186 static Unit *swap_following(Unit *u) {
1188 Swap *other, *first = NULL;
1192 /* If the user configured the swap through /etc/fstab or
1193 * a device unit, follow that. */
1195 if (s->from_fragment)
1198 LIST_FOREACH_OTHERS(same_devnode, other, s)
1199 if (other->from_fragment)
1202 /* Otherwise make everybody follow the unit that's named after
1203 * the swap device in the kernel */
1205 if (streq_ptr(s->what, s->devnode))
1208 LIST_FOREACH_AFTER(same_devnode, other, s)
1209 if (streq_ptr(other->what, other->devnode))
1212 LIST_FOREACH_BEFORE(same_devnode, other, s) {
1213 if (streq_ptr(other->what, other->devnode))
1219 /* Fall back to the first on the list */
1223 static int swap_following_set(Unit *u, Set **_set) {
1224 Swap *s = SWAP(u), *other;
1231 if (LIST_JUST_US(same_devnode, s)) {
1236 set = set_new(NULL);
1240 LIST_FOREACH_OTHERS(same_devnode, other, s) {
1241 r = set_put(set, other);
1254 static void swap_shutdown(Manager *m) {
1257 m->swap_event_source = sd_event_source_unref(m->swap_event_source);
1259 if (m->proc_swaps) {
1260 fclose(m->proc_swaps);
1261 m->proc_swaps = NULL;
1264 hashmap_free(m->swaps_by_devnode);
1265 m->swaps_by_devnode = NULL;
1268 static int swap_enumerate(Manager *m) {
1273 if (!m->proc_swaps) {
1274 m->proc_swaps = fopen("/proc/swaps", "re");
1276 return errno == ENOENT ? 0 : -errno;
1278 r = sd_event_add_io(m->event, &m->swap_event_source, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m);
1282 /* Dispatch this before we dispatch SIGCHLD, so that
1283 * we always get the events from /proc/swaps before
1284 * the SIGCHLD of /sbin/swapon. */
1285 r = sd_event_source_set_priority(m->swap_event_source, -10);
1290 r = swap_load_proc_swaps(m, false);
1301 int swap_process_new_device(Manager *m, struct udev_device *dev) {
1302 struct udev_list_entry *item = NULL, *first = NULL;
1303 _cleanup_free_ char *e = NULL;
1311 dn = udev_device_get_devnode(dev);
1315 e = unit_name_from_path(dn, ".swap");
1319 s = hashmap_get(m->units, e);
1321 r = swap_set_devnode(s, dn);
1323 first = udev_device_get_devlinks_list_entry(dev);
1324 udev_list_entry_foreach(item, first) {
1325 _cleanup_free_ char *n = NULL;
1327 n = unit_name_from_path(udev_list_entry_get_name(item), ".swap");
1331 s = hashmap_get(m->units, n);
1335 q = swap_set_devnode(s, dn);
1344 int swap_process_removed_device(Manager *m, struct udev_device *dev) {
1349 dn = udev_device_get_devnode(dev);
1353 while ((s = hashmap_get(m->swaps_by_devnode, dn))) {
1356 q = swap_set_devnode(s, NULL);
1364 static void swap_reset_failed(Unit *u) {
1369 if (s->state == SWAP_FAILED)
1370 swap_set_state(s, SWAP_DEAD);
1372 s->result = SWAP_SUCCESS;
1375 static int swap_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1376 return unit_kill_common(u, who, signo, -1, SWAP(u)->control_pid, error);
1379 static int swap_get_timeout(Unit *u, uint64_t *timeout) {
1383 if (!s->timer_event_source)
1386 r = sd_event_source_get_time(s->timer_event_source, timeout);
1393 static bool swap_supported(Manager *m) {
1394 static int supported = -1;
1396 /* If swap support is not available in the kernel, or we are
1397 * running in a container we don't support swap units, and any
1398 * attempts to starting one should fail immediately. */
1402 access("/proc/swaps", F_OK) >= 0 &&
1403 detect_container(NULL) <= 0;
1408 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1409 [SWAP_DEAD] = "dead",
1410 [SWAP_ACTIVATING] = "activating",
1411 [SWAP_ACTIVATING_DONE] = "activating-done",
1412 [SWAP_ACTIVE] = "active",
1413 [SWAP_DEACTIVATING] = "deactivating",
1414 [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1415 [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1416 [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1417 [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1418 [SWAP_FAILED] = "failed"
1421 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1423 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1424 [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1425 [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1428 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1430 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1431 [SWAP_SUCCESS] = "success",
1432 [SWAP_FAILURE_RESOURCES] = "resources",
1433 [SWAP_FAILURE_TIMEOUT] = "timeout",
1434 [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1435 [SWAP_FAILURE_SIGNAL] = "signal",
1436 [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1439 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1441 const UnitVTable swap_vtable = {
1442 .object_size = sizeof(Swap),
1443 .exec_context_offset = offsetof(Swap, exec_context),
1444 .cgroup_context_offset = offsetof(Swap, cgroup_context),
1445 .kill_context_offset = offsetof(Swap, kill_context),
1446 .exec_runtime_offset = offsetof(Swap, exec_runtime),
1452 .private_section = "Swap",
1455 .no_instances = true,
1461 .coldplug = swap_coldplug,
1465 .start = swap_start,
1470 .get_timeout = swap_get_timeout,
1472 .serialize = swap_serialize,
1473 .deserialize_item = swap_deserialize_item,
1475 .active_state = swap_active_state,
1476 .sub_state_to_string = swap_sub_state_to_string,
1478 .check_gc = swap_check_gc,
1480 .sigchld_event = swap_sigchld_event,
1482 .reset_failed = swap_reset_failed,
1484 .bus_interface = "org.freedesktop.systemd1.Swap",
1485 .bus_vtable = bus_swap_vtable,
1486 .bus_set_property = bus_swap_set_property,
1487 .bus_commit_properties = bus_swap_commit_properties,
1489 .following = swap_following,
1490 .following_set = swap_following_set,
1492 .enumerate = swap_enumerate,
1493 .shutdown = swap_shutdown,
1494 .supported = swap_supported,
1496 .status_message_formats = {
1497 .starting_stopping = {
1498 [0] = "Activating swap %s...",
1499 [1] = "Deactivating swap %s...",
1501 .finished_start_job = {
1502 [JOB_DONE] = "Activated swap %s.",
1503 [JOB_FAILED] = "Failed to activate swap %s.",
1504 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1505 [JOB_TIMEOUT] = "Timed out activating swap %s.",
1507 .finished_stop_job = {
1508 [JOB_DONE] = "Deactivated swap %s.",
1509 [JOB_FAILED] = "Failed deactivating swap %s.",
1510 [JOB_TIMEOUT] = "Timed out deactivating swap %s.",