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/>.
24 #include <sys/epoll.h>
30 #include "unit-name.h"
31 #include "dbus-swap.h"
33 #include "exit-status.h"
34 #include "path-util.h"
36 #include "udev-util.h"
37 #include "fstab-util.h"
39 static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
40 [SWAP_DEAD] = UNIT_INACTIVE,
41 [SWAP_ACTIVATING] = UNIT_ACTIVATING,
42 [SWAP_ACTIVATING_DONE] = UNIT_ACTIVE,
43 [SWAP_ACTIVE] = UNIT_ACTIVE,
44 [SWAP_DEACTIVATING] = UNIT_DEACTIVATING,
45 [SWAP_ACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
46 [SWAP_ACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
47 [SWAP_DEACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
48 [SWAP_DEACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
49 [SWAP_FAILED] = UNIT_FAILED
52 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
53 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
55 static void swap_unset_proc_swaps(Swap *s) {
58 if (!s->from_proc_swaps)
61 free(s->parameters_proc_swaps.what);
62 s->parameters_proc_swaps.what = NULL;
64 s->from_proc_swaps = false;
67 static int swap_set_devnode(Swap *s, const char *devnode) {
74 r = hashmap_ensure_allocated(&UNIT(s)->manager->swaps_by_devnode, &string_hash_ops);
78 swaps = UNIT(s)->manager->swaps_by_devnode;
81 first = hashmap_get(swaps, s->devnode);
83 LIST_REMOVE(same_devnode, first, s);
85 hashmap_replace(swaps, first->devnode, first);
87 hashmap_remove(swaps, s->devnode);
94 s->devnode = strdup(devnode);
98 first = hashmap_get(swaps, s->devnode);
99 LIST_PREPEND(same_devnode, first, s);
101 return hashmap_replace(swaps, first->devnode, first);
107 static void swap_init(Unit *u) {
111 assert(UNIT(s)->load_state == UNIT_STUB);
113 s->timeout_usec = u->manager->default_timeout_start_usec;
115 s->exec_context.std_output = u->manager->default_std_output;
116 s->exec_context.std_error = u->manager->default_std_error;
118 s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
120 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
122 u->ignore_on_isolate = true;
125 static void swap_unwatch_control_pid(Swap *s) {
128 if (s->control_pid <= 0)
131 unit_unwatch_pid(UNIT(s), s->control_pid);
135 static void swap_done(Unit *u) {
140 swap_unset_proc_swaps(s);
141 swap_set_devnode(s, NULL);
146 free(s->parameters_fragment.what);
147 s->parameters_fragment.what = NULL;
149 free(s->parameters_fragment.options);
150 s->parameters_fragment.options = NULL;
152 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
153 exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
154 s->control_command = NULL;
156 swap_unwatch_control_pid(s);
158 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
161 static int swap_arm_timer(Swap *s) {
166 if (s->timeout_usec <= 0) {
167 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
171 if (s->timer_event_source) {
172 r = sd_event_source_set_time(s->timer_event_source, now(CLOCK_MONOTONIC) + s->timeout_usec);
176 return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT);
179 return sd_event_add_time(
180 UNIT(s)->manager->event,
181 &s->timer_event_source,
183 now(CLOCK_MONOTONIC) + s->timeout_usec, 0,
184 swap_dispatch_timer, s);
187 static int swap_add_device_links(Swap *s) {
193 if (!s->from_fragment)
196 if (is_device_path(s->what))
197 return unit_add_node_link(UNIT(s), s->what, UNIT(s)->manager->running_as == SYSTEMD_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) {
208 if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM)
211 if (detect_container(NULL) > 0)
214 return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
217 static int swap_verify(Swap *s) {
219 _cleanup_free_ char *e = NULL;
221 if (UNIT(s)->load_state != UNIT_LOADED)
224 e = unit_name_from_path(s->what, ".swap");
228 b = unit_has_name(UNIT(s), e);
230 log_unit_error(UNIT(s)->id, "%s: Value of \"What\" and unit name do not match, not loading.", UNIT(s)->id);
234 if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
235 log_unit_error(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.", UNIT(s)->id);
242 static int swap_load_devnode(Swap *s) {
243 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
249 if (stat(s->what, &st) < 0 || !S_ISBLK(st.st_mode))
252 d = udev_device_new_from_devnum(UNIT(s)->manager->udev, 'b', st.st_rdev);
256 p = udev_device_get_devnode(d);
260 return swap_set_devnode(s, p);
263 static int swap_load(Unit *u) {
268 assert(u->load_state == UNIT_STUB);
270 /* Load a .swap file */
271 r = unit_load_fragment_and_dropin_optional(u);
275 if (u->load_state == UNIT_LOADED) {
277 if (UNIT(s)->fragment_path)
278 s->from_fragment = true;
281 if (s->parameters_fragment.what)
282 s->what = strdup(s->parameters_fragment.what);
283 else if (s->parameters_proc_swaps.what)
284 s->what = strdup(s->parameters_proc_swaps.what);
286 s->what = unit_name_to_path(u->id);
292 path_kill_slashes(s->what);
294 if (!UNIT(s)->description) {
295 r = unit_set_description(u, s->what);
300 r = unit_require_mounts_for(UNIT(s), s->what);
304 r = swap_add_device_links(s);
308 r = swap_load_devnode(s);
312 r = unit_patch_contexts(u);
316 r = unit_add_exec_dependencies(u, &s->exec_context);
320 r = unit_add_default_slice(u, &s->cgroup_context);
324 if (UNIT(s)->default_dependencies) {
325 r = swap_add_default_dependencies(s);
331 return swap_verify(s);
334 static int swap_setup_unit(
337 const char *what_proc_swaps,
341 _cleanup_free_ char *e = NULL;
349 assert(what_proc_swaps);
351 e = unit_name_from_path(what, ".swap");
355 u = manager_get_unit(m, e);
358 SWAP(u)->from_proc_swaps &&
359 !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps)) {
360 log_error("Swap %s appeared twice with different device paths %s and %s", e, SWAP(u)->parameters_proc_swaps.what, what_proc_swaps);
367 u = unit_new(m, sizeof(Swap));
371 r = unit_add_name(u, e);
375 SWAP(u)->what = strdup(what);
376 if (!SWAP(u)->what) {
381 unit_add_to_load_queue(u);
385 p = &SWAP(u)->parameters_proc_swaps;
388 p->what = strdup(what_proc_swaps);
396 SWAP(u)->is_active = true;
397 SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
400 SWAP(u)->from_proc_swaps = true;
402 p->priority = priority;
404 unit_add_to_dbus_queue(u);
408 log_unit_warning_errno(e, r, "Failed to load swap unit: %m");
416 static int swap_process_new(Manager *m, const char *device, int prio, bool set_flags) {
417 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
418 struct udev_list_entry *item = NULL, *first = NULL;
425 r = swap_setup_unit(m, device, device, prio, set_flags);
429 /* If this is a block device, then let's add duplicates for
430 * all other names of this block device */
431 if (stat(device, &st) < 0 || !S_ISBLK(st.st_mode))
434 d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev);
438 /* Add the main device node */
439 dn = udev_device_get_devnode(d);
440 if (dn && !streq(dn, device))
441 swap_setup_unit(m, dn, device, prio, set_flags);
443 /* Add additional units for all symlinks */
444 first = udev_device_get_devlinks_list_entry(d);
445 udev_list_entry_foreach(item, first) {
448 /* Don't bother with the /dev/block links */
449 p = udev_list_entry_get_name(item);
451 if (streq(p, device))
454 if (path_startswith(p, "/dev/block/"))
457 if (stat(p, &st) >= 0)
458 if (!S_ISBLK(st.st_mode) ||
459 st.st_rdev != udev_device_get_devnum(d))
462 swap_setup_unit(m, p, device, prio, set_flags);
468 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_ACTIVATING_DONE &&
481 state != SWAP_DEACTIVATING &&
482 state != SWAP_DEACTIVATING_SIGTERM &&
483 state != SWAP_DEACTIVATING_SIGKILL) {
484 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
485 swap_unwatch_control_pid(s);
486 s->control_command = NULL;
487 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
490 if (state != old_state)
491 log_unit_debug(UNIT(s)->id,
492 "%s changed %s -> %s",
494 swap_state_to_string(old_state),
495 swap_state_to_string(state));
497 unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
499 /* If there other units for the same device node have a job
500 queued it might be worth checking again if it is runnable
501 now. This is necessary, since swap_start() refuses
502 operation with EAGAIN if there's already another job for
503 the same device node queued. */
504 LIST_FOREACH_OTHERS(same_devnode, other, s)
505 if (UNIT(other)->job)
506 job_add_to_run_queue(UNIT(other)->job);
509 static int swap_coldplug(Unit *u, Hashmap *deferred_work) {
511 SwapState new_state = SWAP_DEAD;
515 assert(s->state == SWAP_DEAD);
517 if (s->deserialized_state != s->state)
518 new_state = s->deserialized_state;
519 else if (s->from_proc_swaps)
520 new_state = SWAP_ACTIVE;
522 if (new_state == s->state)
525 if (new_state == SWAP_ACTIVATING ||
526 new_state == SWAP_ACTIVATING_SIGTERM ||
527 new_state == SWAP_ACTIVATING_SIGKILL ||
528 new_state == SWAP_ACTIVATING_DONE ||
529 new_state == SWAP_DEACTIVATING ||
530 new_state == SWAP_DEACTIVATING_SIGTERM ||
531 new_state == SWAP_DEACTIVATING_SIGKILL) {
533 if (s->control_pid <= 0)
536 r = unit_watch_pid(UNIT(s), s->control_pid);
540 r = swap_arm_timer(s);
545 swap_set_state(s, new_state);
549 static void swap_dump(Unit *u, FILE *f, const char *prefix) {
556 if (s->from_proc_swaps)
557 p = &s->parameters_proc_swaps;
558 else if (s->from_fragment)
559 p = &s->parameters_fragment;
567 "%sFrom /proc/swaps: %s\n"
568 "%sFrom fragment: %s\n",
569 prefix, swap_state_to_string(s->state),
570 prefix, swap_result_to_string(s->result),
572 prefix, yes_no(s->from_proc_swaps),
573 prefix, yes_no(s->from_fragment));
576 fprintf(f, "%sDevice Node: %s\n", prefix, s->devnode);
583 prefix, strempty(p->options));
585 if (s->control_pid > 0)
587 "%sControl PID: "PID_FMT"\n",
588 prefix, s->control_pid);
590 exec_context_dump(&s->exec_context, f, prefix);
591 kill_context_dump(&s->kill_context, f, prefix);
594 static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
597 ExecParameters exec_params = {
598 .apply_permissions = true,
599 .apply_chroot = true,
600 .apply_tty_stdin = true,
607 (void) unit_realize_cgroup(UNIT(s));
608 if (s->reset_cpu_usage) {
609 (void) unit_reset_cpu_usage(UNIT(s));
610 s->reset_cpu_usage = false;
613 r = unit_setup_exec_runtime(UNIT(s));
617 r = swap_arm_timer(s);
621 exec_params.environment = UNIT(s)->manager->environment;
622 exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn;
623 exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported;
624 exec_params.cgroup_path = UNIT(s)->cgroup_path;
625 exec_params.cgroup_delegate = s->cgroup_context.delegate;
626 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager);
627 exec_params.unit_id = UNIT(s)->id;
637 r = unit_watch_pid(UNIT(s), pid);
639 /* FIXME: we need to do something here */
647 s->timer_event_source = sd_event_source_unref(s->timer_event_source);
651 static void swap_enter_dead(Swap *s, SwapResult f) {
654 if (f != SWAP_SUCCESS)
657 exec_runtime_destroy(s->exec_runtime);
658 s->exec_runtime = exec_runtime_unref(s->exec_runtime);
660 exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
662 swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD);
665 static void swap_enter_active(Swap *s, SwapResult f) {
668 if (f != SWAP_SUCCESS)
671 swap_set_state(s, SWAP_ACTIVE);
674 static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) {
679 if (f != SWAP_SUCCESS)
682 r = unit_kill_context(
685 (state != SWAP_ACTIVATING_SIGTERM && state != SWAP_DEACTIVATING_SIGTERM) ?
686 KILL_KILL : KILL_TERMINATE,
694 r = swap_arm_timer(s);
698 swap_set_state(s, state);
699 } else if (state == SWAP_ACTIVATING_SIGTERM)
700 swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_SUCCESS);
701 else if (state == SWAP_DEACTIVATING_SIGTERM)
702 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_SUCCESS);
704 swap_enter_dead(s, SWAP_SUCCESS);
709 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to kill processes: %m", UNIT(s)->id);
710 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
713 static void swap_enter_activating(Swap *s) {
714 _cleanup_free_ char *discard = NULL;
715 int r, priority = -1;
719 s->control_command_id = SWAP_EXEC_ACTIVATE;
720 s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
722 if (s->from_fragment) {
723 fstab_filter_options(s->parameters_fragment.options, "discard\0",
724 NULL, &discard, NULL);
726 priority = s->parameters_fragment.priority;
728 r = fstab_find_pri(s->parameters_fragment.options, &priority);
730 log_notice_errno(r, "Failed to parse swap priority \"%s\", ignoring: %m",
731 s->parameters_fragment.options);
735 r = exec_command_set(s->control_command, "/sbin/swapon", NULL);
740 char p[DECIMAL_STR_MAX(int)];
742 sprintf(p, "%i", priority);
743 r = exec_command_append(s->control_command, "-p", p, NULL);
748 if (discard && !streq(discard, "none")) {
749 const char *discard_arg;
751 if (streq(discard, "all"))
752 discard_arg = "--discard";
754 discard_arg = strjoina("--discard=", discard);
756 r = exec_command_append(s->control_command, discard_arg, NULL);
761 r = exec_command_append(s->control_command, s->what, NULL);
765 swap_unwatch_control_pid(s);
767 r = swap_spawn(s, s->control_command, &s->control_pid);
771 swap_set_state(s, SWAP_ACTIVATING);
776 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'swapon' task: %m", UNIT(s)->id);
777 swap_enter_dead(s, SWAP_FAILURE_RESOURCES);
780 static void swap_enter_deactivating(Swap *s) {
785 s->control_command_id = SWAP_EXEC_DEACTIVATE;
786 s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
788 r = exec_command_set(s->control_command,
795 swap_unwatch_control_pid(s);
797 r = swap_spawn(s, s->control_command, &s->control_pid);
801 swap_set_state(s, SWAP_DEACTIVATING);
806 log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'swapoff' task: %m", UNIT(s)->id);
807 swap_enter_active(s, SWAP_FAILURE_RESOURCES);
810 static int swap_start(Unit *u) {
811 Swap *s = SWAP(u), *other;
815 /* We cannot fulfill this request right now, try again later
818 if (s->state == SWAP_DEACTIVATING ||
819 s->state == SWAP_DEACTIVATING_SIGTERM ||
820 s->state == SWAP_DEACTIVATING_SIGKILL ||
821 s->state == SWAP_ACTIVATING_SIGTERM ||
822 s->state == SWAP_ACTIVATING_SIGKILL)
825 if (s->state == SWAP_ACTIVATING)
828 assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
830 if (detect_container(NULL) > 0)
833 /* If there's a job for another swap unit for the same node
834 * running, then let's not dispatch this one for now, and wait
835 * until that other job has finished. */
836 LIST_FOREACH_OTHERS(same_devnode, other, s)
837 if (UNIT(other)->job && UNIT(other)->job->state == JOB_RUNNING)
840 s->result = SWAP_SUCCESS;
841 s->reset_cpu_usage = true;
843 swap_enter_activating(s);
847 static int swap_stop(Unit *u) {
852 if (s->state == SWAP_DEACTIVATING ||
853 s->state == SWAP_DEACTIVATING_SIGTERM ||
854 s->state == SWAP_DEACTIVATING_SIGKILL ||
855 s->state == SWAP_ACTIVATING_SIGTERM ||
856 s->state == SWAP_ACTIVATING_SIGKILL)
859 assert(s->state == SWAP_ACTIVATING ||
860 s->state == SWAP_ACTIVATING_DONE ||
861 s->state == SWAP_ACTIVE);
863 if (detect_container(NULL) > 0)
866 swap_enter_deactivating(s);
870 static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
877 unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
878 unit_serialize_item(u, f, "result", swap_result_to_string(s->result));
880 if (s->control_pid > 0)
881 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
883 if (s->control_command_id >= 0)
884 unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
889 static int swap_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
895 if (streq(key, "state")) {
898 state = swap_state_from_string(value);
900 log_unit_debug(u->id, "Failed to parse state value %s", value);
902 s->deserialized_state = state;
903 } else if (streq(key, "result")) {
906 f = swap_result_from_string(value);
908 log_unit_debug(u->id, "Failed to parse result value %s", value);
909 else if (f != SWAP_SUCCESS)
911 } else if (streq(key, "control-pid")) {
914 if (parse_pid(value, &pid) < 0)
915 log_unit_debug(u->id, "Failed to parse control-pid value %s", value);
917 s->control_pid = pid;
919 } else if (streq(key, "control-command")) {
922 id = swap_exec_command_from_string(value);
924 log_unit_debug(u->id, "Failed to parse exec-command value %s", value);
926 s->control_command_id = id;
927 s->control_command = s->exec_command + id;
930 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
935 _pure_ static UnitActiveState swap_active_state(Unit *u) {
938 return state_translation_table[SWAP(u)->state];
941 _pure_ static const char *swap_sub_state_to_string(Unit *u) {
944 return swap_state_to_string(SWAP(u)->state);
947 _pure_ static bool swap_check_gc(Unit *u) {
952 return s->from_proc_swaps;
955 static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
962 if (pid != s->control_pid)
967 if (is_clean_exit(code, status, NULL))
969 else if (code == CLD_EXITED)
970 f = SWAP_FAILURE_EXIT_CODE;
971 else if (code == CLD_KILLED)
972 f = SWAP_FAILURE_SIGNAL;
973 else if (code == CLD_DUMPED)
974 f = SWAP_FAILURE_CORE_DUMP;
976 assert_not_reached("Unknown code");
978 if (f != SWAP_SUCCESS)
981 if (s->control_command) {
982 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
984 s->control_command = NULL;
985 s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
989 f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
990 "%s swap process exited, code=%s status=%i",
991 u->id, sigchld_code_to_string(code), status);
995 case SWAP_ACTIVATING:
996 case SWAP_ACTIVATING_DONE:
997 case SWAP_ACTIVATING_SIGTERM:
998 case SWAP_ACTIVATING_SIGKILL:
1000 if (f == SWAP_SUCCESS)
1001 swap_enter_active(s, f);
1003 swap_enter_dead(s, f);
1006 case SWAP_DEACTIVATING:
1007 case SWAP_DEACTIVATING_SIGKILL:
1008 case SWAP_DEACTIVATING_SIGTERM:
1010 swap_enter_dead(s, f);
1014 assert_not_reached("Uh, control process died at wrong time.");
1017 /* Notify clients about changed exit status */
1018 unit_add_to_dbus_queue(u);
1021 static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1022 Swap *s = SWAP(userdata);
1025 assert(s->timer_event_source == source);
1029 case SWAP_ACTIVATING:
1030 case SWAP_ACTIVATING_DONE:
1031 log_unit_warning(UNIT(s)->id, "%s activation timed out. Stopping.", UNIT(s)->id);
1032 swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1035 case SWAP_DEACTIVATING:
1036 log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Stopping.", UNIT(s)->id);
1037 swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT);
1040 case SWAP_ACTIVATING_SIGTERM:
1041 if (s->kill_context.send_sigkill) {
1042 log_unit_warning(UNIT(s)->id, "%s activation timed out. Killing.", UNIT(s)->id);
1043 swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1045 log_unit_warning(UNIT(s)->id, "%s activation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1046 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1050 case SWAP_DEACTIVATING_SIGTERM:
1051 if (s->kill_context.send_sigkill) {
1052 log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Killing.", UNIT(s)->id);
1053 swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT);
1055 log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
1056 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1060 case SWAP_ACTIVATING_SIGKILL:
1061 case SWAP_DEACTIVATING_SIGKILL:
1062 log_unit_warning(UNIT(s)->id, "%s swap process still around after SIGKILL. Ignoring.", UNIT(s)->id);
1063 swap_enter_dead(s, SWAP_FAILURE_TIMEOUT);
1067 assert_not_reached("Timeout at wrong time.");
1073 static int swap_load_proc_swaps(Manager *m, bool set_flags) {
1079 rewind(m->proc_swaps);
1081 (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
1084 _cleanup_free_ char *dev = NULL, *d = NULL;
1087 k = fscanf(m->proc_swaps,
1088 "%ms " /* device/file */
1089 "%*s " /* type of swap */
1090 "%*s " /* swap size */
1092 "%i\n", /* priority */
1098 log_warning("Failed to parse /proc/swaps:%u.", i);
1106 device_found_node(m, d, true, DEVICE_FOUND_SWAP, set_flags);
1108 k = swap_process_new(m, d, prio, set_flags);
1116 static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1117 Manager *m = userdata;
1122 assert(revents & EPOLLPRI);
1124 r = swap_load_proc_swaps(m, true);
1126 log_error_errno(r, "Failed to reread /proc/swaps: %m");
1128 /* Reset flags, just in case, for late calls */
1129 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1130 Swap *swap = SWAP(u);
1132 swap->is_active = swap->just_activated = false;
1138 manager_dispatch_load_queue(m);
1140 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) {
1141 Swap *swap = SWAP(u);
1143 if (!swap->is_active) {
1144 /* This has just been deactivated */
1146 swap_unset_proc_swaps(swap);
1148 switch (swap->state) {
1151 swap_enter_dead(swap, SWAP_SUCCESS);
1156 swap_set_state(swap, swap->state);
1161 device_found_node(m, swap->what, false, DEVICE_FOUND_SWAP, true);
1163 } else if (swap->just_activated) {
1165 /* New swap entry */
1167 switch (swap->state) {
1171 swap_enter_active(swap, SWAP_SUCCESS);
1174 case SWAP_ACTIVATING:
1175 swap_set_state(swap, SWAP_ACTIVATING_DONE);
1179 /* Nothing really changed, but let's
1180 * issue an notification call
1181 * nonetheless, in case somebody is
1182 * waiting for this. */
1183 swap_set_state(swap, swap->state);
1188 /* Reset the flags for later calls */
1189 swap->is_active = swap->just_activated = false;
1195 static Unit *swap_following(Unit *u) {
1197 Swap *other, *first = NULL;
1201 /* If the user configured the swap through /etc/fstab or
1202 * a device unit, follow that. */
1204 if (s->from_fragment)
1207 LIST_FOREACH_OTHERS(same_devnode, other, s)
1208 if (other->from_fragment)
1211 /* Otherwise make everybody follow the unit that's named after
1212 * the swap device in the kernel */
1214 if (streq_ptr(s->what, s->devnode))
1217 LIST_FOREACH_AFTER(same_devnode, other, s)
1218 if (streq_ptr(other->what, other->devnode))
1221 LIST_FOREACH_BEFORE(same_devnode, other, s) {
1222 if (streq_ptr(other->what, other->devnode))
1228 /* Fall back to the first on the list */
1232 static int swap_following_set(Unit *u, Set **_set) {
1233 Swap *s = SWAP(u), *other;
1240 if (LIST_JUST_US(same_devnode, s)) {
1245 set = set_new(NULL);
1249 LIST_FOREACH_OTHERS(same_devnode, other, s) {
1250 r = set_put(set, other);
1263 static void swap_shutdown(Manager *m) {
1266 m->swap_event_source = sd_event_source_unref(m->swap_event_source);
1268 if (m->proc_swaps) {
1269 fclose(m->proc_swaps);
1270 m->proc_swaps = NULL;
1273 hashmap_free(m->swaps_by_devnode);
1274 m->swaps_by_devnode = NULL;
1277 static int swap_enumerate(Manager *m) {
1282 if (!m->proc_swaps) {
1283 m->proc_swaps = fopen("/proc/swaps", "re");
1285 return errno == ENOENT ? 0 : -errno;
1287 r = sd_event_add_io(m->event, &m->swap_event_source, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m);
1291 /* Dispatch this before we dispatch SIGCHLD, so that
1292 * we always get the events from /proc/swaps before
1293 * the SIGCHLD of /sbin/swapon. */
1294 r = sd_event_source_set_priority(m->swap_event_source, -10);
1299 r = swap_load_proc_swaps(m, false);
1310 int swap_process_device_new(Manager *m, struct udev_device *dev) {
1311 struct udev_list_entry *item = NULL, *first = NULL;
1312 _cleanup_free_ char *e = NULL;
1320 dn = udev_device_get_devnode(dev);
1324 e = unit_name_from_path(dn, ".swap");
1328 s = hashmap_get(m->units, e);
1330 r = swap_set_devnode(s, dn);
1332 first = udev_device_get_devlinks_list_entry(dev);
1333 udev_list_entry_foreach(item, first) {
1334 _cleanup_free_ char *n = NULL;
1336 n = unit_name_from_path(udev_list_entry_get_name(item), ".swap");
1340 s = hashmap_get(m->units, n);
1344 q = swap_set_devnode(s, dn);
1353 int swap_process_device_remove(Manager *m, struct udev_device *dev) {
1358 dn = udev_device_get_devnode(dev);
1362 while ((s = hashmap_get(m->swaps_by_devnode, dn))) {
1365 q = swap_set_devnode(s, NULL);
1373 static void swap_reset_failed(Unit *u) {
1378 if (s->state == SWAP_FAILED)
1379 swap_set_state(s, SWAP_DEAD);
1381 s->result = SWAP_SUCCESS;
1384 static int swap_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1385 return unit_kill_common(u, who, signo, -1, SWAP(u)->control_pid, error);
1388 static int swap_get_timeout(Unit *u, uint64_t *timeout) {
1392 if (!s->timer_event_source)
1395 r = sd_event_source_get_time(s->timer_event_source, timeout);
1402 static bool swap_supported(Manager *m) {
1403 static int supported = -1;
1405 /* If swap support is not available in the kernel, or we are
1406 * running in a container we don't support swap units, and any
1407 * attempts to starting one should fail immediately. */
1411 access("/proc/swaps", F_OK) >= 0 &&
1412 detect_container(NULL) <= 0;
1417 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
1418 [SWAP_DEAD] = "dead",
1419 [SWAP_ACTIVATING] = "activating",
1420 [SWAP_ACTIVATING_DONE] = "activating-done",
1421 [SWAP_ACTIVE] = "active",
1422 [SWAP_DEACTIVATING] = "deactivating",
1423 [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
1424 [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
1425 [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
1426 [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
1427 [SWAP_FAILED] = "failed"
1430 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
1432 static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
1433 [SWAP_EXEC_ACTIVATE] = "ExecActivate",
1434 [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
1437 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
1439 static const char* const swap_result_table[_SWAP_RESULT_MAX] = {
1440 [SWAP_SUCCESS] = "success",
1441 [SWAP_FAILURE_RESOURCES] = "resources",
1442 [SWAP_FAILURE_TIMEOUT] = "timeout",
1443 [SWAP_FAILURE_EXIT_CODE] = "exit-code",
1444 [SWAP_FAILURE_SIGNAL] = "signal",
1445 [SWAP_FAILURE_CORE_DUMP] = "core-dump"
1448 DEFINE_STRING_TABLE_LOOKUP(swap_result, SwapResult);
1450 const UnitVTable swap_vtable = {
1451 .object_size = sizeof(Swap),
1452 .exec_context_offset = offsetof(Swap, exec_context),
1453 .cgroup_context_offset = offsetof(Swap, cgroup_context),
1454 .kill_context_offset = offsetof(Swap, kill_context),
1455 .exec_runtime_offset = offsetof(Swap, exec_runtime),
1461 .private_section = "Swap",
1464 .no_instances = true,
1470 .coldplug = swap_coldplug,
1474 .start = swap_start,
1479 .get_timeout = swap_get_timeout,
1481 .serialize = swap_serialize,
1482 .deserialize_item = swap_deserialize_item,
1484 .active_state = swap_active_state,
1485 .sub_state_to_string = swap_sub_state_to_string,
1487 .check_gc = swap_check_gc,
1489 .sigchld_event = swap_sigchld_event,
1491 .reset_failed = swap_reset_failed,
1493 .bus_interface = "org.freedesktop.systemd1.Swap",
1494 .bus_vtable = bus_swap_vtable,
1495 .bus_set_property = bus_swap_set_property,
1496 .bus_commit_properties = bus_swap_commit_properties,
1498 .following = swap_following,
1499 .following_set = swap_following_set,
1501 .enumerate = swap_enumerate,
1502 .shutdown = swap_shutdown,
1503 .supported = swap_supported,
1505 .status_message_formats = {
1506 .starting_stopping = {
1507 [0] = "Activating swap %s...",
1508 [1] = "Deactivating swap %s...",
1510 .finished_start_job = {
1511 [JOB_DONE] = "Activated swap %s.",
1512 [JOB_FAILED] = "Failed to activate swap %s.",
1513 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1514 [JOB_TIMEOUT] = "Timed out activating swap %s.",
1516 .finished_stop_job = {
1517 [JOB_DONE] = "Deactivated swap %s.",
1518 [JOB_FAILED] = "Failed deactivating swap %s.",
1519 [JOB_TIMEOUT] = "Timed out deactivating swap %s.",