1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2010 Lennart Poettering
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/epoll.h>
28 #include "alloc-util.h"
29 #include "dbus-swap.h"
31 #include "exit-status.h"
33 #include "format-util.h"
34 #include "fstab-util.h"
35 #include "parse-util.h"
36 #include "path-util.h"
37 #include "process-util.h"
39 #include "string-table.h"
40 #include "string-util.h"
42 #include "udev-util.h"
43 #include "unit-name.h"
47 static const UnitActiveState state_translation_table
[_SWAP_STATE_MAX
] = {
48 [SWAP_DEAD
] = UNIT_INACTIVE
,
49 [SWAP_ACTIVATING
] = UNIT_ACTIVATING
,
50 [SWAP_ACTIVATING_DONE
] = UNIT_ACTIVE
,
51 [SWAP_ACTIVE
] = UNIT_ACTIVE
,
52 [SWAP_DEACTIVATING
] = 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 bool SWAP_STATE_WITH_PROCESS(SwapState state
) {
66 SWAP_DEACTIVATING_SIGTERM
,
67 SWAP_DEACTIVATING_SIGKILL
);
70 static void swap_unset_proc_swaps(Swap
*s
) {
73 if (!s
->from_proc_swaps
)
76 s
->parameters_proc_swaps
.what
= mfree(s
->parameters_proc_swaps
.what
);
78 s
->from_proc_swaps
= false;
81 static int swap_set_devnode(Swap
*s
, const char *devnode
) {
88 r
= hashmap_ensure_allocated(&UNIT(s
)->manager
->swaps_by_devnode
, &string_hash_ops
);
92 swaps
= UNIT(s
)->manager
->swaps_by_devnode
;
95 first
= hashmap_get(swaps
, s
->devnode
);
97 LIST_REMOVE(same_devnode
, first
, s
);
99 hashmap_replace(swaps
, first
->devnode
, first
);
101 hashmap_remove(swaps
, s
->devnode
);
103 s
->devnode
= mfree(s
->devnode
);
107 s
->devnode
= strdup(devnode
);
111 first
= hashmap_get(swaps
, s
->devnode
);
112 LIST_PREPEND(same_devnode
, first
, s
);
114 return hashmap_replace(swaps
, first
->devnode
, first
);
120 static void swap_init(Unit
*u
) {
124 assert(UNIT(s
)->load_state
== UNIT_STUB
);
126 s
->timeout_usec
= u
->manager
->default_timeout_start_usec
;
128 s
->exec_context
.std_output
= u
->manager
->default_std_output
;
129 s
->exec_context
.std_error
= u
->manager
->default_std_error
;
131 s
->parameters_proc_swaps
.priority
= s
->parameters_fragment
.priority
= -1;
133 s
->control_command_id
= _SWAP_EXEC_COMMAND_INVALID
;
135 u
->ignore_on_isolate
= true;
138 static void swap_unwatch_control_pid(Swap
*s
) {
141 if (s
->control_pid
<= 0)
144 unit_unwatch_pid(UNIT(s
), s
->control_pid
);
148 static void swap_done(Unit
*u
) {
153 swap_unset_proc_swaps(s
);
154 swap_set_devnode(s
, NULL
);
156 s
->what
= mfree(s
->what
);
157 s
->parameters_fragment
.what
= mfree(s
->parameters_fragment
.what
);
158 s
->parameters_fragment
.options
= mfree(s
->parameters_fragment
.options
);
160 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
, false);
161 exec_command_done_array(s
->exec_command
, _SWAP_EXEC_COMMAND_MAX
);
162 s
->control_command
= NULL
;
164 dynamic_creds_unref(&s
->dynamic_creds
);
166 swap_unwatch_control_pid(s
);
168 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
171 static int swap_arm_timer(Swap
*s
, usec_t usec
) {
176 if (s
->timer_event_source
) {
177 r
= sd_event_source_set_time(s
->timer_event_source
, usec
);
181 return sd_event_source_set_enabled(s
->timer_event_source
, SD_EVENT_ONESHOT
);
184 if (usec
== USEC_INFINITY
)
187 r
= sd_event_add_time(
188 UNIT(s
)->manager
->event
,
189 &s
->timer_event_source
,
192 swap_dispatch_timer
, s
);
196 (void) sd_event_source_set_description(s
->timer_event_source
, "swap-timer");
201 static int swap_add_device_dependencies(Swap
*s
) {
207 if (!s
->from_fragment
)
210 if (is_device_path(s
->what
))
211 return unit_add_node_dependency(UNIT(s
), s
->what
, MANAGER_IS_SYSTEM(UNIT(s
)->manager
), UNIT_BINDS_TO
, UNIT_DEPENDENCY_FILE
);
213 /* File based swap devices need to be ordered after
214 * systemd-remount-fs.service, since they might need a
215 * writable file system. */
216 return unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, SPECIAL_REMOUNT_FS_SERVICE
, NULL
, true, UNIT_DEPENDENCY_FILE
);
219 static int swap_add_default_dependencies(Swap
*s
) {
224 if (!UNIT(s
)->default_dependencies
)
227 if (!MANAGER_IS_SYSTEM(UNIT(s
)->manager
))
230 if (detect_container() > 0)
233 /* swap units generated for the swap dev links are missing the
234 * ordering dep against the swap target. */
235 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_BEFORE
, SPECIAL_SWAP_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
239 return unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true, UNIT_DEPENDENCY_DEFAULT
);
242 static int swap_verify(Swap
*s
) {
243 _cleanup_free_
char *e
= NULL
;
246 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
249 r
= unit_name_from_path(s
->what
, ".swap", &e
);
251 return log_unit_error_errno(UNIT(s
), r
, "Failed to generate unit name from path: %m");
253 if (!unit_has_name(UNIT(s
), e
)) {
254 log_unit_error(UNIT(s
), "Value of What= and unit name do not match, not loading.");
258 if (s
->exec_context
.pam_name
&& s
->kill_context
.kill_mode
!= KILL_CONTROL_GROUP
) {
259 log_unit_error(UNIT(s
), "Unit has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.");
266 static int swap_load_devnode(Swap
*s
) {
267 _cleanup_udev_device_unref_
struct udev_device
*d
= NULL
;
273 if (stat(s
->what
, &st
) < 0 || !S_ISBLK(st
.st_mode
))
276 d
= udev_device_new_from_devnum(UNIT(s
)->manager
->udev
, 'b', st
.st_rdev
);
280 p
= udev_device_get_devnode(d
);
284 return swap_set_devnode(s
, p
);
287 static int swap_load(Unit
*u
) {
292 assert(u
->load_state
== UNIT_STUB
);
294 /* Load a .swap file */
295 if (SWAP(u
)->from_proc_swaps
)
296 r
= unit_load_fragment_and_dropin_optional(u
);
298 r
= unit_load_fragment_and_dropin(u
);
302 if (u
->load_state
== UNIT_LOADED
) {
304 if (UNIT(s
)->fragment_path
)
305 s
->from_fragment
= true;
308 if (s
->parameters_fragment
.what
)
309 s
->what
= strdup(s
->parameters_fragment
.what
);
310 else if (s
->parameters_proc_swaps
.what
)
311 s
->what
= strdup(s
->parameters_proc_swaps
.what
);
313 r
= unit_name_to_path(u
->id
, &s
->what
);
322 path_kill_slashes(s
->what
);
324 if (!UNIT(s
)->description
) {
325 r
= unit_set_description(u
, s
->what
);
330 r
= unit_require_mounts_for(UNIT(s
), s
->what
, UNIT_DEPENDENCY_IMPLICIT
);
334 r
= swap_add_device_dependencies(s
);
338 r
= swap_load_devnode(s
);
342 r
= unit_patch_contexts(u
);
346 r
= unit_add_exec_dependencies(u
, &s
->exec_context
);
350 r
= unit_set_default_slice(u
);
354 r
= swap_add_default_dependencies(s
);
359 return swap_verify(s
);
362 static int swap_setup_unit(
365 const char *what_proc_swaps
,
369 _cleanup_free_
char *e
= NULL
;
377 assert(what_proc_swaps
);
379 r
= unit_name_from_path(what
, ".swap", &e
);
381 return log_unit_error_errno(u
, r
, "Failed to generate unit name from path: %m");
383 u
= manager_get_unit(m
, e
);
386 SWAP(u
)->from_proc_swaps
&&
387 !path_equal(SWAP(u
)->parameters_proc_swaps
.what
, what_proc_swaps
)) {
388 log_error("Swap %s appeared twice with different device paths %s and %s", e
, SWAP(u
)->parameters_proc_swaps
.what
, what_proc_swaps
);
395 r
= unit_new_for_name(m
, sizeof(Swap
), e
, &u
);
399 SWAP(u
)->what
= strdup(what
);
400 if (!SWAP(u
)->what
) {
405 unit_add_to_load_queue(u
);
409 p
= &SWAP(u
)->parameters_proc_swaps
;
412 p
->what
= strdup(what_proc_swaps
);
420 SWAP(u
)->is_active
= true;
421 SWAP(u
)->just_activated
= !SWAP(u
)->from_proc_swaps
;
424 SWAP(u
)->from_proc_swaps
= true;
426 p
->priority
= priority
;
428 unit_add_to_dbus_queue(u
);
432 log_unit_warning_errno(u
, r
, "Failed to load swap unit: %m");
440 static int swap_process_new(Manager
*m
, const char *device
, int prio
, bool set_flags
) {
441 _cleanup_udev_device_unref_
struct udev_device
*d
= NULL
;
442 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
449 r
= swap_setup_unit(m
, device
, device
, prio
, set_flags
);
453 /* If this is a block device, then let's add duplicates for
454 * all other names of this block device */
455 if (stat(device
, &st
) < 0 || !S_ISBLK(st
.st_mode
))
458 d
= udev_device_new_from_devnum(m
->udev
, 'b', st
.st_rdev
);
462 /* Add the main device node */
463 dn
= udev_device_get_devnode(d
);
464 if (dn
&& !streq(dn
, device
))
465 swap_setup_unit(m
, dn
, device
, prio
, set_flags
);
467 /* Add additional units for all symlinks */
468 first
= udev_device_get_devlinks_list_entry(d
);
469 udev_list_entry_foreach(item
, first
) {
472 /* Don't bother with the /dev/block links */
473 p
= udev_list_entry_get_name(item
);
475 if (streq(p
, device
))
478 if (path_startswith(p
, "/dev/block/"))
481 if (stat(p
, &st
) >= 0)
482 if (!S_ISBLK(st
.st_mode
) ||
483 st
.st_rdev
!= udev_device_get_devnum(d
))
486 swap_setup_unit(m
, p
, device
, prio
, set_flags
);
492 static void swap_set_state(Swap
*s
, SwapState state
) {
498 old_state
= s
->state
;
501 if (!SWAP_STATE_WITH_PROCESS(state
)) {
502 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
503 swap_unwatch_control_pid(s
);
504 s
->control_command
= NULL
;
505 s
->control_command_id
= _SWAP_EXEC_COMMAND_INVALID
;
508 if (state
!= old_state
)
509 log_unit_debug(UNIT(s
), "Changed %s -> %s", swap_state_to_string(old_state
), swap_state_to_string(state
));
511 unit_notify(UNIT(s
), state_translation_table
[old_state
], state_translation_table
[state
], true);
513 /* If there other units for the same device node have a job
514 queued it might be worth checking again if it is runnable
515 now. This is necessary, since swap_start() refuses
516 operation with EAGAIN if there's already another job for
517 the same device node queued. */
518 LIST_FOREACH_OTHERS(same_devnode
, other
, s
)
519 if (UNIT(other
)->job
)
520 job_add_to_run_queue(UNIT(other
)->job
);
523 static int swap_coldplug(Unit
*u
) {
525 SwapState new_state
= SWAP_DEAD
;
529 assert(s
->state
== SWAP_DEAD
);
531 if (s
->deserialized_state
!= s
->state
)
532 new_state
= s
->deserialized_state
;
533 else if (s
->from_proc_swaps
)
534 new_state
= SWAP_ACTIVE
;
536 if (new_state
== s
->state
)
539 if (s
->control_pid
> 0 &&
540 pid_is_unwaited(s
->control_pid
) &&
541 SWAP_STATE_WITH_PROCESS(new_state
)) {
543 r
= unit_watch_pid(UNIT(s
), s
->control_pid
);
547 r
= swap_arm_timer(s
, usec_add(u
->state_change_timestamp
.monotonic
, s
->timeout_usec
));
552 if (!IN_SET(new_state
, SWAP_DEAD
, SWAP_FAILED
)) {
553 (void) unit_setup_dynamic_creds(u
);
554 (void) unit_setup_exec_runtime(u
);
557 swap_set_state(s
, new_state
);
561 static void swap_dump(Unit
*u
, FILE *f
, const char *prefix
) {
562 char buf
[FORMAT_TIMESPAN_MAX
] = {};
569 if (s
->from_proc_swaps
)
570 p
= &s
->parameters_proc_swaps
;
571 else if (s
->from_fragment
)
572 p
= &s
->parameters_fragment
;
580 "%sFrom /proc/swaps: %s\n"
581 "%sFrom fragment: %s\n",
582 prefix
, swap_state_to_string(s
->state
),
583 prefix
, swap_result_to_string(s
->result
),
585 prefix
, yes_no(s
->from_proc_swaps
),
586 prefix
, yes_no(s
->from_fragment
));
589 fprintf(f
, "%sDevice Node: %s\n", prefix
, s
->devnode
);
596 prefix
, strempty(p
->options
));
599 "%sTimeoutSec: %s\n",
600 prefix
, format_timespan(buf
, sizeof(buf
), s
->timeout_usec
, USEC_PER_SEC
));
602 if (s
->control_pid
> 0)
604 "%sControl PID: "PID_FMT
"\n",
605 prefix
, s
->control_pid
);
607 exec_context_dump(&s
->exec_context
, f
, prefix
);
608 kill_context_dump(&s
->kill_context
, f
, prefix
);
609 cgroup_context_dump(&s
->cgroup_context
, f
, prefix
);
612 static int swap_spawn(Swap
*s
, ExecCommand
*c
, pid_t
*_pid
) {
614 ExecParameters exec_params
= {
615 .flags
= EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
,
627 r
= unit_prepare_exec(UNIT(s
));
631 r
= swap_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_usec
));
635 manager_set_exec_params(UNIT(s
)->manager
, &exec_params
);
636 unit_set_exec_params(UNIT(s
), &exec_params
);
638 r
= exec_spawn(UNIT(s
),
648 r
= unit_watch_pid(UNIT(s
), pid
);
650 /* FIXME: we need to do something here */
658 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
663 static void swap_enter_dead(Swap
*s
, SwapResult f
) {
666 if (s
->result
== SWAP_SUCCESS
)
669 if (s
->result
!= SWAP_SUCCESS
)
670 log_unit_warning(UNIT(s
), "Failed with result '%s'.", swap_result_to_string(s
->result
));
672 swap_set_state(s
, s
->result
!= SWAP_SUCCESS
? SWAP_FAILED
: SWAP_DEAD
);
674 s
->exec_runtime
= exec_runtime_unref(s
->exec_runtime
, true);
676 exec_context_destroy_runtime_directory(&s
->exec_context
, UNIT(s
)->manager
->prefix
[EXEC_DIRECTORY_RUNTIME
]);
678 unit_unref_uid_gid(UNIT(s
), true);
680 dynamic_creds_destroy(&s
->dynamic_creds
);
683 static void swap_enter_active(Swap
*s
, SwapResult f
) {
686 if (s
->result
== SWAP_SUCCESS
)
689 swap_set_state(s
, SWAP_ACTIVE
);
692 static void swap_enter_dead_or_active(Swap
*s
, SwapResult f
) {
695 if (s
->from_proc_swaps
)
696 swap_enter_active(s
, f
);
698 swap_enter_dead(s
, f
);
701 static void swap_enter_signal(Swap
*s
, SwapState state
, SwapResult f
) {
707 if (s
->result
== SWAP_SUCCESS
)
710 if (state
== SWAP_DEACTIVATING_SIGTERM
)
711 kop
= KILL_TERMINATE
;
715 r
= unit_kill_context(UNIT(s
), &s
->kill_context
, kop
, -1, s
->control_pid
, false);
720 r
= swap_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_usec
));
724 swap_set_state(s
, state
);
725 } else if (state
== SWAP_DEACTIVATING_SIGTERM
&& s
->kill_context
.send_sigkill
)
726 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGKILL
, SWAP_SUCCESS
);
728 swap_enter_dead_or_active(s
, SWAP_SUCCESS
);
733 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
734 swap_enter_dead_or_active(s
, SWAP_FAILURE_RESOURCES
);
737 static void swap_enter_activating(Swap
*s
) {
738 _cleanup_free_
char *opts
= NULL
;
743 unit_warn_leftover_processes(UNIT(s
));
745 s
->control_command_id
= SWAP_EXEC_ACTIVATE
;
746 s
->control_command
= s
->exec_command
+ SWAP_EXEC_ACTIVATE
;
748 if (s
->from_fragment
) {
751 r
= fstab_find_pri(s
->parameters_fragment
.options
, &priority
);
753 log_warning_errno(r
, "Failed to parse swap priority \"%s\", ignoring: %m", s
->parameters_fragment
.options
);
754 else if (r
== 1 && s
->parameters_fragment
.priority
>= 0)
755 log_warning("Duplicate swap priority configuration by Priority and Options fields.");
757 if (r
<= 0 && s
->parameters_fragment
.priority
>= 0) {
758 if (s
->parameters_fragment
.options
)
759 r
= asprintf(&opts
, "%s,pri=%i", s
->parameters_fragment
.options
, s
->parameters_fragment
.priority
);
761 r
= asprintf(&opts
, "pri=%i", s
->parameters_fragment
.priority
);
767 r
= exec_command_set(s
->control_command
, "/sbin/swapon", NULL
);
771 if (s
->parameters_fragment
.options
|| opts
) {
772 r
= exec_command_append(s
->control_command
, "-o",
773 opts
? : s
->parameters_fragment
.options
, NULL
);
778 r
= exec_command_append(s
->control_command
, s
->what
, NULL
);
782 swap_unwatch_control_pid(s
);
784 r
= swap_spawn(s
, s
->control_command
, &s
->control_pid
);
788 swap_set_state(s
, SWAP_ACTIVATING
);
793 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'swapon' task: %m");
794 swap_enter_dead_or_active(s
, SWAP_FAILURE_RESOURCES
);
797 static void swap_enter_deactivating(Swap
*s
) {
802 s
->control_command_id
= SWAP_EXEC_DEACTIVATE
;
803 s
->control_command
= s
->exec_command
+ SWAP_EXEC_DEACTIVATE
;
805 r
= exec_command_set(s
->control_command
,
812 swap_unwatch_control_pid(s
);
814 r
= swap_spawn(s
, s
->control_command
, &s
->control_pid
);
818 swap_set_state(s
, SWAP_DEACTIVATING
);
823 log_unit_warning_errno(UNIT(s
), r
, "Failed to run 'swapoff' task: %m");
824 swap_enter_dead_or_active(s
, SWAP_FAILURE_RESOURCES
);
827 static int swap_start(Unit
*u
) {
828 Swap
*s
= SWAP(u
), *other
;
833 /* We cannot fulfill this request right now, try again later please! */
836 SWAP_DEACTIVATING_SIGTERM
,
837 SWAP_DEACTIVATING_SIGKILL
))
841 if (s
->state
== SWAP_ACTIVATING
)
844 assert(IN_SET(s
->state
, SWAP_DEAD
, SWAP_FAILED
));
846 if (detect_container() > 0)
849 /* If there's a job for another swap unit for the same node
850 * running, then let's not dispatch this one for now, and wait
851 * until that other job has finished. */
852 LIST_FOREACH_OTHERS(same_devnode
, other
, s
)
853 if (UNIT(other
)->job
&& UNIT(other
)->job
->state
== JOB_RUNNING
)
856 r
= unit_start_limit_test(u
);
858 swap_enter_dead(s
, SWAP_FAILURE_START_LIMIT_HIT
);
862 r
= unit_acquire_invocation_id(u
);
866 s
->result
= SWAP_SUCCESS
;
868 u
->reset_accounting
= true;
870 swap_enter_activating(s
);
874 static int swap_stop(Unit
*u
) {
881 case SWAP_DEACTIVATING
:
882 case SWAP_DEACTIVATING_SIGTERM
:
883 case SWAP_DEACTIVATING_SIGKILL
:
887 case SWAP_ACTIVATING
:
888 case SWAP_ACTIVATING_DONE
:
889 /* There's a control process pending, directly enter kill mode */
890 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGTERM
, SWAP_SUCCESS
);
894 if (detect_container() > 0)
897 swap_enter_deactivating(s
);
901 assert_not_reached("Unexpected state.");
905 static int swap_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
912 unit_serialize_item(u
, f
, "state", swap_state_to_string(s
->state
));
913 unit_serialize_item(u
, f
, "result", swap_result_to_string(s
->result
));
915 if (s
->control_pid
> 0)
916 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, s
->control_pid
);
918 if (s
->control_command_id
>= 0)
919 unit_serialize_item(u
, f
, "control-command", swap_exec_command_to_string(s
->control_command_id
));
924 static int swap_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
930 if (streq(key
, "state")) {
933 state
= swap_state_from_string(value
);
935 log_unit_debug(u
, "Failed to parse state value: %s", value
);
937 s
->deserialized_state
= state
;
938 } else if (streq(key
, "result")) {
941 f
= swap_result_from_string(value
);
943 log_unit_debug(u
, "Failed to parse result value: %s", value
);
944 else if (f
!= SWAP_SUCCESS
)
946 } else if (streq(key
, "control-pid")) {
949 if (parse_pid(value
, &pid
) < 0)
950 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
952 s
->control_pid
= pid
;
954 } else if (streq(key
, "control-command")) {
957 id
= swap_exec_command_from_string(value
);
959 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
961 s
->control_command_id
= id
;
962 s
->control_command
= s
->exec_command
+ id
;
965 log_unit_debug(u
, "Unknown serialization key: %s", key
);
970 _pure_
static UnitActiveState
swap_active_state(Unit
*u
) {
973 return state_translation_table
[SWAP(u
)->state
];
976 _pure_
static const char *swap_sub_state_to_string(Unit
*u
) {
979 return swap_state_to_string(SWAP(u
)->state
);
982 _pure_
static bool swap_check_gc(Unit
*u
) {
987 return s
->from_proc_swaps
;
990 static void swap_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
997 if (pid
!= s
->control_pid
)
1002 if (is_clean_exit(code
, status
, EXIT_CLEAN_COMMAND
, NULL
))
1004 else if (code
== CLD_EXITED
)
1005 f
= SWAP_FAILURE_EXIT_CODE
;
1006 else if (code
== CLD_KILLED
)
1007 f
= SWAP_FAILURE_SIGNAL
;
1008 else if (code
== CLD_DUMPED
)
1009 f
= SWAP_FAILURE_CORE_DUMP
;
1011 assert_not_reached("Unknown code");
1013 if (s
->result
== SWAP_SUCCESS
)
1016 if (s
->control_command
) {
1017 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
1019 s
->control_command
= NULL
;
1020 s
->control_command_id
= _SWAP_EXEC_COMMAND_INVALID
;
1023 log_unit_full(u
, f
== SWAP_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
1024 "Swap process exited, code=%s status=%i", sigchld_code_to_string(code
), status
);
1028 case SWAP_ACTIVATING
:
1029 case SWAP_ACTIVATING_DONE
:
1031 if (f
== SWAP_SUCCESS
|| s
->from_proc_swaps
)
1032 swap_enter_active(s
, f
);
1034 swap_enter_dead(s
, f
);
1037 case SWAP_DEACTIVATING
:
1038 case SWAP_DEACTIVATING_SIGKILL
:
1039 case SWAP_DEACTIVATING_SIGTERM
:
1041 swap_enter_dead_or_active(s
, f
);
1045 assert_not_reached("Uh, control process died at wrong time.");
1048 /* Notify clients about changed exit status */
1049 unit_add_to_dbus_queue(u
);
1052 static int swap_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
1053 Swap
*s
= SWAP(userdata
);
1056 assert(s
->timer_event_source
== source
);
1060 case SWAP_ACTIVATING
:
1061 case SWAP_ACTIVATING_DONE
:
1062 log_unit_warning(UNIT(s
), "Activation timed out. Stopping.");
1063 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGTERM
, SWAP_FAILURE_TIMEOUT
);
1066 case SWAP_DEACTIVATING
:
1067 log_unit_warning(UNIT(s
), "Deactivation timed out. Stopping.");
1068 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGTERM
, SWAP_FAILURE_TIMEOUT
);
1071 case SWAP_DEACTIVATING_SIGTERM
:
1072 if (s
->kill_context
.send_sigkill
) {
1073 log_unit_warning(UNIT(s
), "Swap process timed out. Killing.");
1074 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGKILL
, SWAP_FAILURE_TIMEOUT
);
1076 log_unit_warning(UNIT(s
), "Swap process timed out. Skipping SIGKILL. Ignoring.");
1077 swap_enter_dead_or_active(s
, SWAP_FAILURE_TIMEOUT
);
1081 case SWAP_DEACTIVATING_SIGKILL
:
1082 log_unit_warning(UNIT(s
), "Swap process still around after SIGKILL. Ignoring.");
1083 swap_enter_dead_or_active(s
, SWAP_FAILURE_TIMEOUT
);
1087 assert_not_reached("Timeout at wrong time.");
1093 static int swap_load_proc_swaps(Manager
*m
, bool set_flags
) {
1099 rewind(m
->proc_swaps
);
1101 (void) fscanf(m
->proc_swaps
, "%*s %*s %*s %*s %*s\n");
1104 _cleanup_free_
char *dev
= NULL
, *d
= NULL
;
1107 k
= fscanf(m
->proc_swaps
,
1108 "%ms " /* device/file */
1109 "%*s " /* type of swap */
1110 "%*s " /* swap size */
1112 "%i\n", /* priority */
1118 log_warning("Failed to parse /proc/swaps:%u.", i
);
1122 if (cunescape(dev
, UNESCAPE_RELAX
, &d
) < 0)
1125 device_found_node(m
, d
, true, DEVICE_FOUND_SWAP
, set_flags
);
1127 k
= swap_process_new(m
, d
, prio
, set_flags
);
1135 static int swap_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
1136 Manager
*m
= userdata
;
1141 assert(revents
& EPOLLPRI
);
1143 r
= swap_load_proc_swaps(m
, true);
1145 log_error_errno(r
, "Failed to reread /proc/swaps: %m");
1147 /* Reset flags, just in case, for late calls */
1148 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_SWAP
]) {
1149 Swap
*swap
= SWAP(u
);
1151 swap
->is_active
= swap
->just_activated
= false;
1157 manager_dispatch_load_queue(m
);
1159 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_SWAP
]) {
1160 Swap
*swap
= SWAP(u
);
1162 if (!swap
->is_active
) {
1163 /* This has just been deactivated */
1165 swap_unset_proc_swaps(swap
);
1167 switch (swap
->state
) {
1170 swap_enter_dead(swap
, SWAP_SUCCESS
);
1175 swap_set_state(swap
, swap
->state
);
1180 device_found_node(m
, swap
->what
, false, DEVICE_FOUND_SWAP
, true);
1182 } else if (swap
->just_activated
) {
1184 /* New swap entry */
1186 switch (swap
->state
) {
1190 (void) unit_acquire_invocation_id(UNIT(swap
));
1191 swap_enter_active(swap
, SWAP_SUCCESS
);
1194 case SWAP_ACTIVATING
:
1195 swap_set_state(swap
, SWAP_ACTIVATING_DONE
);
1199 /* Nothing really changed, but let's
1200 * issue an notification call
1201 * nonetheless, in case somebody is
1202 * waiting for this. */
1203 swap_set_state(swap
, swap
->state
);
1208 /* Reset the flags for later calls */
1209 swap
->is_active
= swap
->just_activated
= false;
1215 static Unit
*swap_following(Unit
*u
) {
1217 Swap
*other
, *first
= NULL
;
1221 /* If the user configured the swap through /etc/fstab or
1222 * a device unit, follow that. */
1224 if (s
->from_fragment
)
1227 LIST_FOREACH_OTHERS(same_devnode
, other
, s
)
1228 if (other
->from_fragment
)
1231 /* Otherwise, make everybody follow the unit that's named after
1232 * the swap device in the kernel */
1234 if (streq_ptr(s
->what
, s
->devnode
))
1237 LIST_FOREACH_AFTER(same_devnode
, other
, s
)
1238 if (streq_ptr(other
->what
, other
->devnode
))
1241 LIST_FOREACH_BEFORE(same_devnode
, other
, s
) {
1242 if (streq_ptr(other
->what
, other
->devnode
))
1248 /* Fall back to the first on the list */
1252 static int swap_following_set(Unit
*u
, Set
**_set
) {
1253 Swap
*s
= SWAP(u
), *other
;
1260 if (LIST_JUST_US(same_devnode
, s
)) {
1265 set
= set_new(NULL
);
1269 LIST_FOREACH_OTHERS(same_devnode
, other
, s
) {
1270 r
= set_put(set
, other
);
1283 static void swap_shutdown(Manager
*m
) {
1286 m
->swap_event_source
= sd_event_source_unref(m
->swap_event_source
);
1288 m
->proc_swaps
= safe_fclose(m
->proc_swaps
);
1290 m
->swaps_by_devnode
= hashmap_free(m
->swaps_by_devnode
);
1293 static void swap_enumerate(Manager
*m
) {
1298 if (!m
->proc_swaps
) {
1299 m
->proc_swaps
= fopen("/proc/swaps", "re");
1300 if (!m
->proc_swaps
) {
1301 if (errno
== ENOENT
)
1302 log_debug("Not swap enabled, skipping enumeration");
1304 log_error_errno(errno
, "Failed to open /proc/swaps: %m");
1309 r
= sd_event_add_io(m
->event
, &m
->swap_event_source
, fileno(m
->proc_swaps
), EPOLLPRI
, swap_dispatch_io
, m
);
1311 log_error_errno(r
, "Failed to watch /proc/swaps: %m");
1315 /* Dispatch this before we dispatch SIGCHLD, so that
1316 * we always get the events from /proc/swaps before
1317 * the SIGCHLD of /sbin/swapon. */
1318 r
= sd_event_source_set_priority(m
->swap_event_source
, SD_EVENT_PRIORITY_NORMAL
-10);
1320 log_error_errno(r
, "Failed to change /proc/swaps priority: %m");
1324 (void) sd_event_source_set_description(m
->swap_event_source
, "swap-proc");
1327 r
= swap_load_proc_swaps(m
, false);
1337 int swap_process_device_new(Manager
*m
, struct udev_device
*dev
) {
1338 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
1339 _cleanup_free_
char *e
= NULL
;
1347 dn
= udev_device_get_devnode(dev
);
1351 r
= unit_name_from_path(dn
, ".swap", &e
);
1355 u
= manager_get_unit(m
, e
);
1357 r
= swap_set_devnode(SWAP(u
), dn
);
1359 first
= udev_device_get_devlinks_list_entry(dev
);
1360 udev_list_entry_foreach(item
, first
) {
1361 _cleanup_free_
char *n
= NULL
;
1364 q
= unit_name_from_path(udev_list_entry_get_name(item
), ".swap", &n
);
1368 u
= manager_get_unit(m
, n
);
1370 q
= swap_set_devnode(SWAP(u
), dn
);
1379 int swap_process_device_remove(Manager
*m
, struct udev_device
*dev
) {
1384 dn
= udev_device_get_devnode(dev
);
1388 while ((s
= hashmap_get(m
->swaps_by_devnode
, dn
))) {
1391 q
= swap_set_devnode(s
, NULL
);
1399 static void swap_reset_failed(Unit
*u
) {
1404 if (s
->state
== SWAP_FAILED
)
1405 swap_set_state(s
, SWAP_DEAD
);
1407 s
->result
= SWAP_SUCCESS
;
1410 static int swap_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
1411 return unit_kill_common(u
, who
, signo
, -1, SWAP(u
)->control_pid
, error
);
1414 static int swap_get_timeout(Unit
*u
, usec_t
*timeout
) {
1419 if (!s
->timer_event_source
)
1422 r
= sd_event_source_get_time(s
->timer_event_source
, &t
);
1425 if (t
== USEC_INFINITY
)
1432 static bool swap_supported(void) {
1433 static int supported
= -1;
1435 /* If swap support is not available in the kernel, or we are
1436 * running in a container we don't support swap units, and any
1437 * attempts to starting one should fail immediately. */
1441 access("/proc/swaps", F_OK
) >= 0 &&
1442 detect_container() <= 0;
1447 static int swap_control_pid(Unit
*u
) {
1452 return s
->control_pid
;
1455 static const char* const swap_exec_command_table
[_SWAP_EXEC_COMMAND_MAX
] = {
1456 [SWAP_EXEC_ACTIVATE
] = "ExecActivate",
1457 [SWAP_EXEC_DEACTIVATE
] = "ExecDeactivate",
1460 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command
, SwapExecCommand
);
1462 static const char* const swap_result_table
[_SWAP_RESULT_MAX
] = {
1463 [SWAP_SUCCESS
] = "success",
1464 [SWAP_FAILURE_RESOURCES
] = "resources",
1465 [SWAP_FAILURE_TIMEOUT
] = "timeout",
1466 [SWAP_FAILURE_EXIT_CODE
] = "exit-code",
1467 [SWAP_FAILURE_SIGNAL
] = "signal",
1468 [SWAP_FAILURE_CORE_DUMP
] = "core-dump",
1469 [SWAP_FAILURE_START_LIMIT_HIT
] = "start-limit-hit",
1472 DEFINE_STRING_TABLE_LOOKUP(swap_result
, SwapResult
);
1474 const UnitVTable swap_vtable
= {
1475 .object_size
= sizeof(Swap
),
1476 .exec_context_offset
= offsetof(Swap
, exec_context
),
1477 .cgroup_context_offset
= offsetof(Swap
, cgroup_context
),
1478 .kill_context_offset
= offsetof(Swap
, kill_context
),
1479 .exec_runtime_offset
= offsetof(Swap
, exec_runtime
),
1480 .dynamic_creds_offset
= offsetof(Swap
, dynamic_creds
),
1486 .private_section
= "Swap",
1492 .coldplug
= swap_coldplug
,
1496 .start
= swap_start
,
1501 .get_timeout
= swap_get_timeout
,
1503 .serialize
= swap_serialize
,
1504 .deserialize_item
= swap_deserialize_item
,
1506 .active_state
= swap_active_state
,
1507 .sub_state_to_string
= swap_sub_state_to_string
,
1509 .check_gc
= swap_check_gc
,
1511 .sigchld_event
= swap_sigchld_event
,
1513 .reset_failed
= swap_reset_failed
,
1515 .control_pid
= swap_control_pid
,
1517 .bus_vtable
= bus_swap_vtable
,
1518 .bus_set_property
= bus_swap_set_property
,
1519 .bus_commit_properties
= bus_swap_commit_properties
,
1521 .following
= swap_following
,
1522 .following_set
= swap_following_set
,
1524 .enumerate
= swap_enumerate
,
1525 .shutdown
= swap_shutdown
,
1526 .supported
= swap_supported
,
1528 .status_message_formats
= {
1529 .starting_stopping
= {
1530 [0] = "Activating swap %s...",
1531 [1] = "Deactivating swap %s...",
1533 .finished_start_job
= {
1534 [JOB_DONE
] = "Activated swap %s.",
1535 [JOB_FAILED
] = "Failed to activate swap %s.",
1536 [JOB_TIMEOUT
] = "Timed out activating swap %s.",
1538 .finished_stop_job
= {
1539 [JOB_DONE
] = "Deactivated swap %s.",
1540 [JOB_FAILED
] = "Failed deactivating swap %s.",
1541 [JOB_TIMEOUT
] = "Timed out deactivating swap %s.",