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(UNIT(s
)->manager
->swaps_by_proc_swaps
, s
->parameters_proc_swaps
.what
);
66 LIST_REMOVE(Swap
, same_proc_swaps
, first
, s
);
69 hashmap_remove_and_replace(UNIT(s
)->manager
->swaps_by_proc_swaps
, s
->parameters_proc_swaps
.what
, first
->parameters_proc_swaps
.what
, first
);
71 hashmap_remove(UNIT(s
)->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(UNIT(s
)->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
->manager
->default_std_output
;
87 s
->exec_context
.std_error
= u
->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 UNIT(s
)->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 (UNIT(s
)->load_state
!= UNIT_LOADED
||
138 UNIT(m
)->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
, UNIT(s
)->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(UNIT(s
)->manager
, SPECIAL_SWAP_TARGET
, NULL
, NULL
, &tu
)) < 0)
185 (p
->handle
|| UNIT(s
)->manager
->swap_auto
) &&
187 UNIT(s
)->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 UNIT(s
)->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 (UNIT(s
)->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 (UNIT(s
)->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", UNIT(s
)->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.", UNIT(s
)->id
);
260 static int swap_load(Unit
*u
) {
265 assert(u
->load_state
== UNIT_STUB
);
267 /* Load a .swap file */
268 if ((r
= unit_load_fragment_and_dropin_optional(u
)) < 0)
271 if (u
->load_state
== UNIT_LOADED
) {
272 if ((r
= unit_add_exec_dependencies(u
, &s
->exec_context
)) < 0)
275 if (UNIT(s
)->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
->id
);
292 path_kill_slashes(s
->what
);
294 if (!UNIT(s
)->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 (UNIT(s
)->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 e
= unit_name_from_path(what
, ".swap");
341 u
= manager_get_unit(m
, e
);
343 if (what_proc_swaps
&&
345 SWAP(u
)->from_proc_swaps
&&
346 !path_equal(SWAP(u
)->parameters_proc_swaps
.what
, what_proc_swaps
))
352 u
= unit_new(m
, sizeof(Swap
));
358 r
= unit_add_name(u
, e
);
362 SWAP(u
)->what
= strdup(what
);
363 if (!SWAP(u
)->what
) {
368 unit_add_to_load_queue(u
);
372 if (what_proc_swaps
) {
375 p
= &SWAP(u
)->parameters_proc_swaps
;
378 if (!(wp
= strdup(what_proc_swaps
))) {
383 if (!m
->swaps_by_proc_swaps
)
384 if (!(m
->swaps_by_proc_swaps
= hashmap_new(string_hash_func
, string_compare_func
))) {
392 first
= hashmap_get(m
->swaps_by_proc_swaps
, wp
);
393 LIST_PREPEND(Swap
, same_proc_swaps
, first
, SWAP(u
));
395 if ((r
= hashmap_replace(m
->swaps_by_proc_swaps
, wp
, first
)) < 0)
400 SWAP(u
)->is_active
= true;
401 SWAP(u
)->just_activated
= !SWAP(u
)->from_proc_swaps
;
404 SWAP(u
)->from_proc_swaps
= true;
407 p
= &SWAP(u
)->parameters_etc_fstab
;
409 if (!(wp
= strdup(what
))) {
417 SWAP(u
)->from_etc_fstab
= true;
420 p
->priority
= priority
;
425 unit_add_to_dbus_queue(u
);
432 log_warning("Failed to load swap unit: %s", strerror(-r
));
443 static int swap_process_new_swap(Manager
*m
, const char *device
, int prio
, bool set_flags
) {
449 if (stat(device
, &st
) >= 0 && S_ISBLK(st
.st_mode
)) {
450 struct udev_device
*d
;
452 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
454 /* So this is a proper swap device. Create swap units
455 * for all names this swap device is known under */
457 if (!(d
= udev_device_new_from_devnum(m
->udev
, 'b', st
.st_rdev
)))
460 if ((dn
= udev_device_get_devnode(d
)))
461 r
= swap_add_one(m
, dn
, device
, prio
, false, false, false, set_flags
);
463 /* Add additional units for all symlinks */
464 first
= udev_device_get_devlinks_list_entry(d
);
465 udev_list_entry_foreach(item
, first
) {
468 /* Don't bother with the /dev/block links */
469 p
= udev_list_entry_get_name(item
);
471 if (path_startswith(p
, "/dev/block/"))
474 if (stat(p
, &st
) >= 0)
475 if ((!S_ISBLK(st
.st_mode
)) || st
.st_rdev
!= udev_device_get_devnum(d
))
478 if ((k
= swap_add_one(m
, p
, device
, prio
, false, false, false, set_flags
)) < 0)
482 udev_device_unref(d
);
485 if ((k
= swap_add_one(m
, device
, device
, prio
, false, false, false, set_flags
)) < 0)
491 static void swap_set_state(Swap
*s
, SwapState state
) {
496 old_state
= s
->state
;
499 if (state
!= SWAP_ACTIVATING
&&
500 state
!= SWAP_ACTIVATING_SIGTERM
&&
501 state
!= SWAP_ACTIVATING_SIGKILL
&&
502 state
!= SWAP_DEACTIVATING
&&
503 state
!= SWAP_DEACTIVATING_SIGTERM
&&
504 state
!= SWAP_DEACTIVATING_SIGKILL
) {
505 unit_unwatch_timer(UNIT(s
), &s
->timer_watch
);
506 swap_unwatch_control_pid(s
);
507 s
->control_command
= NULL
;
508 s
->control_command_id
= _SWAP_EXEC_COMMAND_INVALID
;
511 if (state
!= old_state
)
512 log_debug("%s changed %s -> %s",
514 swap_state_to_string(old_state
),
515 swap_state_to_string(state
));
517 unit_notify(UNIT(s
), state_translation_table
[old_state
], state_translation_table
[state
], true);
520 static int swap_coldplug(Unit
*u
) {
522 SwapState new_state
= SWAP_DEAD
;
526 assert(s
->state
== SWAP_DEAD
);
528 if (s
->deserialized_state
!= s
->state
)
529 new_state
= s
->deserialized_state
;
530 else if (s
->from_proc_swaps
)
531 new_state
= SWAP_ACTIVE
;
533 if (new_state
!= s
->state
) {
535 if (new_state
== SWAP_ACTIVATING
||
536 new_state
== SWAP_ACTIVATING_SIGTERM
||
537 new_state
== SWAP_ACTIVATING_SIGKILL
||
538 new_state
== SWAP_DEACTIVATING
||
539 new_state
== SWAP_DEACTIVATING_SIGTERM
||
540 new_state
== SWAP_DEACTIVATING_SIGKILL
) {
542 if (s
->control_pid
<= 0)
545 if ((r
= unit_watch_pid(UNIT(s
), s
->control_pid
)) < 0)
548 if ((r
= unit_watch_timer(UNIT(s
), s
->timeout_usec
, &s
->timer_watch
)) < 0)
552 swap_set_state(s
, new_state
);
558 static void swap_dump(Unit
*u
, FILE *f
, const char *prefix
) {
565 if (s
->from_proc_swaps
)
566 p
= &s
->parameters_proc_swaps
;
567 else if (s
->from_fragment
)
568 p
= &s
->parameters_fragment
;
570 p
= &s
->parameters_etc_fstab
;
579 "%sFrom /etc/fstab: %s\n"
580 "%sFrom /proc/swaps: %s\n"
581 "%sFrom fragment: %s\n",
582 prefix
, swap_state_to_string(s
->state
),
585 prefix
, yes_no(p
->noauto
),
586 prefix
, yes_no(p
->nofail
),
587 prefix
, yes_no(p
->handle
),
588 prefix
, yes_no(s
->from_etc_fstab
),
589 prefix
, yes_no(s
->from_proc_swaps
),
590 prefix
, yes_no(s
->from_fragment
));
592 if (s
->control_pid
> 0)
594 "%sControl PID: %lu\n",
595 prefix
, (unsigned long) s
->control_pid
);
597 exec_context_dump(&s
->exec_context
, f
, prefix
);
600 static int swap_spawn(Swap
*s
, ExecCommand
*c
, pid_t
*_pid
) {
608 if ((r
= unit_watch_timer(UNIT(s
), s
->timeout_usec
, &s
->timer_watch
)) < 0)
611 if ((r
= exec_spawn(c
,
615 UNIT(s
)->manager
->environment
,
619 UNIT(s
)->manager
->confirm_spawn
,
620 UNIT(s
)->cgroup_bondings
,
621 UNIT(s
)->cgroup_attributes
,
625 if ((r
= unit_watch_pid(UNIT(s
), pid
)) < 0)
626 /* FIXME: we need to do something here */
634 unit_unwatch_timer(UNIT(s
), &s
->timer_watch
);
639 static void swap_enter_dead(Swap
*s
, bool success
) {
645 swap_set_state(s
, s
->failure
? SWAP_FAILED
: SWAP_DEAD
);
648 static void swap_enter_active(Swap
*s
, bool success
) {
654 swap_set_state(s
, SWAP_ACTIVE
);
657 static void swap_enter_signal(Swap
*s
, SwapState state
, bool success
) {
660 bool wait_for_exit
= false;
667 if (s
->exec_context
.kill_mode
!= KILL_NONE
) {
668 int sig
= (state
== SWAP_ACTIVATING_SIGTERM
||
669 state
== SWAP_DEACTIVATING_SIGTERM
) ? s
->exec_context
.kill_signal
: SIGKILL
;
671 if (s
->control_pid
> 0) {
672 if (kill_and_sigcont(s
->control_pid
, sig
) < 0 && errno
!= ESRCH
)
674 log_warning("Failed to kill control process %li: %m", (long) s
->control_pid
);
676 wait_for_exit
= true;
679 if (s
->exec_context
.kill_mode
== KILL_CONTROL_GROUP
) {
681 if (!(pid_set
= set_new(trivial_hash_func
, trivial_compare_func
))) {
686 /* Exclude the control pid from being killed via the cgroup */
687 if (s
->control_pid
> 0)
688 if ((r
= set_put(pid_set
, LONG_TO_PTR(s
->control_pid
))) < 0)
691 if ((r
= cgroup_bonding_kill_list(UNIT(s
)->cgroup_bondings
, sig
, true, pid_set
)) < 0) {
692 if (r
!= -EAGAIN
&& r
!= -ESRCH
&& r
!= -ENOENT
)
693 log_warning("Failed to kill control group: %s", strerror(-r
));
695 wait_for_exit
= true;
703 if ((r
= unit_watch_timer(UNIT(s
), s
->timeout_usec
, &s
->timer_watch
)) < 0)
706 swap_set_state(s
, state
);
708 swap_enter_dead(s
, true);
713 log_warning("%s failed to kill processes: %s", UNIT(s
)->id
, strerror(-r
));
715 swap_enter_dead(s
, false);
721 static void swap_enter_activating(Swap
*s
) {
726 s
->control_command_id
= SWAP_EXEC_ACTIVATE
;
727 s
->control_command
= s
->exec_command
+ SWAP_EXEC_ACTIVATE
;
729 if (s
->from_fragment
)
730 priority
= s
->parameters_fragment
.priority
;
731 else if (s
->from_etc_fstab
)
732 priority
= s
->parameters_etc_fstab
.priority
;
739 snprintf(p
, sizeof(p
), "%i", priority
);
742 r
= exec_command_set(
750 r
= exec_command_set(
759 swap_unwatch_control_pid(s
);
761 if ((r
= swap_spawn(s
, s
->control_command
, &s
->control_pid
)) < 0)
764 swap_set_state(s
, SWAP_ACTIVATING
);
769 log_warning("%s failed to run 'swapon' task: %s", UNIT(s
)->id
, strerror(-r
));
770 swap_enter_dead(s
, false);
773 static void swap_enter_deactivating(Swap
*s
, bool success
) {
781 s
->control_command_id
= SWAP_EXEC_DEACTIVATE
;
782 s
->control_command
= s
->exec_command
+ SWAP_EXEC_DEACTIVATE
;
784 if ((r
= exec_command_set(
791 swap_unwatch_control_pid(s
);
793 if ((r
= swap_spawn(s
, s
->control_command
, &s
->control_pid
)) < 0)
796 swap_set_state(s
, SWAP_DEACTIVATING
);
801 log_warning("%s failed to run 'swapoff' task: %s", UNIT(s
)->id
, strerror(-r
));
802 swap_enter_active(s
, false);
805 static int swap_start(Unit
*u
) {
810 /* We cannot fulfill this request right now, try again later
813 if (s
->state
== SWAP_DEACTIVATING
||
814 s
->state
== SWAP_DEACTIVATING_SIGTERM
||
815 s
->state
== SWAP_DEACTIVATING_SIGKILL
||
816 s
->state
== SWAP_ACTIVATING_SIGTERM
||
817 s
->state
== SWAP_ACTIVATING_SIGKILL
)
820 if (s
->state
== SWAP_ACTIVATING
)
823 assert(s
->state
== SWAP_DEAD
|| s
->state
== SWAP_FAILED
);
826 swap_enter_activating(s
);
830 static int swap_stop(Unit
*u
) {
835 if (s
->state
== SWAP_DEACTIVATING
||
836 s
->state
== SWAP_DEACTIVATING_SIGTERM
||
837 s
->state
== SWAP_DEACTIVATING_SIGKILL
||
838 s
->state
== SWAP_ACTIVATING_SIGTERM
||
839 s
->state
== SWAP_ACTIVATING_SIGKILL
)
842 assert(s
->state
== SWAP_ACTIVATING
||
843 s
->state
== SWAP_ACTIVE
);
845 swap_enter_deactivating(s
, true);
849 static int swap_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
856 unit_serialize_item(u
, f
, "state", swap_state_to_string(s
->state
));
857 unit_serialize_item(u
, f
, "failure", yes_no(s
->failure
));
859 if (s
->control_pid
> 0)
860 unit_serialize_item_format(u
, f
, "control-pid", "%lu", (unsigned long) s
->control_pid
);
862 if (s
->control_command_id
>= 0)
863 unit_serialize_item(u
, f
, "control-command", swap_exec_command_to_string(s
->control_command_id
));
868 static int swap_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
874 if (streq(key
, "state")) {
877 if ((state
= swap_state_from_string(value
)) < 0)
878 log_debug("Failed to parse state value %s", value
);
880 s
->deserialized_state
= state
;
881 } else if (streq(key
, "failure")) {
884 if ((b
= parse_boolean(value
)) < 0)
885 log_debug("Failed to parse failure value %s", value
);
887 s
->failure
= b
|| s
->failure
;
889 } else if (streq(key
, "control-pid")) {
892 if (parse_pid(value
, &pid
) < 0)
893 log_debug("Failed to parse control-pid value %s", value
);
895 s
->control_pid
= pid
;
897 } else if (streq(key
, "control-command")) {
900 if ((id
= swap_exec_command_from_string(value
)) < 0)
901 log_debug("Failed to parse exec-command value %s", value
);
903 s
->control_command_id
= id
;
904 s
->control_command
= s
->exec_command
+ id
;
908 log_debug("Unknown serialization key '%s'", key
);
913 static UnitActiveState
swap_active_state(Unit
*u
) {
916 return state_translation_table
[SWAP(u
)->state
];
919 static const char *swap_sub_state_to_string(Unit
*u
) {
922 return swap_state_to_string(SWAP(u
)->state
);
925 static bool swap_check_gc(Unit
*u
) {
930 return s
->from_etc_fstab
|| s
->from_proc_swaps
;
933 static void swap_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
940 if (pid
!= s
->control_pid
)
945 success
= is_clean_exit(code
, status
);
946 s
->failure
= s
->failure
|| !success
;
948 if (s
->control_command
) {
949 exec_status_exit(&s
->control_command
->exec_status
, &s
->exec_context
, pid
, code
, status
);
950 s
->control_command
= NULL
;
951 s
->control_command_id
= _SWAP_EXEC_COMMAND_INVALID
;
954 log_full(success
? LOG_DEBUG
: LOG_NOTICE
,
955 "%s swap process exited, code=%s status=%i", u
->id
, sigchld_code_to_string(code
), status
);
959 case SWAP_ACTIVATING
:
960 case SWAP_ACTIVATING_SIGTERM
:
961 case SWAP_ACTIVATING_SIGKILL
:
964 swap_enter_active(s
, true);
966 swap_enter_dead(s
, false);
969 case SWAP_DEACTIVATING
:
970 case SWAP_DEACTIVATING_SIGKILL
:
971 case SWAP_DEACTIVATING_SIGTERM
:
974 swap_enter_dead(s
, true);
976 swap_enter_dead(s
, false);
980 assert_not_reached("Uh, control process died at wrong time.");
983 /* Notify clients about changed exit status */
984 unit_add_to_dbus_queue(u
);
986 /* Request a reload of /proc/swaps, so that following units
987 * can follow our state change */
988 u
->manager
->request_reload
= true;
991 static void swap_timer_event(Unit
*u
, uint64_t elapsed
, Watch
*w
) {
995 assert(elapsed
== 1);
996 assert(w
== &s
->timer_watch
);
1000 case SWAP_ACTIVATING
:
1001 log_warning("%s activation timed out. Stopping.", u
->id
);
1002 swap_enter_signal(s
, SWAP_ACTIVATING_SIGTERM
, false);
1005 case SWAP_DEACTIVATING
:
1006 log_warning("%s deactivation timed out. Stopping.", u
->id
);
1007 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGTERM
, false);
1010 case SWAP_ACTIVATING_SIGTERM
:
1011 if (s
->exec_context
.send_sigkill
) {
1012 log_warning("%s activation timed out. Killing.", u
->id
);
1013 swap_enter_signal(s
, SWAP_ACTIVATING_SIGKILL
, false);
1015 log_warning("%s activation timed out. Skipping SIGKILL. Ignoring.", u
->id
);
1016 swap_enter_dead(s
, false);
1020 case SWAP_DEACTIVATING_SIGTERM
:
1021 if (s
->exec_context
.send_sigkill
) {
1022 log_warning("%s deactivation timed out. Killing.", u
->id
);
1023 swap_enter_signal(s
, SWAP_DEACTIVATING_SIGKILL
, false);
1025 log_warning("%s deactivation timed out. Skipping SIGKILL. Ignoring.", u
->id
);
1026 swap_enter_dead(s
, false);
1030 case SWAP_ACTIVATING_SIGKILL
:
1031 case SWAP_DEACTIVATING_SIGKILL
:
1032 log_warning("%s swap process still around after SIGKILL. Ignoring.", u
->id
);
1033 swap_enter_dead(s
, false);
1037 assert_not_reached("Timeout at wrong time.");
1041 static int swap_load_proc_swaps(Manager
*m
, bool set_flags
) {
1047 rewind(m
->proc_swaps
);
1049 (void) fscanf(m
->proc_swaps
, "%*s %*s %*s %*s %*s\n");
1052 char *dev
= NULL
, *d
;
1055 if ((k
= fscanf(m
->proc_swaps
,
1056 "%ms " /* device/file */
1057 "%*s " /* type of swap */
1058 "%*s " /* swap size */
1060 "%i\n", /* priority */
1061 &dev
, &prio
)) != 2) {
1066 log_warning("Failed to parse /proc/swaps:%u.", i
);
1077 k
= swap_process_new_swap(m
, d
, prio
, set_flags
);
1087 int swap_dispatch_reload(Manager
*m
) {
1088 /* This function should go as soon as the kernel properly notifies us */
1090 if (_likely_(!m
->request_reload
))
1093 m
->request_reload
= false;
1095 return swap_fd_event(m
, EPOLLPRI
);
1098 int swap_fd_event(Manager
*m
, int events
) {
1103 assert(events
& EPOLLPRI
);
1105 if ((r
= swap_load_proc_swaps(m
, true)) < 0) {
1106 log_error("Failed to reread /proc/swaps: %s", strerror(-r
));
1108 /* Reset flags, just in case, for late calls */
1109 LIST_FOREACH(units_by_type
, meta
, m
->units_by_type
[UNIT_SWAP
]) {
1110 Swap
*swap
= (Swap
*) meta
;
1112 swap
->is_active
= swap
->just_activated
= false;
1118 manager_dispatch_load_queue(m
);
1120 LIST_FOREACH(units_by_type
, meta
, m
->units_by_type
[UNIT_SWAP
]) {
1121 Swap
*swap
= (Swap
*) meta
;
1123 if (!swap
->is_active
) {
1124 /* This has just been deactivated */
1126 swap
->from_proc_swaps
= false;
1127 swap_unset_proc_swaps(swap
);
1129 switch (swap
->state
) {
1132 swap_enter_dead(swap
, true);
1136 swap_set_state(swap
, swap
->state
);
1140 } else if (swap
->just_activated
) {
1142 /* New swap entry */
1144 switch (swap
->state
) {
1148 swap_enter_active(swap
, true);
1152 /* Nothing really changed, but let's
1153 * issue an notification call
1154 * nonetheless, in case somebody is
1155 * waiting for this. */
1156 swap_set_state(swap
, swap
->state
);
1161 /* Reset the flags for later calls */
1162 swap
->is_active
= swap
->just_activated
= false;
1168 static Unit
*swap_following(Unit
*u
) {
1170 Swap
*other
, *first
= NULL
;
1174 if (streq_ptr(s
->what
, s
->parameters_proc_swaps
.what
))
1177 /* Make everybody follow the unit that's named after the swap
1178 * device in the kernel */
1180 LIST_FOREACH_AFTER(same_proc_swaps
, other
, s
)
1181 if (streq_ptr(other
->what
, other
->parameters_proc_swaps
.what
))
1184 LIST_FOREACH_BEFORE(same_proc_swaps
, other
, s
) {
1185 if (streq_ptr(other
->what
, other
->parameters_proc_swaps
.what
))
1194 static int swap_following_set(Unit
*u
, Set
**_set
) {
1203 if (LIST_JUST_US(same_proc_swaps
, s
)) {
1208 if (!(set
= set_new(NULL
, NULL
)))
1211 LIST_FOREACH_AFTER(same_proc_swaps
, other
, s
)
1212 if ((r
= set_put(set
, other
)) < 0)
1215 LIST_FOREACH_BEFORE(same_proc_swaps
, other
, s
)
1216 if ((r
= set_put(set
, other
)) < 0)
1227 static void swap_shutdown(Manager
*m
) {
1230 if (m
->proc_swaps
) {
1231 fclose(m
->proc_swaps
);
1232 m
->proc_swaps
= NULL
;
1235 hashmap_free(m
->swaps_by_proc_swaps
);
1236 m
->swaps_by_proc_swaps
= NULL
;
1239 static int swap_enumerate(Manager
*m
) {
1241 struct epoll_event ev
;
1244 if (!m
->proc_swaps
) {
1245 if (!(m
->proc_swaps
= fopen("/proc/swaps", "re")))
1246 return (errno
== ENOENT
) ? 0 : -errno
;
1248 m
->swap_watch
.type
= WATCH_SWAP
;
1249 m
->swap_watch
.fd
= fileno(m
->proc_swaps
);
1252 ev
.events
= EPOLLPRI
;
1253 ev
.data
.ptr
= &m
->swap_watch
;
1255 if (epoll_ctl(m
->epoll_fd
, EPOLL_CTL_ADD
, m
->swap_watch
.fd
, &ev
) < 0)
1259 /* We rely on mount.c to load /etc/fstab for us */
1261 if ((r
= swap_load_proc_swaps(m
, false)) < 0)
1267 static void swap_reset_failed(Unit
*u
) {
1272 if (s
->state
== SWAP_FAILED
)
1273 swap_set_state(s
, SWAP_DEAD
);
1278 static int swap_kill(Unit
*u
, KillWho who
, KillMode mode
, int signo
, DBusError
*error
) {
1281 Set
*pid_set
= NULL
;
1285 if (who
== KILL_MAIN
) {
1286 dbus_set_error(error
, BUS_ERROR_NO_SUCH_PROCESS
, "Swap units have no main processes");
1290 if (s
->control_pid
<= 0 && who
== KILL_CONTROL
) {
1291 dbus_set_error(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No control process to kill");
1295 if (who
== KILL_CONTROL
|| who
== KILL_ALL
)
1296 if (s
->control_pid
> 0)
1297 if (kill(s
->control_pid
, signo
) < 0)
1300 if (who
== KILL_ALL
&& mode
== KILL_CONTROL_GROUP
) {
1303 if (!(pid_set
= set_new(trivial_hash_func
, trivial_compare_func
)))
1306 /* Exclude the control pid from being killed via the cgroup */
1307 if (s
->control_pid
> 0)
1308 if ((q
= set_put(pid_set
, LONG_TO_PTR(s
->control_pid
))) < 0) {
1313 if ((q
= cgroup_bonding_kill_list(UNIT(s
)->cgroup_bondings
, signo
, false, pid_set
)) < 0)
1314 if (q
!= -EAGAIN
&& q
!= -ESRCH
&& q
!= -ENOENT
)
1325 static const char* const swap_state_table
[_SWAP_STATE_MAX
] = {
1326 [SWAP_DEAD
] = "dead",
1327 [SWAP_ACTIVATING
] = "activating",
1328 [SWAP_ACTIVE
] = "active",
1329 [SWAP_DEACTIVATING
] = "deactivating",
1330 [SWAP_ACTIVATING_SIGTERM
] = "activating-sigterm",
1331 [SWAP_ACTIVATING_SIGKILL
] = "activating-sigkill",
1332 [SWAP_DEACTIVATING_SIGTERM
] = "deactivating-sigterm",
1333 [SWAP_DEACTIVATING_SIGKILL
] = "deactivating-sigkill",
1334 [SWAP_FAILED
] = "failed"
1337 DEFINE_STRING_TABLE_LOOKUP(swap_state
, SwapState
);
1339 static const char* const swap_exec_command_table
[_SWAP_EXEC_COMMAND_MAX
] = {
1340 [SWAP_EXEC_ACTIVATE
] = "ExecActivate",
1341 [SWAP_EXEC_DEACTIVATE
] = "ExecDeactivate",
1344 DEFINE_STRING_TABLE_LOOKUP(swap_exec_command
, SwapExecCommand
);
1346 const UnitVTable swap_vtable
= {
1348 .object_size
= sizeof(Swap
),
1355 .no_instances
= true,
1356 .show_status
= true,
1362 .coldplug
= swap_coldplug
,
1366 .start
= swap_start
,
1371 .serialize
= swap_serialize
,
1372 .deserialize_item
= swap_deserialize_item
,
1374 .active_state
= swap_active_state
,
1375 .sub_state_to_string
= swap_sub_state_to_string
,
1377 .check_gc
= swap_check_gc
,
1379 .sigchld_event
= swap_sigchld_event
,
1380 .timer_event
= swap_timer_event
,
1382 .reset_failed
= swap_reset_failed
,
1384 .bus_interface
= "org.freedesktop.systemd1.Swap",
1385 .bus_message_handler
= bus_swap_message_handler
,
1386 .bus_invalidating_properties
= bus_swap_invalidating_properties
,
1388 .following
= swap_following
,
1389 .following_set
= swap_following_set
,
1391 .enumerate
= swap_enumerate
,
1392 .shutdown
= swap_shutdown