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 General Public License as published by
10 the Free Software Foundation; either version 2 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 General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
26 #include <sys/epoll.h>
33 #include "load-fragment.h"
34 #include "load-dropin.h"
35 #include "unit-name.h"
36 #include "dbus-swap.h"
38 #include "bus-errors.h"
39 #include "exit-status.h"
42 static const UnitActiveState state_translation_table
[_SWAP_STATE_MAX
] = {
43 [SWAP_DEAD
] = UNIT_INACTIVE
,
44 [SWAP_ACTIVATING
] = UNIT_ACTIVATING
,
45 [SWAP_ACTIVE
] = UNIT_ACTIVE
,
46 [SWAP_DEACTIVATING
] = UNIT_DEACTIVATING
,
47 [SWAP_ACTIVATING_SIGTERM
] = UNIT_DEACTIVATING
,
48 [SWAP_ACTIVATING_SIGKILL
] = UNIT_DEACTIVATING
,
49 [SWAP_DEACTIVATING_SIGTERM
] = UNIT_DEACTIVATING
,
50 [SWAP_DEACTIVATING_SIGKILL
] = UNIT_DEACTIVATING
,
51 [SWAP_FAILED
] = UNIT_FAILED
54 static void swap_unset_proc_swaps(Swap
*s
) {
59 if (!s
->parameters_proc_swaps
.what
)
62 /* Remove this unit from the chain of swaps which share the
63 * same kernel swap device. */
65 first
= hashmap_get(s
->meta
.manager
->swaps_by_proc_swaps
, s
->parameters_proc_swaps
.what
);
66 LIST_REMOVE(Swap
, same_proc_swaps
, first
, s
);
69 hashmap_remove_and_replace(s
->meta
.manager
->swaps_by_proc_swaps
, s
->parameters_proc_swaps
.what
, first
->parameters_proc_swaps
.what
, first
);
71 hashmap_remove(s
->meta
.manager
->swaps_by_proc_swaps
, s
->parameters_proc_swaps
.what
);
73 free(s
->parameters_proc_swaps
.what
);
74 s
->parameters_proc_swaps
.what
= NULL
;
77 static void swap_init(Unit
*u
) {
81 assert(s
->meta
.load_state
== UNIT_STUB
);
83 s
->timeout_usec
= DEFAULT_TIMEOUT_USEC
;
85 exec_context_init(&s
->exec_context
);
86 s
->exec_context
.std_output
= u
->meta
.manager
->default_std_output
;
87 s
->exec_context
.std_error
= u
->meta
.manager
->default_std_error
;
89 s
->parameters_etc_fstab
.priority
= s
->parameters_proc_swaps
.priority
= s
->parameters_fragment
.priority
= -1;
91 s
->timer_watch
.type
= WATCH_INVALID
;
93 s
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
95 s
->meta
.ignore_on_isolate
= true;
98 static void swap_unwatch_control_pid(Swap
*s
) {
101 if (s
->control_pid
<= 0)
104 unit_unwatch_pid(UNIT(s
), s
->control_pid
);
108 static void swap_done(Unit
*u
) {
113 swap_unset_proc_swaps(s
);
118 free(s
->parameters_etc_fstab
.what
);
119 free(s
->parameters_fragment
.what
);
120 s
->parameters_etc_fstab
.what
= s
->parameters_fragment
.what
= NULL
;
122 exec_context_done(&s
->exec_context
);
123 exec_command_done_array(s
->exec_command
, _SWAP_EXEC_COMMAND_MAX
);
124 s
->control_command
= NULL
;
126 swap_unwatch_control_pid(s
);
128 unit_unwatch_timer(u
, &s
->timer_watch
);
131 int swap_add_one_mount_link(Swap
*s
, Mount
*m
) {
137 if (s
->meta
.load_state
!= UNIT_LOADED
||
138 m
->meta
.load_state
!= UNIT_LOADED
)
141 if (is_device_path(s
->what
))
144 if (!path_startswith(s
->what
, m
->where
))
147 if ((r
= unit_add_two_dependencies(UNIT(s
), UNIT_AFTER
, UNIT_REQUIRES
, UNIT(m
), true)) < 0)
153 static int swap_add_mount_links(Swap
*s
) {
159 LIST_FOREACH(units_by_type
, other
, s
->meta
.manager
->units_by_type
[UNIT_MOUNT
])
160 if ((r
= swap_add_one_mount_link(s
, (Mount
*) other
)) < 0)
166 static int swap_add_target_links(Swap
*s
) {
173 if (s
->from_fragment
)
174 p
= &s
->parameters_fragment
;
175 else if (s
->from_etc_fstab
)
176 p
= &s
->parameters_etc_fstab
;
180 if ((r
= manager_load_unit(s
->meta
.manager
, SPECIAL_SWAP_TARGET
, NULL
, NULL
, &tu
)) < 0)
185 (p
->handle
|| s
->meta
.manager
->swap_auto
) &&
187 s
->meta
.manager
->running_as
== MANAGER_SYSTEM
)
188 if ((r
= unit_add_dependency(tu
, UNIT_WANTS
, UNIT(s
), true)) < 0)
191 return unit_add_dependency(UNIT(s
), UNIT_BEFORE
, tu
, true);
194 static int swap_add_device_links(Swap
*s
) {
202 if (s
->from_fragment
)
203 p
= &s
->parameters_fragment
;
204 else if (s
->from_etc_fstab
)
205 p
= &s
->parameters_etc_fstab
;
209 if (is_device_path(s
->what
))
210 return unit_add_node_link(UNIT(s
), s
->what
,
211 !p
->noauto
&& p
->nofail
&&
212 s
->meta
.manager
->running_as
== MANAGER_SYSTEM
);
214 /* File based swap devices need to be ordered after
215 * remount-rootfs.service, since they might need a
216 * writable file system. */
217 return unit_add_dependency_by_name(UNIT(s
), UNIT_AFTER
, SPECIAL_REMOUNT_ROOTFS_SERVICE
, NULL
, true);
220 static int swap_add_default_dependencies(Swap
*s
) {
225 if (s
->meta
.manager
->running_as
== MANAGER_SYSTEM
) {
227 if ((r
= unit_add_two_dependencies_by_name(UNIT(s
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true)) < 0)
234 static int swap_verify(Swap
*s
) {
238 if (s
->meta
.load_state
!= UNIT_LOADED
)
241 if (!(e
= unit_name_from_path(s
->what
, ".swap")))
244 b
= unit_has_name(UNIT(s
), e
);
248 log_error("%s: Value of \"What\" and unit name do not match, not loading.\n", s
->meta
.id
);
252 if (s
->exec_context
.pam_name
&& s
->exec_context
.kill_mode
!= KILL_CONTROL_GROUP
) {
253 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", s
->meta
.id
);
260 static int swap_load(Unit
*u
) {
265 assert(u
->meta
.load_state
== UNIT_STUB
);
267 /* Load a .swap file */
268 if ((r
= unit_load_fragment_and_dropin_optional(u
)) < 0)
271 if (u
->meta
.load_state
== UNIT_LOADED
) {
272 if ((r
= unit_add_exec_dependencies(u
, &s
->exec_context
)) < 0)
275 if (s
->meta
.fragment_path
)
276 s
->from_fragment
= true;
279 if (s
->parameters_fragment
.what
)
280 s
->what
= strdup(s
->parameters_fragment
.what
);
281 else if (s
->parameters_etc_fstab
.what
)
282 s
->what
= strdup(s
->parameters_etc_fstab
.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
->meta
.id
);
292 path_kill_slashes(s
->what
);
294 if (!s
->meta
.description
)
295 if ((r
= unit_set_description(u
, s
->what
)) < 0)
298 if ((r
= swap_add_device_links(s
)) < 0)
301 if ((r
= swap_add_mount_links(s
)) < 0)
304 if ((r
= swap_add_target_links(s
)) < 0)
307 if ((r
= unit_add_default_cgroups(u
)) < 0)
310 if (s
->meta
.default_dependencies
)
311 if ((r
= swap_add_default_dependencies(s
)) < 0)
315 return swap_verify(s
);
321 const char *what_proc_swaps
,
329 char *e
= NULL
, *wp
= NULL
;
337 if (!(e
= unit_name_from_path(what
, ".swap")))
340 u
= manager_get_unit(m
, e
);
342 if (what_proc_swaps
&&
344 SWAP(u
)->from_proc_swaps
&&
345 !path_equal(SWAP(u
)->parameters_proc_swaps
.what
, what_proc_swaps
))
351 if (!(u
= unit_new(m
))) {
356 if ((r
= unit_add_name(u
, e
)) < 0)
359 if (!(SWAP(u
)->what
= strdup(what
))) {
364 unit_add_to_load_queue(u
);
368 if (what_proc_swaps
) {
371 p
= &SWAP(u
)->parameters_proc_swaps
;
374 if (!(wp
= strdup(what_proc_swaps
))) {
379 if (!m
->swaps_by_proc_swaps
)
380 if (!(m
->swaps_by_proc_swaps
= hashmap_new(string_hash_func
, string_compare_func
))) {
388 first
= hashmap_get(m
->swaps_by_proc_swaps
, wp
);
389 LIST_PREPEND(Swap
, same_proc_swaps
, first
, SWAP(u
));
391 if ((r
= hashmap_replace(m
->swaps_by_proc_swaps
, wp
, first
)) < 0)
396 SWAP(u
)->is_active
= true;
397 SWAP(u
)->just_activated
= !SWAP(u
)->from_proc_swaps
;
400 SWAP(u
)->from_proc_swaps
= true;
403 p
= &SWAP(u
)->parameters_etc_fstab
;
405 if (!(wp
= strdup(what
))) {
413 SWAP(u
)->from_etc_fstab
= true;
416 p
->priority
= priority
;
421 unit_add_to_dbus_queue(u
);
428 log_warning("Failed to load swap unit: %s", strerror(-r
));
439 static int swap_process_new_swap(Manager
*m
, const char *device
, int prio
, bool set_flags
) {
445 if (stat(device
, &st
) >= 0 && S_ISBLK(st
.st_mode
)) {
446 struct udev_device
*d
;
448 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
450 /* So this is a proper swap device. Create swap units
451 * for all names this swap device is known under */
453 if (!(d
= udev_device_new_from_devnum(m
->udev
, 'b', st
.st_rdev
)))
456 if ((dn
= udev_device_get_devnode(d
)))
457 r
= swap_add_one(m
, dn
, device
, prio
, false, false, false, set_flags
);
459 /* Add additional units for all symlinks */
460 first
= udev_device_get_devlinks_list_entry(d
);
461 udev_list_entry_foreach(item
, first
) {
464 /* Don't bother with the /dev/block links */
465 p
= udev_list_entry_get_name(item
);
467 if (path_startswith(p
, "/dev/block/"))
470 if (stat(p
, &st
) >= 0)
471 if ((!S_ISBLK(st
.st_mode
)) || st
.st_rdev
!= udev_device_get_devnum(d
))
474 if ((k
= swap_add_one(m
, p
, device
, prio
, false, false, false, set_flags
)) < 0)
478 udev_device_unref(d
);
481 if ((k
= swap_add_one(m
, device
, device
, prio
, false, false, false, set_flags
)) < 0)
487 static void swap_set_state(Swap
*s
, SwapState state
) {
492 old_state
= s
->state
;
495 if (state
!= SWAP_ACTIVATING
&&
496 state
!= SWAP_ACTIVATING_SIGTERM
&&
497 state
!= SWAP_ACTIVATING_SIGKILL
&&
498 state
!= SWAP_DEACTIVATING
&&
499 state
!= SWAP_DEACTIVATING_SIGTERM
&&
500 state
!= SWAP_DEACTIVATING_SIGKILL
) {
501 unit_unwatch_timer(UNIT(s
), &s
->timer_watch
);
502 swap_unwatch_control_pid(s
);
503 s
->control_command
= NULL
;
504 s
->control_command_id
= _SWAP_EXEC_COMMAND_INVALID
;
507 if (state
!= old_state
)
508 log_debug("%s changed %s -> %s",
510 swap_state_to_string(old_state
),
511 swap_state_to_string(state
));
513 unit_notify(UNIT(s
), state_translation_table
[old_state
], state_translation_table
[state
], true);
516 static int swap_coldplug(Unit
*u
) {
518 SwapState new_state
= SWAP_DEAD
;
522 assert(s
->state
== SWAP_DEAD
);
524 if (s
->deserialized_state
!= s
->state
)
525 new_state
= s
->deserialized_state
;
526 else if (s
->from_proc_swaps
)
527 new_state
= SWAP_ACTIVE
;
529 if (new_state
!= s
->state
) {
531 if (new_state
== SWAP_ACTIVATING
||
532 new_state
== SWAP_ACTIVATING_SIGTERM
||
533 new_state
== SWAP_ACTIVATING_SIGKILL
||
534 new_state
== SWAP_DEACTIVATING
||
535 new_state
== SWAP_DEACTIVATING_SIGTERM
||
536 new_state
== SWAP_DEACTIVATING_SIGKILL
) {
538 if (s
->control_pid
<= 0)
541 if ((r
= unit_watch_pid(UNIT(s
), s
->control_pid
)) < 0)
544 if ((r
= unit_watch_timer(UNIT(s
), s
->timeout_usec
, &s
->timer_watch
)) < 0)
548 swap_set_state(s
, new_state
);
554 static void swap_dump(Unit
*u
, FILE *f
, const char *prefix
) {
561 if (s
->from_proc_swaps
)
562 p
= &s
->parameters_proc_swaps
;
563 else if (s
->from_fragment
)
564 p
= &s
->parameters_fragment
;
566 p
= &s
->parameters_etc_fstab
;
575 "%sFrom /etc/fstab: %s\n"
576 "%sFrom /proc/swaps: %s\n"
577 "%sFrom fragment: %s\n",
578 prefix
, swap_state_to_string(s
->state
),
581 prefix
, yes_no(p
->noauto
),
582 prefix
, yes_no(p
->nofail
),
583 prefix
, yes_no(p
->handle
),
584 prefix
, yes_no(s
->from_etc_fstab
),
585 prefix
, yes_no(s
->from_proc_swaps
),
586 prefix
, yes_no(s
->from_fragment
));
588 if (s
->control_pid
> 0)
590 "%sControl PID: %lu\n",
591 prefix
, (unsigned long) s
->control_pid
);
593 exec_context_dump(&s
->exec_context
, f
, prefix
);
596 static int swap_spawn(Swap
*s
, ExecCommand
*c
, pid_t
*_pid
) {
604 if ((r
= unit_watch_timer(UNIT(s
), s
->timeout_usec
, &s
->timer_watch
)) < 0)
607 if ((r
= exec_spawn(c
,
611 s
->meta
.manager
->environment
,
615 s
->meta
.manager
->confirm_spawn
,
616 s
->meta
.cgroup_bondings
,
617 s
->meta
.cgroup_attributes
,
621 if ((r
= unit_watch_pid(UNIT(s
), pid
)) < 0)
622 /* FIXME: we need to do something here */
630 unit_unwatch_timer(UNIT(s
), &s
->timer_watch
);
635 static void swap_enter_dead(Swap
*s
, bool success
) {
641 swap_set_state(s
, s
->failure
? SWAP_FAILED
: SWAP_DEAD
);
644 static void swap_enter_active(Swap
*s
, bool success
) {
650 swap_set_state(s
, SWAP_ACTIVE
);
653 static void swap_enter_signal(Swap
*s
, SwapState state
, bool success
) {
656 bool wait_for_exit
= false;
663 if (s
->exec_context
.kill_mode
!= KILL_NONE
) {
664 int sig
= (state
== SWAP_ACTIVATING_SIGTERM
||
665 state
== SWAP_DEACTIVATING_SIGTERM
) ? s
->exec_context
.kill_signal
: SIGKILL
;
667 if (s
->control_pid
> 0) {
668 if (kill_and_sigcont(s
->control_pid
, sig
) < 0 && errno
!= ESRCH
)
670 log_warning("Failed to kill control process %li: %m", (long) s
->control_pid
);
672 wait_for_exit
= true;
675 if (s
->exec_context
.kill_mode
== KILL_CONTROL_GROUP
) {
677 if (!(pid_set
= set_new(trivial_hash_func
, trivial_compare_func
))) {
682 /* Exclude the control pid from being killed via the cgroup */
683 if (s
->control_pid
> 0)
684 if ((r
= set_put(pid_set
, LONG_TO_PTR(s
->control_pid
))) < 0)
687 if ((r
= cgroup_bonding_kill_list(s
->meta
.cgroup_bondings
, sig
, true, pid_set
)) < 0) {
688 if (r
!= -EAGAIN
&& r
!= -ESRCH
&& r
!= -ENOENT
)
689 log_warning("Failed to kill control group: %s", strerror(-r
));
691 wait_for_exit
= true;
699 if ((r
= unit_watch_timer(UNIT(s
), s
->timeout_usec
, &s
->timer_watch
)) < 0)
702 swap_set_state(s
, state
);
704 swap_enter_dead(s
, true);
709 log_warning("%s failed to kill processes: %s", s
->meta
.id
, strerror(-r
));
711 swap_enter_dead(s
, false);
717 static void swap_enter_activating(Swap
*s
) {
722 s
->control_command_id
= SWAP_EXEC_ACTIVATE
;
723 s
->control_command
= s
->exec_command
+ SWAP_EXEC_ACTIVATE
;
725 if (s
->from_fragment
)
726 priority
= s
->parameters_fragment
.priority
;
727 else if (s
->from_etc_fstab
)
728 priority
= s
->parameters_etc_fstab
.priority
;
735 snprintf(p
, sizeof(p
), "%i", priority
);
738 r
= exec_command_set(
746 r
= exec_command_set(
755 swap_unwatch_control_pid(s
);
757 if ((r
= swap_spawn(s
, s
->control_command
, &s
->control_pid
)) < 0)
760 swap_set_state(s
, SWAP_ACTIVATING
);
765 log_warning("%s failed to run 'swapon' task: %s", s
->meta
.id
, strerror(-r
));
766 swap_enter_dead(s
, false);
769 static void swap_enter_deactivating(Swap
*s
, bool success
) {
777 s
->control_command_id
= SWAP_EXEC_DEACTIVATE
;
778 s
->control_command
= s
->exec_command
+ SWAP_EXEC_DEACTIVATE
;
780 if ((r
= exec_command_set(
787 swap_unwatch_control_pid(s
);
789 if ((r
= swap_spawn(s
, s
->control_command
, &s
->control_pid
)) < 0)
792 swap_set_state(s
, SWAP_DEACTIVATING
);
797 log_warning("%s failed to run 'swapoff' task: %s", s
->meta
.id
, strerror(-r
));
798 swap_enter_active(s
, false);
801 static int swap_start(Unit
*u
) {
806 /* We cannot fulfill this request right now, try again later
809 if (s
->state
== SWAP_DEACTIVATING
||
810 s
->state
== SWAP_DEACTIVATING_SIGTERM
||
811 s
->state
== SWAP_DEACTIVATING_SIGKILL
||
812 s
->state
== SWAP_ACTIVATING_SIGTERM
||
813 s
->state
== SWAP_ACTIVATING_SIGKILL
)
816 if (s
->state
== SWAP_ACTIVATING
)
819 assert(s
->state
== SWAP_DEAD
|| s
->state
== SWAP_FAILED
);
822 swap_enter_activating(s
);
826 static int swap_stop(Unit
*u
) {
831 if (s
->state
== SWAP_DEACTIVATING
||
832 s
->state
== SWAP_DEACTIVATING_SIGTERM
||
833 s
->state
== SWAP_DEACTIVATING_SIGKILL
||
834 s
->state
== SWAP_ACTIVATING_SIGTERM
||
835 s
->state
== SWAP_ACTIVATING_SIGKILL
)
838 assert(s
->state
== SWAP_ACTIVATING
||
839 s
->state
== SWAP_ACTIVE
);
841 swap_enter_deactivating(s
, true);
845 static int swap_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
852 unit_serialize_item(u
, f
, "state", swap_state_to_string(s
->state
));
853 unit_serialize_item(u
, f
, "failure", yes_no(s
->failure
));
855 if (s
->control_pid
> 0)
856 unit_serialize_item_format(u
, f
, "control-pid", "%lu", (unsigned long) s
->control_pid
);
858 if (s
->control_command_id
>= 0)
859 unit_serialize_item(u
, f
, "control-command", swap_exec_command_to_string(s
->control_command_id
));
864 static int swap_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
870 if (streq(key
, "state")) {
873 if ((state
= swap_state_from_string(value
)) < 0)
874 log_debug("Failed to parse state value %s", value
);
876 s
->deserialized_state
= state
;
877 } else if (streq(key
, "failure")) {
880 if ((b
= parse_boolean(value
)) < 0)
881 log_debug("Failed to parse failure value %s", value
);
883 s
->failure
= b
|| s
->failure
;
885 } else if (streq(key
, "control-pid")) {
888 if (parse_pid(value
, &pid
) < 0)
889 log_debug("Failed to parse control-pid value %s", value
);
891 s
->control_pid
= pid
;
893 } else if (streq(key
, "control-command")) {
896 if ((id
= swap_exec_command_from_string(value
)) < 0)
897 log_debug("Failed to parse exec-command value %s", value
);
899 s
->control_command_id
= id
;
900 s
->control_command
= s
->exec_command
+ id
;
904 log_debug("Unknown serialization key '%s'", key
);
909 static UnitActiveState
swap_active_state(Unit
*u
) {
912 return state_translation_table
[SWAP(u
)->state
];
915 static const char *swap_sub_state_to_string(Unit
*u
) {
918 return swap_state_to_string(SWAP(u
)->state
);
921 static bool swap_check_gc(Unit
*u
) {
926 return s
->from_etc_fstab
|| s
->from_proc_swaps
;
929 static void swap_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
936 if (pid
!= s
->control_pid
)
941 success
= is_clean_exit(code
, status
);
942 s
->failure
= s
->failure
|| !success
;
944 if (s
->control_command
) {
945 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
946 s
->control_command
= NULL
;
947 s
->control_command_id
= _SWAP_EXEC_COMMAND_INVALID
;
950 log_full(success
? LOG_DEBUG
: LOG_NOTICE
,
951 "%s swap process exited, code=%s status=%i", u
->meta
.id
, sigchld_code_to_string(code
), status
);
955 case SWAP_ACTIVATING
:
956 case SWAP_ACTIVATING_SIGTERM
:
957 case SWAP_ACTIVATING_SIGKILL
:
960 swap_enter_active(s
, true);
962 swap_enter_dead(s
, false);
965 case SWAP_DEACTIVATING
:
966 case SWAP_DEACTIVATING_SIGKILL
:
967 case SWAP_DEACTIVATING_SIGTERM
:
970 swap_enter_dead(s
, true);
972 swap_enter_dead(s
, false);
976 assert_not_reached("Uh, control process died at wrong time.");
979 /* Notify clients about changed exit status */
980 unit_add_to_dbus_queue(u
);
982 /* Request a reload of /proc/swaps, so that following units
983 * can follow our state change */
984 u
->meta
.manager
->request_reload
= true;
987 static void swap_timer_event(Unit
*u
, uint64_t elapsed
, Watch
*w
) {
991 assert(elapsed
== 1);
992 assert(w
== &s
->timer_watch
);
996 case SWAP_ACTIVATING
:
997 log_warning("%s activation timed out. Stopping.", u
->meta
.id
);
998 swap_enter_signal(s
, SWAP_ACTIVATING_SIGTERM
, false);
1001 case SWAP_DEACTIVATING
:
1002 log_warning("%s deactivation timed out. Stopping.", u
->meta
.id
);
1003 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGTERM
, false);
1006 case SWAP_ACTIVATING_SIGTERM
:
1007 if (s
->exec_context
.send_sigkill
) {
1008 log_warning("%s activation timed out. Killing.", u
->meta
.id
);
1009 swap_enter_signal(s
, SWAP_ACTIVATING_SIGKILL
, false);
1011 log_warning("%s activation timed out. Skipping SIGKILL. Ignoring.", u
->meta
.id
);
1012 swap_enter_dead(s
, false);
1016 case SWAP_DEACTIVATING_SIGTERM
:
1017 if (s
->exec_context
.send_sigkill
) {
1018 log_warning("%s deactivation timed out. Killing.", u
->meta
.id
);
1019 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGKILL
, false);
1021 log_warning("%s deactivation timed out. Skipping SIGKILL. Ignoring.", u
->meta
.id
);
1022 swap_enter_dead(s
, false);
1026 case SWAP_ACTIVATING_SIGKILL
:
1027 case SWAP_DEACTIVATING_SIGKILL
:
1028 log_warning("%s swap process still around after SIGKILL. Ignoring.", u
->meta
.id
);
1029 swap_enter_dead(s
, false);
1033 assert_not_reached("Timeout at wrong time.");
1037 static int swap_load_proc_swaps(Manager
*m
, bool set_flags
) {
1043 rewind(m
->proc_swaps
);
1045 (void) fscanf(m
->proc_swaps
, "%*s %*s %*s %*s %*s\n");
1048 char *dev
= NULL
, *d
;
1051 if ((k
= fscanf(m
->proc_swaps
,
1052 "%ms " /* device/file */
1053 "%*s " /* type of swap */
1054 "%*s " /* swap size */
1056 "%i\n", /* priority */
1057 &dev
, &prio
)) != 2) {
1062 log_warning("Failed to parse /proc/swaps:%u.", i
);
1073 k
= swap_process_new_swap(m
, d
, prio
, set_flags
);
1083 int swap_dispatch_reload(Manager
*m
) {
1084 /* This function should go as soon as the kernel properly notifies us */
1086 if (_likely_(!m
->request_reload
))
1089 m
->request_reload
= false;
1091 return swap_fd_event(m
, EPOLLPRI
);
1094 int swap_fd_event(Manager
*m
, int events
) {
1099 assert(events
& EPOLLPRI
);
1101 if ((r
= swap_load_proc_swaps(m
, true)) < 0) {
1102 log_error("Failed to reread /proc/swaps: %s", strerror(-r
));
1104 /* Reset flags, just in case, for late calls */
1105 LIST_FOREACH(units_by_type
, meta
, m
->units_by_type
[UNIT_SWAP
]) {
1106 Swap
*swap
= (Swap
*) meta
;
1108 swap
->is_active
= swap
->just_activated
= false;
1114 manager_dispatch_load_queue(m
);
1116 LIST_FOREACH(units_by_type
, meta
, m
->units_by_type
[UNIT_SWAP
]) {
1117 Swap
*swap
= (Swap
*) meta
;
1119 if (!swap
->is_active
) {
1120 /* This has just been deactivated */
1122 swap
->from_proc_swaps
= false;
1123 swap_unset_proc_swaps(swap
);
1125 switch (swap
->state
) {
1128 swap_enter_dead(swap
, true);
1132 swap_set_state(swap
, swap
->state
);
1136 } else if (swap
->just_activated
) {
1138 /* New swap entry */
1140 switch (swap
->state
) {
1144 swap_enter_active(swap
, true);
1148 /* Nothing really changed, but let's
1149 * issue an notification call
1150 * nonetheless, in case somebody is
1151 * waiting for this. */
1152 swap_set_state(swap
, swap
->state
);
1157 /* Reset the flags for later calls */
1158 swap
->is_active
= swap
->just_activated
= false;
1164 static Unit
*swap_following(Unit
*u
) {
1166 Swap
*other
, *first
= NULL
;
1170 if (streq_ptr(s
->what
, s
->parameters_proc_swaps
.what
))
1173 /* Make everybody follow the unit that's named after the swap
1174 * device in the kernel */
1176 LIST_FOREACH_AFTER(same_proc_swaps
, other
, s
)
1177 if (streq_ptr(other
->what
, other
->parameters_proc_swaps
.what
))
1180 LIST_FOREACH_BEFORE(same_proc_swaps
, other
, s
) {
1181 if (streq_ptr(other
->what
, other
->parameters_proc_swaps
.what
))
1190 static int swap_following_set(Unit
*u
, Set
**_set
) {
1199 if (LIST_JUST_US(same_proc_swaps
, s
)) {
1204 if (!(set
= set_new(NULL
, NULL
)))
1207 LIST_FOREACH_AFTER(same_proc_swaps
, other
, s
)
1208 if ((r
= set_put(set
, other
)) < 0)
1211 LIST_FOREACH_BEFORE(same_proc_swaps
, other
, s
)
1212 if ((r
= set_put(set
, other
)) < 0)
1223 static void swap_shutdown(Manager
*m
) {
1226 if (m
->proc_swaps
) {
1227 fclose(m
->proc_swaps
);
1228 m
->proc_swaps
= NULL
;
1231 hashmap_free(m
->swaps_by_proc_swaps
);
1232 m
->swaps_by_proc_swaps
= NULL
;
1235 static int swap_enumerate(Manager
*m
) {
1237 struct epoll_event ev
;
1240 if (!m
->proc_swaps
) {
1241 if (!(m
->proc_swaps
= fopen("/proc/swaps", "re")))
1242 return (errno
== ENOENT
) ? 0 : -errno
;
1244 m
->swap_watch
.type
= WATCH_SWAP
;
1245 m
->swap_watch
.fd
= fileno(m
->proc_swaps
);
1248 ev
.events
= EPOLLPRI
;
1249 ev
.data
.ptr
= &m
->swap_watch
;
1251 if (epoll_ctl(m
->epoll_fd
, EPOLL_CTL_ADD
, m
->swap_watch
.fd
, &ev
) < 0)
1255 /* We rely on mount.c to load /etc/fstab for us */
1257 if ((r
= swap_load_proc_swaps(m
, false)) < 0)
1263 static void swap_reset_failed(Unit
*u
) {
1268 if (s
->state
== SWAP_FAILED
)
1269 swap_set_state(s
, SWAP_DEAD
);
1274 static int swap_kill(Unit
*u
, KillWho who
, KillMode mode
, int signo
, DBusError
*error
) {
1277 Set
*pid_set
= NULL
;
1281 if (who
== KILL_MAIN
) {
1282 dbus_set_error(error
, BUS_ERROR_NO_SUCH_PROCESS
, "Swap units have no main processes");
1286 if (s
->control_pid
<= 0 && who
== KILL_CONTROL
) {
1287 dbus_set_error(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No control process to kill");
1291 if (who
== KILL_CONTROL
|| who
== KILL_ALL
)
1292 if (s
->control_pid
> 0)
1293 if (kill(s
->control_pid
, signo
) < 0)
1296 if (who
== KILL_ALL
&& mode
== KILL_CONTROL_GROUP
) {
1299 if (!(pid_set
= set_new(trivial_hash_func
, trivial_compare_func
)))
1302 /* Exclude the control pid from being killed via the cgroup */
1303 if (s
->control_pid
> 0)
1304 if ((q
= set_put(pid_set
, LONG_TO_PTR(s
->control_pid
))) < 0) {
1309 if ((q
= cgroup_bonding_kill_list(s
->meta
.cgroup_bondings
, signo
, false, pid_set
)) < 0)
1310 if (q
!= -EAGAIN
&& q
!= -ESRCH
&& q
!= -ENOENT
)
1321 static const char* const swap_state_table
[_SWAP_STATE_MAX
] = {
1322 [SWAP_DEAD
] = "dead",
1323 [SWAP_ACTIVATING
] = "activating",
1324 [SWAP_ACTIVE
] = "active",
1325 [SWAP_DEACTIVATING
] = "deactivating",
1326 [SWAP_ACTIVATING_SIGTERM
] = "activating-sigterm",
1327 [SWAP_ACTIVATING_SIGKILL
] = "activating-sigkill",
1328 [SWAP_DEACTIVATING_SIGTERM
] = "deactivating-sigterm",
1329 [SWAP_DEACTIVATING_SIGKILL
] = "deactivating-sigkill",
1330 [SWAP_FAILED
] = "failed"
1333 DEFINE_STRING_TABLE_LOOKUP(swap_state
, SwapState
);
1335 static const char* const swap_exec_command_table
[_SWAP_EXEC_COMMAND_MAX
] = {
1336 [SWAP_EXEC_ACTIVATE
] = "ExecActivate",
1337 [SWAP_EXEC_DEACTIVATE
] = "ExecDeactivate",
1340 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command
, SwapExecCommand
);
1342 const UnitVTable swap_vtable
= {
1350 .no_instances
= true,
1351 .show_status
= true,
1357 .coldplug
= swap_coldplug
,
1361 .start
= swap_start
,
1366 .serialize
= swap_serialize
,
1367 .deserialize_item
= swap_deserialize_item
,
1369 .active_state
= swap_active_state
,
1370 .sub_state_to_string
= swap_sub_state_to_string
,
1372 .check_gc
= swap_check_gc
,
1374 .sigchld_event
= swap_sigchld_event
,
1375 .timer_event
= swap_timer_event
,
1377 .reset_failed
= swap_reset_failed
,
1379 .bus_interface
= "org.freedesktop.systemd1.Swap",
1380 .bus_message_handler
= bus_swap_message_handler
,
1381 .bus_invalidating_properties
= bus_swap_invalidating_properties
,
1383 .following
= swap_following
,
1384 .following_set
= swap_following_set
,
1386 .enumerate
= swap_enumerate
,
1387 .shutdown
= swap_shutdown