X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fswap.c;h=c32f60810c0f17444d12861e7080c4e10ed16bac;hp=487b18350a21cfcf4276eacfe008efbec3ffc254;hb=67370238b55df4126e505007d46deaff8bb55a36;hpb=e04aad61bb5eff117e51631727a3ef2807c75d6b diff --git a/src/swap.c b/src/swap.c index 487b18350..c32f60810 100644 --- a/src/swap.c +++ b/src/swap.c @@ -35,6 +35,9 @@ #include "unit-name.h" #include "dbus-swap.h" #include "special.h" +#include "bus-errors.h" +#include "exit-status.h" +#include "def.h" static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = { [SWAP_DEAD] = UNIT_INACTIVE, @@ -80,6 +83,7 @@ static void swap_unset_proc_swaps(Swap *s) { s->timeout_usec = DEFAULT_TIMEOUT_USEC; exec_context_init(&s->exec_context); + s->exec_context.std_output = EXEC_OUTPUT_KMSG; s->parameters_etc_fstab.priority = s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1; @@ -174,8 +178,9 @@ static int swap_add_target_links(Swap *s) { return r; if (!p->noauto && + !p->nofail && (p->handle || s->meta.manager->swap_auto) && - !s->from_fragment && + s->from_etc_fstab && s->meta.manager->running_as == MANAGER_SYSTEM) if ((r = unit_add_dependency(tu, UNIT_WANTS, UNIT(s), true)) < 0) return r; @@ -198,9 +203,15 @@ static int swap_add_device_links(Swap *s) { else return 0; - return unit_add_node_link(UNIT(s), s->what, - !p->noauto && p->nofail && - s->meta.manager->running_as == MANAGER_SYSTEM); + if (is_device_path(s->what)) + return unit_add_node_link(UNIT(s), s->what, + !p->noauto && p->nofail && + s->meta.manager->running_as == MANAGER_SYSTEM); + else + /* File based swap devices need to be ordered after + * remount-rootfs.service, since they might need a + * writable file system. */ + return unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_REMOUNT_ROOTFS_SERVICE, NULL, true); } static int swap_add_default_dependencies(Swap *s) { @@ -210,10 +221,7 @@ static int swap_add_default_dependencies(Swap *s) { if (s->meta.manager->running_as == MANAGER_SYSTEM) { - if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0) - return r; - - if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTED_BY, SPECIAL_UMOUNT_TARGET, NULL, true)) < 0) + if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true)) < 0) return r; } @@ -258,6 +266,8 @@ static int swap_load(Unit *u) { return r; if (u->meta.load_state == UNIT_LOADED) { + if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0) + return r; if (s->meta.fragment_path) s->from_fragment = true; @@ -282,7 +292,6 @@ static int swap_load(Unit *u) { if ((r = unit_set_description(u, s->what)) < 0) return r; - if ((r = swap_add_device_links(s)) < 0) return r; @@ -292,6 +301,9 @@ static int swap_load(Unit *u) { if ((r = swap_add_target_links(s)) < 0) return r; + if ((r = unit_add_default_cgroups(u)) < 0) + return r; + if (s->meta.default_dependencies) if ((r = swap_add_default_dependencies(s)) < 0) return r; @@ -495,7 +507,7 @@ static void swap_set_state(Swap *s, SwapState state) { swap_state_to_string(old_state), swap_state_to_string(state)); - unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state]); + unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true); } static int swap_coldplug(Unit *u) { @@ -649,9 +661,7 @@ static void swap_enter_signal(Swap *s, SwapState state, bool success) { state == SWAP_DEACTIVATING_SIGTERM) ? s->exec_context.kill_signal : SIGKILL; if (s->control_pid > 0) { - if (kill(s->exec_context.kill_mode == KILL_PROCESS_GROUP ? - -s->control_pid : - s->control_pid, sig) < 0 && errno != ESRCH) + if (kill_and_sigcont(s->control_pid, sig) < 0 && errno != ESRCH) log_warning("Failed to kill control process %li: %m", (long) s->control_pid); else @@ -670,13 +680,14 @@ static void swap_enter_signal(Swap *s, SwapState state, bool success) { if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) goto fail; - if ((r = cgroup_bonding_kill_list(s->meta.cgroup_bondings, sig, pid_set)) < 0) { + if ((r = cgroup_bonding_kill_list(s->meta.cgroup_bondings, sig, true, pid_set)) < 0) { if (r != -EAGAIN && r != -ESRCH && r != -ENOENT) log_warning("Failed to kill control group: %s", strerror(-r)); } else if (r > 0) wait_for_exit = true; set_free(pid_set); + pid_set = NULL; } } @@ -989,13 +1000,23 @@ static void swap_timer_event(Unit *u, uint64_t elapsed, Watch *w) { break; case SWAP_ACTIVATING_SIGTERM: - log_warning("%s activation timed out. Killing.", u->meta.id); - swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, false); + if (s->exec_context.send_sigkill) { + log_warning("%s activation timed out. Killing.", u->meta.id); + swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, false); + } else { + log_warning("%s activation timed out. Skipping SIGKILL. Ignoring.", u->meta.id); + swap_enter_dead(s, false); + } break; case SWAP_DEACTIVATING_SIGTERM: - log_warning("%s deactivation timed out. Killing.", u->meta.id); - swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, false); + if (s->exec_context.send_sigkill) { + log_warning("%s deactivation timed out. Killing.", u->meta.id); + swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, false); + } else { + log_warning("%s deactivation timed out. Skipping SIGKILL. Ignoring.", u->meta.id); + swap_enter_dead(s, false); + } break; case SWAP_ACTIVATING_SIGKILL: @@ -1056,17 +1077,24 @@ static int swap_load_proc_swaps(Manager *m, bool set_flags) { } int swap_dispatch_reload(Manager *m) { - Meta *meta; - int r; - - assert(m); + /* This function should go as soon as the kernel properly notifies us */ if (_likely_(!m->request_reload)) return 0; m->request_reload = false; - if ((r == swap_load_proc_swaps(m, true)) < 0) { + return swap_fd_event(m, EPOLLPRI); +} + +int swap_fd_event(Manager *m, int events) { + Meta *meta; + int r; + + assert(m); + assert(events & EPOLLPRI); + + if ((r = swap_load_proc_swaps(m, true)) < 0) { log_error("Failed to reread /proc/swaps: %s", strerror(-r)); /* Reset flags, just in case, for late calls */ @@ -1155,6 +1183,39 @@ static Unit *swap_following(Unit *u) { return UNIT(first); } +static int swap_following_set(Unit *u, Set **_set) { + Swap *s = SWAP(u); + Swap *other; + Set *set; + int r; + + assert(s); + assert(_set); + + if (LIST_JUST_US(same_proc_swaps, s)) { + *_set = NULL; + return 0; + } + + if (!(set = set_new(NULL, NULL))) + return -ENOMEM; + + LIST_FOREACH_AFTER(same_proc_swaps, other, s) + if ((r = set_put(set, other)) < 0) + goto fail; + + LIST_FOREACH_BEFORE(same_proc_swaps, other, s) + if ((r = set_put(set, other)) < 0) + goto fail; + + *_set = set; + return 1; + +fail: + set_free(set); + return r; +} + static void swap_shutdown(Manager *m) { assert(m); @@ -1169,12 +1230,24 @@ static void swap_shutdown(Manager *m) { static int swap_enumerate(Manager *m) { int r; + struct epoll_event ev; assert(m); - if (!m->proc_swaps) + if (!m->proc_swaps) { if (!(m->proc_swaps = fopen("/proc/swaps", "re"))) return -errno; + m->swap_watch.type = WATCH_SWAP; + m->swap_watch.fd = fileno(m->proc_swaps); + + zero(ev); + ev.events = EPOLLPRI; + ev.data.ptr = &m->swap_watch; + + if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->swap_watch.fd, &ev) < 0) + return -errno; + } + /* We rely on mount.c to load /etc/fstab for us */ if ((r = swap_load_proc_swaps(m, false)) < 0) @@ -1194,6 +1267,52 @@ static void swap_reset_failed(Unit *u) { s->failure = false; } +static int swap_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) { + Swap *s = SWAP(u); + int r = 0; + Set *pid_set = NULL; + + assert(s); + + if (who == KILL_MAIN) { + dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Swap units have no main processes"); + return -EINVAL; + } + + if (s->control_pid <= 0 && who == KILL_CONTROL) { + dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill"); + return -ENOENT; + } + + if (s->control_pid > 0) + if (kill(s->control_pid, signo) < 0) + r = -errno; + + if (mode == KILL_CONTROL_GROUP) { + int q; + + if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) + return -ENOMEM; + + /* Exclude the control pid from being killed via the cgroup */ + if (s->control_pid > 0) + if ((q = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0) { + r = q; + goto finish; + } + + if ((q = cgroup_bonding_kill_list(s->meta.cgroup_bondings, signo, false, pid_set)) < 0) + if (r != -EAGAIN && r != -ESRCH && r != -ENOENT) + r = q; + } + +finish: + if (pid_set) + set_free(pid_set); + + return r; +} + static const char* const swap_state_table[_SWAP_STATE_MAX] = { [SWAP_DEAD] = "dead", [SWAP_ACTIVATING] = "activating", @@ -1234,6 +1353,8 @@ const UnitVTable swap_vtable = { .start = swap_start, .stop = swap_stop, + .kill = swap_kill, + .serialize = swap_serialize, .deserialize_item = swap_deserialize_item, @@ -1252,6 +1373,7 @@ const UnitVTable swap_vtable = { .bus_invalidating_properties = bus_swap_invalidating_properties, .following = swap_following, + .following_set = swap_following_set, .enumerate = swap_enumerate, .shutdown = swap_shutdown