1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
10 #include "alloc-util.h"
11 #include "dbus-swap.h"
12 #include "dbus-unit.h"
13 #include "device-util.h"
16 #include "exit-status.h"
18 #include "format-util.h"
19 #include "fstab-util.h"
20 #include "parse-util.h"
21 #include "path-util.h"
22 #include "process-util.h"
23 #include "serialize.h"
25 #include "string-table.h"
26 #include "string-util.h"
28 #include "unit-name.h"
32 static const UnitActiveState state_translation_table
[_SWAP_STATE_MAX
] = {
33 [SWAP_DEAD
] = UNIT_INACTIVE
,
34 [SWAP_ACTIVATING
] = UNIT_ACTIVATING
,
35 [SWAP_ACTIVATING_DONE
] = UNIT_ACTIVE
,
36 [SWAP_ACTIVE
] = UNIT_ACTIVE
,
37 [SWAP_DEACTIVATING
] = UNIT_DEACTIVATING
,
38 [SWAP_DEACTIVATING_SIGTERM
] = UNIT_DEACTIVATING
,
39 [SWAP_DEACTIVATING_SIGKILL
] = UNIT_DEACTIVATING
,
40 [SWAP_FAILED
] = UNIT_FAILED
,
41 [SWAP_CLEANING
] = UNIT_MAINTENANCE
,
44 static int swap_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
45 static int swap_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
);
46 static int swap_process_proc_swaps(Manager
*m
);
48 static bool SWAP_STATE_WITH_PROCESS(SwapState state
) {
53 SWAP_DEACTIVATING_SIGTERM
,
54 SWAP_DEACTIVATING_SIGKILL
,
58 static UnitActiveState
swap_active_state(Unit
*u
) {
61 return state_translation_table
[SWAP(u
)->state
];
64 static const char *swap_sub_state_to_string(Unit
*u
) {
67 return swap_state_to_string(SWAP(u
)->state
);
70 static bool swap_may_gc(Unit
*u
) {
71 Swap
*s
= ASSERT_PTR(SWAP(u
));
73 if (s
->from_proc_swaps
)
79 static bool swap_is_extrinsic(Unit
*u
) {
82 return MANAGER_IS_USER(u
->manager
);
85 static void swap_unset_proc_swaps(Swap
*s
) {
88 if (!s
->from_proc_swaps
)
91 s
->parameters_proc_swaps
.what
= mfree(s
->parameters_proc_swaps
.what
);
92 s
->from_proc_swaps
= false;
95 static int swap_set_devnode(Swap
*s
, const char *devnode
) {
102 r
= hashmap_ensure_allocated(&UNIT(s
)->manager
->swaps_by_devnode
, &path_hash_ops
);
106 swaps
= UNIT(s
)->manager
->swaps_by_devnode
;
109 first
= hashmap_get(swaps
, s
->devnode
);
111 LIST_REMOVE(same_devnode
, first
, s
);
113 hashmap_replace(swaps
, first
->devnode
, first
);
115 hashmap_remove(swaps
, s
->devnode
);
117 s
->devnode
= mfree(s
->devnode
);
121 s
->devnode
= strdup(devnode
);
125 first
= hashmap_get(swaps
, s
->devnode
);
126 LIST_PREPEND(same_devnode
, first
, s
);
128 return hashmap_replace(swaps
, first
->devnode
, first
);
134 static void swap_init(Unit
*u
) {
135 Swap
*s
= ASSERT_PTR(SWAP(u
));
137 assert(u
->load_state
== UNIT_STUB
);
139 s
->timeout_usec
= u
->manager
->defaults
.timeout_start_usec
;
141 s
->exec_context
.std_output
= u
->manager
->defaults
.std_output
;
142 s
->exec_context
.std_error
= u
->manager
->defaults
.std_error
;
144 s
->control_pid
= PIDREF_NULL
;
145 s
->control_command_id
= _SWAP_EXEC_COMMAND_INVALID
;
147 u
->ignore_on_isolate
= true;
150 static void swap_unwatch_control_pid(Swap
*s
) {
152 unit_unwatch_pidref_done(UNIT(s
), &s
->control_pid
);
155 static void swap_done(Unit
*u
) {
156 Swap
*s
= ASSERT_PTR(SWAP(u
));
158 swap_unset_proc_swaps(s
);
159 swap_set_devnode(s
, NULL
);
161 s
->what
= mfree(s
->what
);
162 s
->parameters_fragment
.what
= mfree(s
->parameters_fragment
.what
);
163 s
->parameters_fragment
.options
= mfree(s
->parameters_fragment
.options
);
165 s
->exec_runtime
= exec_runtime_free(s
->exec_runtime
);
167 exec_command_done_array(s
->exec_command
, _SWAP_EXEC_COMMAND_MAX
);
168 s
->control_command
= NULL
;
170 swap_unwatch_control_pid(s
);
172 s
->timer_event_source
= sd_event_source_disable_unref(s
->timer_event_source
);
175 static int swap_arm_timer(Swap
*s
, bool relative
, usec_t usec
) {
178 return unit_arm_timer(UNIT(s
), &s
->timer_event_source
, relative
, usec
, swap_dispatch_timer
);
181 static SwapParameters
* swap_get_parameters(Swap
*s
) {
184 if (s
->from_proc_swaps
)
185 return &s
->parameters_proc_swaps
;
187 if (s
->from_fragment
)
188 return &s
->parameters_fragment
;
193 static int swap_add_device_dependencies(Swap
*s
) {
194 UnitDependencyMask mask
;
203 p
= swap_get_parameters(s
);
207 mask
= s
->from_proc_swaps
? UNIT_DEPENDENCY_PROC_SWAP
: UNIT_DEPENDENCY_FILE
;
209 if (is_device_path(p
->what
)) {
210 r
= unit_add_node_dependency(UNIT(s
), p
->what
, UNIT_REQUIRES
, mask
);
214 return unit_add_blockdev_dependency(UNIT(s
), p
->what
, mask
);
217 /* File based swap devices need to be ordered after systemd-remount-fs.service, since they might need
218 * a writable file system. */
219 return unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, SPECIAL_REMOUNT_FS_SERVICE
, true, mask
);
222 static int swap_add_default_dependencies(Swap
*s
) {
227 if (!UNIT(s
)->default_dependencies
)
230 if (!MANAGER_IS_SYSTEM(UNIT(s
)->manager
))
233 if (detect_container() > 0)
236 /* swap units generated for the swap dev links are missing the
237 * ordering dep against the swap target. */
238 r
= unit_add_dependency_by_name(UNIT(s
), UNIT_BEFORE
, SPECIAL_SWAP_TARGET
, true, UNIT_DEPENDENCY_DEFAULT
);
242 return unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, true, UNIT_DEPENDENCY_DEFAULT
);
245 static int swap_verify(Swap
*s
) {
246 _cleanup_free_
char *e
= NULL
;
250 assert(UNIT(s
)->load_state
== UNIT_LOADED
);
252 r
= unit_name_from_path(s
->what
, ".swap", &e
);
254 return log_unit_error_errno(UNIT(s
), r
, "Failed to generate unit name from path: %m");
256 if (!unit_has_name(UNIT(s
), e
))
257 return log_unit_error_errno(UNIT(s
), SYNTHETIC_ERRNO(ENOEXEC
), "Value of What= and unit name do not match, not loading.");
259 if (s
->exec_context
.pam_name
&& s
->kill_context
.kill_mode
!= KILL_CONTROL_GROUP
)
260 return log_unit_error_errno(UNIT(s
), SYNTHETIC_ERRNO(ENOEXEC
), "Unit has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.");
265 static int swap_load_devnode(Swap
*s
) {
266 _cleanup_free_
char *p
= NULL
;
272 if (stat(s
->what
, &st
) < 0 || !S_ISBLK(st
.st_mode
))
275 r
= devname_from_stat_rdev(&st
, &p
);
277 log_unit_full_errno(UNIT(s
), r
== -ENOENT
? LOG_DEBUG
: LOG_WARNING
, r
,
278 "Failed to get device node for swap %s: %m", s
->what
);
282 return swap_set_devnode(s
, p
);
285 static int swap_add_extras(Swap
*s
) {
290 if (UNIT(s
)->fragment_path
)
291 s
->from_fragment
= true;
294 if (s
->parameters_fragment
.what
)
295 s
->what
= strdup(s
->parameters_fragment
.what
);
296 else if (s
->parameters_proc_swaps
.what
)
297 s
->what
= strdup(s
->parameters_proc_swaps
.what
);
299 r
= unit_name_to_path(UNIT(s
)->id
, &s
->what
);
308 path_simplify(s
->what
);
310 if (!UNIT(s
)->description
) {
311 r
= unit_set_description(UNIT(s
), s
->what
);
316 r
= unit_add_mounts_for(UNIT(s
), s
->what
, UNIT_DEPENDENCY_IMPLICIT
, UNIT_MOUNT_REQUIRES
);
320 r
= swap_add_device_dependencies(s
);
324 r
= swap_load_devnode(s
);
328 r
= unit_patch_contexts(UNIT(s
));
332 r
= unit_add_exec_dependencies(UNIT(s
), &s
->exec_context
);
336 r
= unit_set_default_slice(UNIT(s
));
340 r
= swap_add_default_dependencies(s
);
347 static int swap_load(Unit
*u
) {
348 Swap
*s
= ASSERT_PTR(SWAP(u
));
351 assert(u
->load_state
== UNIT_STUB
);
353 /* Load a .swap file */
354 r
= unit_load_fragment_and_dropin(u
, /* fragment_required = */ !s
->from_proc_swaps
);
356 /* Add in some extras, and do so either when we successfully loaded something or when /proc/swaps is
358 if (u
->load_state
== UNIT_LOADED
|| s
->from_proc_swaps
)
359 RET_GATHER(r
, swap_add_extras(s
));
364 if (u
->load_state
!= UNIT_LOADED
)
367 return swap_verify(s
);
370 static int swap_setup_unit(
373 const char *what_proc_swaps
,
377 _cleanup_(unit_freep
) Unit
*new = NULL
;
378 _cleanup_free_
char *e
= NULL
;
385 assert(what_proc_swaps
);
387 r
= unit_name_from_path(what
, ".swap", &e
);
389 return log_error_errno(r
, "Failed to generate unit name from path: %m");
391 u
= manager_get_unit(m
, e
);
393 s
= ASSERT_PTR(SWAP(u
));
395 if (s
->from_proc_swaps
&&
396 !path_equal(s
->parameters_proc_swaps
.what
, what_proc_swaps
))
397 return log_unit_error_errno(u
, SYNTHETIC_ERRNO(EEXIST
),
398 "Swap appeared twice with different device paths %s and %s, refusing.",
399 s
->parameters_proc_swaps
.what
, what_proc_swaps
);
401 r
= unit_new_for_name(m
, sizeof(Swap
), e
, &new);
403 return log_warning_errno(r
, "Failed to load swap unit '%s': %m", e
);
406 s
= ASSERT_PTR(SWAP(u
));
408 s
->what
= strdup(what
);
412 unit_add_to_load_queue(u
);
415 SwapParameters
*p
= &s
->parameters_proc_swaps
;
418 p
->what
= strdup(what_proc_swaps
);
423 /* The unit is definitely around now, mark it as loaded if it was previously referenced but
424 * could not be loaded. After all we can load it now, from the data in /proc/swaps. */
425 if (UNIT_IS_LOAD_ERROR(u
->load_state
)) {
426 u
->load_state
= UNIT_LOADED
;
432 s
->just_activated
= !s
->from_proc_swaps
;
435 s
->from_proc_swaps
= true;
437 p
->priority
= priority
;
438 p
->priority_set
= true;
440 unit_add_to_dbus_queue(u
);
446 static void swap_process_new(Manager
*m
, const char *device
, int prio
, bool set_flags
) {
447 _cleanup_(sd_device_unrefp
) sd_device
*d
= NULL
;
449 struct stat st
, st_link
;
454 if (swap_setup_unit(m
, device
, device
, prio
, set_flags
) < 0)
457 /* If this is a block device, then let's add duplicates for
458 * all other names of this block device */
459 if (stat(device
, &st
) < 0 || !S_ISBLK(st
.st_mode
))
462 r
= sd_device_new_from_stat_rdev(&d
, &st
);
464 return (void) log_full_errno(r
== -ENOENT
? LOG_DEBUG
: LOG_WARNING
, r
,
465 "Failed to allocate device for swap %s: %m", device
);
467 /* Add the main device node */
468 if (sd_device_get_devname(d
, &dn
) >= 0 && !streq(dn
, device
))
469 (void) swap_setup_unit(m
, dn
, device
, prio
, set_flags
);
471 /* Add additional units for all symlinks */
472 FOREACH_DEVICE_DEVLINK(d
, devlink
) {
474 /* Don't bother with the /dev/block links */
475 if (streq(devlink
, device
))
478 if (path_startswith(devlink
, "/dev/block/"))
481 if (stat(devlink
, &st_link
) >= 0 &&
482 (!S_ISBLK(st_link
.st_mode
) ||
483 st_link
.st_rdev
!= st
.st_rdev
))
486 (void) swap_setup_unit(m
, devlink
, device
, prio
, set_flags
);
490 static void swap_set_state(Swap
*s
, SwapState state
) {
495 if (s
->state
!= state
)
496 bus_unit_send_pending_change_signal(UNIT(s
), false);
498 old_state
= s
->state
;
501 if (!SWAP_STATE_WITH_PROCESS(state
)) {
502 s
->timer_event_source
= sd_event_source_disable_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
], /* reload_success = */ 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
) {
524 Swap
*s
= ASSERT_PTR(SWAP(u
));
525 SwapState new_state
= SWAP_DEAD
;
528 assert(s
->state
== SWAP_DEAD
);
530 if (s
->deserialized_state
!= s
->state
)
531 new_state
= s
->deserialized_state
;
532 else if (s
->from_proc_swaps
)
533 new_state
= SWAP_ACTIVE
;
535 if (new_state
== s
->state
)
538 if (pidref_is_set(&s
->control_pid
) &&
539 pidref_is_unwaited(&s
->control_pid
) > 0 &&
540 SWAP_STATE_WITH_PROCESS(new_state
)) {
542 r
= unit_watch_pidref(UNIT(s
), &s
->control_pid
, /* exclusive= */ false);
546 r
= swap_arm_timer(s
, /* relative= */ false, usec_add(u
->state_change_timestamp
.monotonic
, s
->timeout_usec
));
551 if (!IN_SET(new_state
, SWAP_DEAD
, SWAP_FAILED
)) {
552 (void) unit_setup_exec_runtime(u
);
553 (void) unit_setup_cgroup_runtime(u
);
556 swap_set_state(s
, new_state
);
560 static void swap_dump(Unit
*u
, FILE *f
, const char *prefix
) {
561 Swap
*s
= ASSERT_PTR(SWAP(u
));
567 prefix
= strempty(prefix
);
568 prefix2
= strjoina(prefix
, "\t");
570 if (s
->from_proc_swaps
)
571 p
= &s
->parameters_proc_swaps
;
572 else if (s
->from_fragment
)
573 p
= &s
->parameters_fragment
;
580 "%sClean Result: %s\n"
582 "%sFrom /proc/swaps: %s\n"
583 "%sFrom fragment: %s\n"
585 prefix
, swap_state_to_string(s
->state
),
586 prefix
, swap_result_to_string(s
->result
),
587 prefix
, swap_result_to_string(s
->clean_result
),
589 prefix
, yes_no(s
->from_proc_swaps
),
590 prefix
, yes_no(s
->from_fragment
),
591 prefix
, yes_no(swap_is_extrinsic(u
)));
594 fprintf(f
, "%sDevice Node: %s\n", prefix
, s
->devnode
);
601 prefix
, strempty(p
->options
));
604 "%sTimeoutSec: %s\n",
605 prefix
, FORMAT_TIMESPAN(s
->timeout_usec
, USEC_PER_SEC
));
607 if (pidref_is_set(&s
->control_pid
))
609 "%sControl PID: "PID_FMT
"\n",
610 prefix
, s
->control_pid
.pid
);
612 exec_context_dump(&s
->exec_context
, f
, prefix
);
613 kill_context_dump(&s
->kill_context
, f
, prefix
);
614 cgroup_context_dump(UNIT(s
), f
, prefix
);
616 for (SwapExecCommand c
= 0; c
< _SWAP_EXEC_COMMAND_MAX
; c
++) {
617 if (!s
->exec_command
[c
].argv
)
620 fprintf(f
, "%s%s %s:\n",
621 prefix
, special_glyph(SPECIAL_GLYPH_ARROW_RIGHT
), swap_exec_command_to_string(c
));
623 exec_command_dump(s
->exec_command
+ c
, f
, prefix2
);
628 static int swap_spawn(Swap
*s
, ExecCommand
*c
, PidRef
*ret_pid
) {
629 _cleanup_(exec_params_shallow_clear
) ExecParameters exec_params
= EXEC_PARAMETERS_INIT(
630 EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
);
631 _cleanup_(pidref_done
) PidRef pidref
= PIDREF_NULL
;
638 r
= unit_prepare_exec(UNIT(s
));
642 r
= swap_arm_timer(s
, /* relative= */ true, s
->timeout_usec
);
646 r
= unit_set_exec_params(UNIT(s
), &exec_params
);
650 r
= exec_spawn(UNIT(s
),
660 r
= unit_watch_pidref(UNIT(s
), &pidref
, /* exclusive= */ true);
664 *ret_pid
= TAKE_PIDREF(pidref
);
668 static void swap_enter_dead(Swap
*s
, SwapResult f
) {
671 if (s
->result
== SWAP_SUCCESS
)
674 unit_log_result(UNIT(s
), s
->result
== SWAP_SUCCESS
, swap_result_to_string(s
->result
));
675 unit_warn_leftover_processes(UNIT(s
), unit_log_leftover_process_stop
);
676 swap_set_state(s
, s
->result
!= SWAP_SUCCESS
? SWAP_FAILED
: SWAP_DEAD
);
678 s
->exec_runtime
= exec_runtime_destroy(s
->exec_runtime
);
680 unit_destroy_runtime_data(UNIT(s
), &s
->exec_context
);
682 unit_unref_uid_gid(UNIT(s
), true);
685 static void swap_enter_active(Swap
*s
, SwapResult f
) {
688 if (s
->result
== SWAP_SUCCESS
)
691 swap_set_state(s
, SWAP_ACTIVE
);
694 static void swap_enter_dead_or_active(Swap
*s
, SwapResult f
) {
697 if (s
->from_proc_swaps
) {
698 swap_enter_active(s
, f
);
700 LIST_FOREACH_OTHERS(same_devnode
, other
, s
)
701 if (UNIT(other
)->job
)
702 swap_enter_dead_or_active(other
, f
);
704 swap_enter_dead(s
, f
);
707 static int state_to_kill_operation(Swap
*s
, SwapState state
) {
708 if (state
== SWAP_DEACTIVATING_SIGTERM
) {
709 if (unit_has_job_type(UNIT(s
), JOB_RESTART
))
712 return KILL_TERMINATE
;
718 static void swap_enter_signal(Swap
*s
, SwapState state
, SwapResult f
) {
723 if (s
->result
== SWAP_SUCCESS
)
726 r
= unit_kill_context(UNIT(s
), state_to_kill_operation(s
, state
));
728 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
733 r
= swap_arm_timer(s
, /* relative= */ true, s
->timeout_usec
);
735 log_unit_warning_errno(UNIT(s
), r
, "Failed to install timer: %m");
739 swap_set_state(s
, state
);
740 } else if (state
== SWAP_DEACTIVATING_SIGTERM
&& s
->kill_context
.send_sigkill
)
741 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGKILL
, SWAP_SUCCESS
);
743 swap_enter_dead_or_active(s
, SWAP_SUCCESS
);
748 swap_enter_dead_or_active(s
, SWAP_FAILURE_RESOURCES
);
751 static void swap_enter_activating(Swap
*s
) {
752 _cleanup_free_
char *opts
= NULL
;
757 unit_warn_leftover_processes(UNIT(s
), unit_log_leftover_process_start
);
759 s
->control_command_id
= SWAP_EXEC_ACTIVATE
;
760 s
->control_command
= s
->exec_command
+ SWAP_EXEC_ACTIVATE
;
762 if (s
->from_fragment
) {
765 r
= fstab_find_pri(s
->parameters_fragment
.options
, &priority
);
767 log_unit_warning_errno(UNIT(s
), r
, "Failed to parse swap priority \"%s\", ignoring: %m", s
->parameters_fragment
.options
);
768 else if (r
> 0 && s
->parameters_fragment
.priority_set
)
769 log_unit_warning(UNIT(s
), "Duplicate swap priority configuration by Priority= and Options= fields.");
771 if (r
<= 0 && s
->parameters_fragment
.priority_set
) {
772 if (s
->parameters_fragment
.options
)
773 r
= asprintf(&opts
, "%s,pri=%i", s
->parameters_fragment
.options
, s
->parameters_fragment
.priority
);
775 r
= asprintf(&opts
, "pri=%i", s
->parameters_fragment
.priority
);
783 r
= exec_command_set(s
->control_command
, "/sbin/swapon", "--fixpgsz", NULL
);
785 log_unit_warning_errno(UNIT(s
), r
, "Failed to initialize swapon command line: %m");
789 if (s
->parameters_fragment
.options
|| opts
) {
790 r
= exec_command_append(s
->control_command
, "-o",
791 opts
?: s
->parameters_fragment
.options
, NULL
);
793 log_unit_warning_errno(UNIT(s
), r
, "Failed to prepare swapon command line: %m");
798 r
= exec_command_append(s
->control_command
, s
->what
, NULL
);
800 log_unit_warning_errno(UNIT(s
), r
, "Failed to prepare swapon command line: %m");
804 swap_unwatch_control_pid(s
);
806 r
= swap_spawn(s
, s
->control_command
, &s
->control_pid
);
808 log_unit_warning_errno(UNIT(s
), r
, "Failed to spawn 'swapon' task: %m");
812 swap_set_state(s
, SWAP_ACTIVATING
);
816 swap_enter_dead_or_active(s
, SWAP_FAILURE_RESOURCES
);
819 static void swap_enter_deactivating(Swap
*s
) {
824 s
->control_command_id
= SWAP_EXEC_DEACTIVATE
;
825 s
->control_command
= s
->exec_command
+ SWAP_EXEC_DEACTIVATE
;
827 r
= exec_command_set(s
->control_command
,
832 log_unit_warning_errno(UNIT(s
), r
, "Failed to prepare swapoff command line: %m");
836 swap_unwatch_control_pid(s
);
838 r
= swap_spawn(s
, s
->control_command
, &s
->control_pid
);
840 log_unit_warning_errno(UNIT(s
), r
, "Failed to spawn 'swapoff' task: %m");
844 swap_set_state(s
, SWAP_DEACTIVATING
);
848 swap_enter_dead_or_active(s
, SWAP_FAILURE_RESOURCES
);
851 static void swap_cycle_clear(Swap
*s
) {
854 s
->result
= SWAP_SUCCESS
;
855 exec_command_reset_status_array(s
->exec_command
, _SWAP_EXEC_COMMAND_MAX
);
857 if (s
->cgroup_runtime
)
858 s
->cgroup_runtime
->reset_accounting
= true;
861 static int swap_start(Unit
*u
) {
867 /* We cannot fulfill this request right now, try again later please! */
870 SWAP_DEACTIVATING_SIGTERM
,
871 SWAP_DEACTIVATING_SIGKILL
,
876 if (s
->state
== SWAP_ACTIVATING
)
879 assert(IN_SET(s
->state
, SWAP_DEAD
, SWAP_FAILED
));
881 if (detect_container() > 0)
884 /* If there's a job for another swap unit for the same node
885 * running, then let's not dispatch this one for now, and wait
886 * until that other job has finished. */
887 LIST_FOREACH_OTHERS(same_devnode
, other
, s
)
888 if (UNIT(other
)->job
&& UNIT(other
)->job
->state
== JOB_RUNNING
)
891 r
= unit_acquire_invocation_id(u
);
896 swap_enter_activating(s
);
900 static int swap_stop(Unit
*u
) {
901 Swap
*s
= ASSERT_PTR(SWAP(u
));
905 case SWAP_DEACTIVATING
:
906 case SWAP_DEACTIVATING_SIGTERM
:
907 case SWAP_DEACTIVATING_SIGKILL
:
911 case SWAP_ACTIVATING
:
912 case SWAP_ACTIVATING_DONE
:
913 /* There's a control process pending, directly enter kill mode */
914 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGTERM
, SWAP_SUCCESS
);
918 if (detect_container() > 0)
921 swap_enter_deactivating(s
);
925 /* If we are currently cleaning, then abort it, brutally. */
926 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGKILL
, SWAP_SUCCESS
);
930 assert_not_reached();
934 static int swap_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
935 Swap
*s
= ASSERT_PTR(SWAP(u
));
940 (void) serialize_item(f
, "state", swap_state_to_string(s
->state
));
941 (void) serialize_item(f
, "result", swap_result_to_string(s
->result
));
942 (void) serialize_pidref(f
, fds
, "control-pid", &s
->control_pid
);
944 if (s
->control_command_id
>= 0)
945 (void) serialize_item(f
, "control-command", swap_exec_command_to_string(s
->control_command_id
));
950 static int swap_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
951 Swap
*s
= ASSERT_PTR(SWAP(u
));
955 if (streq(key
, "state")) {
958 state
= swap_state_from_string(value
);
960 log_unit_debug(u
, "Failed to parse state value: %s", value
);
962 s
->deserialized_state
= state
;
963 } else if (streq(key
, "result")) {
966 f
= swap_result_from_string(value
);
968 log_unit_debug(u
, "Failed to parse result value: %s", value
);
969 else if (f
!= SWAP_SUCCESS
)
971 } else if (streq(key
, "control-pid")) {
973 if (!pidref_is_set(&s
->control_pid
))
974 (void) deserialize_pidref(fds
, value
, &s
->control_pid
);
976 } else if (streq(key
, "control-command")) {
979 id
= swap_exec_command_from_string(value
);
981 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
983 s
->control_command_id
= id
;
984 s
->control_command
= s
->exec_command
+ id
;
987 log_unit_debug(u
, "Unknown serialization key: %s", key
);
992 static void swap_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
993 Swap
*s
= ASSERT_PTR(SWAP(u
));
998 if (pid
!= s
->control_pid
.pid
)
1001 /* Let's scan /proc/swaps before we process SIGCHLD. For the reasoning see the similar code in
1003 (void) swap_process_proc_swaps(u
->manager
);
1005 pidref_done(&s
->control_pid
);
1007 if (is_clean_exit(code
, status
, EXIT_CLEAN_COMMAND
, NULL
))
1009 else if (code
== CLD_EXITED
)
1010 f
= SWAP_FAILURE_EXIT_CODE
;
1011 else if (code
== CLD_KILLED
)
1012 f
= SWAP_FAILURE_SIGNAL
;
1013 else if (code
== CLD_DUMPED
)
1014 f
= SWAP_FAILURE_CORE_DUMP
;
1016 assert_not_reached();
1018 if (s
->result
== SWAP_SUCCESS
)
1021 if (s
->control_command
) {
1022 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
1024 s
->control_command
= NULL
;
1025 s
->control_command_id
= _SWAP_EXEC_COMMAND_INVALID
;
1028 unit_log_process_exit(
1031 swap_exec_command_to_string(s
->control_command_id
),
1037 case SWAP_ACTIVATING
:
1038 case SWAP_ACTIVATING_DONE
:
1040 if (f
== SWAP_SUCCESS
|| s
->from_proc_swaps
)
1041 swap_enter_active(s
, f
);
1043 swap_enter_dead(s
, f
);
1046 case SWAP_DEACTIVATING
:
1047 case SWAP_DEACTIVATING_SIGKILL
:
1048 case SWAP_DEACTIVATING_SIGTERM
:
1050 swap_enter_dead_or_active(s
, f
);
1054 if (s
->clean_result
== SWAP_SUCCESS
)
1055 s
->clean_result
= f
;
1057 swap_enter_dead(s
, SWAP_SUCCESS
);
1061 assert_not_reached();
1064 /* Notify clients about changed exit status */
1065 unit_add_to_dbus_queue(u
);
1068 static int swap_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
1069 Swap
*s
= ASSERT_PTR(SWAP(userdata
));
1071 assert(s
->timer_event_source
== source
);
1075 case SWAP_ACTIVATING
:
1076 case SWAP_ACTIVATING_DONE
:
1077 log_unit_warning(UNIT(s
), "Activation timed out. Stopping.");
1078 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGTERM
, SWAP_FAILURE_TIMEOUT
);
1081 case SWAP_DEACTIVATING
:
1082 log_unit_warning(UNIT(s
), "Deactivation timed out. Stopping.");
1083 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGTERM
, SWAP_FAILURE_TIMEOUT
);
1086 case SWAP_DEACTIVATING_SIGTERM
:
1087 if (s
->kill_context
.send_sigkill
) {
1088 log_unit_warning(UNIT(s
), "Swap process timed out. Killing.");
1089 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGKILL
, SWAP_FAILURE_TIMEOUT
);
1091 log_unit_warning(UNIT(s
), "Swap process timed out. Skipping SIGKILL. Ignoring.");
1092 swap_enter_dead_or_active(s
, SWAP_FAILURE_TIMEOUT
);
1096 case SWAP_DEACTIVATING_SIGKILL
:
1097 log_unit_warning(UNIT(s
), "Swap process still around after SIGKILL. Ignoring.");
1098 swap_enter_dead_or_active(s
, SWAP_FAILURE_TIMEOUT
);
1102 log_unit_warning(UNIT(s
), "Cleaning timed out. killing.");
1104 if (s
->clean_result
== SWAP_SUCCESS
)
1105 s
->clean_result
= SWAP_FAILURE_TIMEOUT
;
1107 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGKILL
, 0);
1111 assert_not_reached();
1117 static int swap_load_proc_swaps(Manager
*m
, bool set_flags
) {
1120 rewind(m
->proc_swaps
);
1122 (void) fscanf(m
->proc_swaps
, "%*s %*s %*s %*s %*s\n");
1124 for (unsigned i
= 1;; i
++) {
1125 _cleanup_free_
char *dev
= NULL
, *d
= NULL
;
1128 k
= fscanf(m
->proc_swaps
,
1129 "%ms " /* device/file */
1130 "%*s " /* type of swap */
1131 "%*s " /* swap size */
1133 "%i\n", /* priority */
1139 log_warning("Failed to parse /proc/swaps:%u, skipping.", i
);
1143 ssize_t l
= cunescape(dev
, UNESCAPE_RELAX
, &d
);
1145 return log_error_errno(l
, "Failed to unescape device path: %m");
1147 device_found_node(m
, d
, DEVICE_FOUND_SWAP
, DEVICE_FOUND_SWAP
);
1149 (void) swap_process_new(m
, d
, prio
, set_flags
);
1155 static int swap_process_proc_swaps(Manager
*m
) {
1160 r
= swap_load_proc_swaps(m
, true);
1162 /* Reset flags, just in case, for late calls */
1163 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_SWAP
]) {
1164 Swap
*swap
= SWAP(u
);
1168 swap
->is_active
= swap
->just_activated
= false;
1174 manager_dispatch_load_queue(m
);
1176 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_SWAP
]) {
1177 Swap
*swap
= SWAP(u
);
1181 if (!swap
->is_active
) {
1183 swap_unset_proc_swaps(swap
);
1185 switch (swap
->state
) {
1188 /* This has just been deactivated */
1189 swap_enter_dead(swap
, SWAP_SUCCESS
);
1194 swap_set_state(swap
, swap
->state
);
1199 device_found_node(m
, swap
->what
, DEVICE_NOT_FOUND
, DEVICE_FOUND_SWAP
);
1201 } else if (swap
->just_activated
) {
1203 /* New swap entry */
1205 switch (swap
->state
) {
1209 (void) unit_acquire_invocation_id(u
);
1210 swap_cycle_clear(swap
);
1211 swap_enter_active(swap
, SWAP_SUCCESS
);
1214 case SWAP_ACTIVATING
:
1215 swap_set_state(swap
, SWAP_ACTIVATING_DONE
);
1219 /* Nothing really changed, but let's
1220 * issue an notification call
1221 * nonetheless, in case somebody is
1222 * waiting for this. */
1223 swap_set_state(swap
, swap
->state
);
1228 /* Reset the flags for later calls */
1229 swap
->is_active
= swap
->just_activated
= false;
1235 static int swap_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
1236 Manager
*m
= ASSERT_PTR(userdata
);
1238 assert(revents
& EPOLLPRI
);
1240 return swap_process_proc_swaps(m
);
1243 static Unit
* swap_following(Unit
*u
) {
1244 Swap
*s
= ASSERT_PTR(SWAP(u
));
1247 /* If the user configured the swap through /etc/fstab or
1248 * a device unit, follow that. */
1250 if (s
->from_fragment
)
1253 LIST_FOREACH_OTHERS(same_devnode
, other
, s
)
1254 if (other
->from_fragment
)
1257 /* Otherwise, make everybody follow the unit that's named after
1258 * the swap device in the kernel */
1260 if (streq_ptr(s
->what
, s
->devnode
))
1263 LIST_FOREACH(same_devnode
, other
, s
->same_devnode_next
)
1264 if (streq_ptr(other
->what
, other
->devnode
))
1267 LIST_FOREACH_BACKWARDS(same_devnode
, other
, s
->same_devnode_prev
) {
1268 if (streq_ptr(other
->what
, other
->devnode
))
1274 /* Fall back to the first on the list */
1278 static int swap_following_set(Unit
*u
, Set
**ret
) {
1279 Swap
*s
= ASSERT_PTR(SWAP(u
));
1280 _cleanup_set_free_ Set
*set
= NULL
;
1285 if (LIST_JUST_US(same_devnode
, s
)) {
1290 set
= set_new(NULL
);
1294 LIST_FOREACH_OTHERS(same_devnode
, other
, s
) {
1295 r
= set_put(set
, other
);
1300 *ret
= TAKE_PTR(set
);
1304 static void swap_shutdown(Manager
*m
) {
1307 m
->swap_event_source
= sd_event_source_disable_unref(m
->swap_event_source
);
1308 m
->proc_swaps
= safe_fclose(m
->proc_swaps
);
1309 m
->swaps_by_devnode
= hashmap_free(m
->swaps_by_devnode
);
1312 static void swap_enumerate(Manager
*m
) {
1317 if (!m
->proc_swaps
) {
1318 m
->proc_swaps
= fopen("/proc/swaps", "re");
1319 if (!m
->proc_swaps
) {
1320 if (errno
== ENOENT
)
1321 log_debug_errno(errno
, "Not swap enabled, skipping enumeration.");
1323 log_warning_errno(errno
, "Failed to open /proc/swaps, ignoring: %m");
1328 r
= sd_event_add_io(m
->event
, &m
->swap_event_source
, fileno(m
->proc_swaps
), EPOLLPRI
, swap_dispatch_io
, m
);
1330 log_error_errno(r
, "Failed to watch /proc/swaps: %m");
1334 /* Dispatch this before we dispatch SIGCHLD, so that
1335 * we always get the events from /proc/swaps before
1336 * the SIGCHLD of /sbin/swapon. */
1337 r
= sd_event_source_set_priority(m
->swap_event_source
, EVENT_PRIORITY_SWAP_TABLE
);
1339 log_error_errno(r
, "Failed to change /proc/swaps priority: %m");
1343 (void) sd_event_source_set_description(m
->swap_event_source
, "swap-proc");
1346 r
= swap_load_proc_swaps(m
, false);
1356 int swap_process_device_new(Manager
*m
, sd_device
*dev
) {
1357 _cleanup_free_
char *e
= NULL
;
1365 if (sd_device_get_devname(dev
, &dn
) < 0)
1368 r
= unit_name_from_path(dn
, ".swap", &e
);
1370 log_debug_errno(r
, "Cannot convert device name '%s' to unit name, ignoring: %m", dn
);
1374 u
= manager_get_unit(m
, e
);
1376 r
= swap_set_devnode(SWAP(u
), dn
);
1378 FOREACH_DEVICE_DEVLINK(dev
, devlink
) {
1379 _cleanup_free_
char *n
= NULL
;
1382 q
= unit_name_from_path(devlink
, ".swap", &n
);
1383 if (q
== -EINVAL
) /* If the name is not convertible to unit name, we can't manage it */
1388 u
= manager_get_unit(m
, n
);
1390 q
= swap_set_devnode(SWAP(u
), dn
);
1399 int swap_process_device_remove(Manager
*m
, sd_device
*dev
) {
1404 r
= sd_device_get_devname(dev
, &dn
);
1409 while ((s
= hashmap_get(m
->swaps_by_devnode
, dn
)))
1410 RET_GATHER(r
, swap_set_devnode(s
, NULL
));
1415 static void swap_reset_failed(Unit
*u
) {
1416 Swap
*s
= ASSERT_PTR(SWAP(u
));
1418 if (s
->state
== SWAP_FAILED
)
1419 swap_set_state(s
, SWAP_DEAD
);
1421 s
->result
= SWAP_SUCCESS
;
1422 s
->clean_result
= SWAP_SUCCESS
;
1425 static void swap_handoff_timestamp(
1427 const struct ucred
*ucred
,
1428 const dual_timestamp
*ts
) {
1430 Swap
*s
= ASSERT_PTR(SWAP(u
));
1435 if (s
->control_pid
.pid
== ucred
->pid
&& s
->control_command
) {
1436 exec_status_handoff(&s
->control_command
->exec_status
, ucred
, ts
);
1437 unit_add_to_dbus_queue(u
);
1441 static int swap_get_timeout(Unit
*u
, usec_t
*timeout
) {
1442 Swap
*s
= ASSERT_PTR(SWAP(u
));
1446 if (!s
->timer_event_source
)
1449 r
= sd_event_source_get_time(s
->timer_event_source
, &t
);
1452 if (t
== USEC_INFINITY
)
1459 static bool swap_supported(void) {
1460 static int supported
= -1;
1462 /* If swap support is not available in the kernel, or we are
1463 * running in a container we don't support swap units, and any
1464 * attempts to starting one should fail immediately. */
1468 access("/proc/swaps", F_OK
) >= 0 &&
1469 detect_container() <= 0;
1474 static PidRef
* swap_control_pid(Unit
*u
) {
1475 return &ASSERT_PTR(SWAP(u
))->control_pid
;
1478 static int swap_clean(Unit
*u
, ExecCleanMask mask
) {
1479 Swap
*s
= ASSERT_PTR(SWAP(u
));
1480 _cleanup_strv_free_
char **l
= NULL
;
1485 if (s
->state
!= SWAP_DEAD
)
1488 r
= exec_context_get_clean_directories(&s
->exec_context
, u
->manager
->prefix
, mask
, &l
);
1492 if (strv_isempty(l
))
1495 swap_unwatch_control_pid(s
);
1496 s
->clean_result
= SWAP_SUCCESS
;
1497 s
->control_command
= NULL
;
1498 s
->control_command_id
= _SWAP_EXEC_COMMAND_INVALID
;
1500 r
= swap_arm_timer(s
, /* relative= */ true, s
->exec_context
.timeout_clean_usec
);
1502 log_unit_warning_errno(u
, r
, "Failed to install timer: %m");
1506 r
= unit_fork_and_watch_rm_rf(u
, l
, &s
->control_pid
);
1508 log_unit_warning_errno(u
, r
, "Failed to spawn cleaning task: %m");
1512 swap_set_state(s
, SWAP_CLEANING
);
1516 s
->clean_result
= SWAP_FAILURE_RESOURCES
;
1517 s
->timer_event_source
= sd_event_source_disable_unref(s
->timer_event_source
);
1521 static int swap_can_clean(Unit
*u
, ExecCleanMask
*ret
) {
1522 Swap
*s
= ASSERT_PTR(SWAP(u
));
1524 return exec_context_get_clean_mask(&s
->exec_context
, ret
);
1527 static int swap_can_start(Unit
*u
) {
1528 Swap
*s
= ASSERT_PTR(SWAP(u
));
1531 r
= unit_test_start_limit(u
);
1533 swap_enter_dead(s
, SWAP_FAILURE_START_LIMIT_HIT
);
1540 int swap_get_priority(const Swap
*s
) {
1543 if (s
->from_proc_swaps
&& s
->parameters_proc_swaps
.priority_set
)
1544 return s
->parameters_proc_swaps
.priority
;
1546 if (s
->from_fragment
&& s
->parameters_fragment
.priority_set
)
1547 return s
->parameters_fragment
.priority
;
1552 const char* swap_get_options(const Swap
*s
) {
1555 if (s
->from_fragment
)
1556 return s
->parameters_fragment
.options
;
1561 static const char* const swap_exec_command_table
[_SWAP_EXEC_COMMAND_MAX
] = {
1562 [SWAP_EXEC_ACTIVATE
] = "ExecActivate",
1563 [SWAP_EXEC_DEACTIVATE
] = "ExecDeactivate",
1566 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command
, SwapExecCommand
);
1568 static const char* const swap_result_table
[_SWAP_RESULT_MAX
] = {
1569 [SWAP_SUCCESS
] = "success",
1570 [SWAP_FAILURE_RESOURCES
] = "resources",
1571 [SWAP_FAILURE_TIMEOUT
] = "timeout",
1572 [SWAP_FAILURE_EXIT_CODE
] = "exit-code",
1573 [SWAP_FAILURE_SIGNAL
] = "signal",
1574 [SWAP_FAILURE_CORE_DUMP
] = "core-dump",
1575 [SWAP_FAILURE_START_LIMIT_HIT
] = "start-limit-hit",
1578 DEFINE_STRING_TABLE_LOOKUP(swap_result
, SwapResult
);
1580 const UnitVTable swap_vtable
= {
1581 .object_size
= sizeof(Swap
),
1582 .exec_context_offset
= offsetof(Swap
, exec_context
),
1583 .cgroup_context_offset
= offsetof(Swap
, cgroup_context
),
1584 .kill_context_offset
= offsetof(Swap
, kill_context
),
1585 .exec_runtime_offset
= offsetof(Swap
, exec_runtime
),
1586 .cgroup_runtime_offset
= offsetof(Swap
, cgroup_runtime
),
1592 .private_section
= "Swap",
1600 .coldplug
= swap_coldplug
,
1604 .start
= swap_start
,
1607 .clean
= swap_clean
,
1608 .can_clean
= swap_can_clean
,
1610 .get_timeout
= swap_get_timeout
,
1612 .serialize
= swap_serialize
,
1613 .deserialize_item
= swap_deserialize_item
,
1615 .active_state
= swap_active_state
,
1616 .sub_state_to_string
= swap_sub_state_to_string
,
1618 .will_restart
= unit_will_restart_default
,
1620 .may_gc
= swap_may_gc
,
1621 .is_extrinsic
= swap_is_extrinsic
,
1623 .sigchld_event
= swap_sigchld_event
,
1625 .reset_failed
= swap_reset_failed
,
1627 .notify_handoff_timestamp
= swap_handoff_timestamp
,
1629 .control_pid
= swap_control_pid
,
1631 .bus_set_property
= bus_swap_set_property
,
1632 .bus_commit_properties
= bus_swap_commit_properties
,
1634 .following
= swap_following
,
1635 .following_set
= swap_following_set
,
1637 .enumerate
= swap_enumerate
,
1638 .shutdown
= swap_shutdown
,
1639 .supported
= swap_supported
,
1641 .status_message_formats
= {
1642 .starting_stopping
= {
1643 [0] = "Activating swap %s...",
1644 [1] = "Deactivating swap %s...",
1646 .finished_start_job
= {
1647 [JOB_DONE
] = "Activated swap %s.",
1648 [JOB_FAILED
] = "Failed to activate swap %s.",
1649 [JOB_TIMEOUT
] = "Timed out activating swap %s.",
1651 .finished_stop_job
= {
1652 [JOB_DONE
] = "Deactivated swap %s.",
1653 [JOB_FAILED
] = "Failed deactivating swap %s.",
1654 [JOB_TIMEOUT
] = "Timed out deactivating swap %s.",
1658 .can_start
= swap_can_start
,
1660 .notify_plymouth
= true,