X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fcore%2Fswap.c;h=de3a5d8b10f1755c23a941bd5e3dae654f569398;hp=cf33ab602ef29010bc8a10b39b6eac102196930a;hb=628c89cc68ab96fce2de7ebba5933725d147aecc;hpb=ddb7d6b9420275fb4451185cd63bd0cbb74ad8e5 diff --git a/src/core/swap.c b/src/core/swap.c index cf33ab602..de3a5d8b1 100644 --- a/src/core/swap.c +++ b/src/core/swap.c @@ -20,27 +20,21 @@ ***/ #include -#include #include -#include #include #include -#include #include #include "unit.h" #include "swap.h" -#include "load-fragment.h" -#include "load-dropin.h" #include "unit-name.h" #include "dbus-swap.h" #include "special.h" -#include "bus-errors.h" #include "exit-status.h" -#include "def.h" #include "path-util.h" #include "virt.h" #include "udev-util.h" +#include "fstab-util.h" static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = { [SWAP_DEAD] = UNIT_INACTIVE, @@ -196,6 +190,9 @@ static int swap_add_device_links(Swap *s) { if (!s->what) return 0; + if (!s->from_fragment) + return 0; + if (is_device_path(s->what)) return unit_add_node_link(UNIT(s), s->what, UNIT(s)->manager->running_as == SYSTEMD_SYSTEM); else @@ -206,8 +203,6 @@ static int swap_add_device_links(Swap *s) { } static int swap_add_default_dependencies(Swap *s) { - int r; - assert(s); if (UNIT(s)->manager->running_as != SYSTEMD_SYSTEM) @@ -216,19 +211,7 @@ static int swap_add_default_dependencies(Swap *s) { if (detect_container(NULL) > 0) return 0; - r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true); - if (r < 0) - return r; - - if (!s->from_fragment) - /* The swap unit can either be for an alternative device name, in which - * case we don't need to add the dependency on swap.target because this unit - * is following a different unit which will have this dependency added, - * or it can be derived from /proc/swaps, in which case it was started - * manually, and should not become a dependency of swap.target. */ - return 0; - - return unit_add_two_dependencies_by_name_inverse(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SWAP_TARGET, NULL, true); + return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true); } static int swap_verify(Swap *s) { @@ -244,12 +227,12 @@ static int swap_verify(Swap *s) { b = unit_has_name(UNIT(s), e); if (!b) { - log_error_unit(UNIT(s)->id, "%s: Value of \"What\" and unit name do not match, not loading.", UNIT(s)->id); + log_unit_error(UNIT(s)->id, "%s: Value of \"What\" and unit name do not match, not loading.", UNIT(s)->id); return -EINVAL; } if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) { - log_error_unit(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.", UNIT(s)->id); + log_unit_error(UNIT(s)->id, "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing to load.", UNIT(s)->id); return -EINVAL; } @@ -348,7 +331,7 @@ static int swap_load(Unit *u) { return swap_verify(s); } -static int swap_add_one( +static int swap_setup_unit( Manager *m, const char *what, const char *what_proc_swaps, @@ -373,8 +356,10 @@ static int swap_add_one( if (u && SWAP(u)->from_proc_swaps && - !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps)) + !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps)) { + log_error("Swap %s appeared twice with different device paths %s and %s", e, SWAP(u)->parameters_proc_swaps.what, what_proc_swaps); return -EEXIST; + } if (!u) { delete = true; @@ -389,7 +374,7 @@ static int swap_add_one( SWAP(u)->what = strdup(what); if (!SWAP(u)->what) { - r = log_oom(); + r = -ENOMEM; goto fail; } @@ -417,11 +402,10 @@ static int swap_add_one( p->priority = priority; unit_add_to_dbus_queue(u); - return 0; fail: - log_warning_unit(e, "Failed to load swap unit: %s", strerror(-r)); + log_unit_warning_errno(e, r, "Failed to load swap unit: %m"); if (delete && u) unit_free(u); @@ -429,7 +413,7 @@ fail: return r; } -static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) { +static int swap_process_new(Manager *m, const char *device, int prio, bool set_flags) { _cleanup_udev_device_unref_ struct udev_device *d = NULL; struct udev_list_entry *item = NULL, *first = NULL; const char *dn; @@ -438,7 +422,7 @@ static int swap_process_new_swap(Manager *m, const char *device, int prio, bool assert(m); - r = swap_add_one(m, device, device, prio, set_flags); + r = swap_setup_unit(m, device, device, prio, set_flags); if (r < 0) return r; @@ -454,7 +438,7 @@ static int swap_process_new_swap(Manager *m, const char *device, int prio, bool /* Add the main device node */ dn = udev_device_get_devnode(d); if (dn && !streq(dn, device)) - swap_add_one(m, dn, device, prio, set_flags); + swap_setup_unit(m, dn, device, prio, set_flags); /* Add additional units for all symlinks */ first = udev_device_get_devlinks_list_entry(d); @@ -475,7 +459,7 @@ static int swap_process_new_swap(Manager *m, const char *device, int prio, bool st.st_rdev != udev_device_get_devnum(d)) continue; - swap_add_one(m, p, device, prio, set_flags); + swap_setup_unit(m, p, device, prio, set_flags); } return r; @@ -483,6 +467,7 @@ static int swap_process_new_swap(Manager *m, const char *device, int prio, bool static void swap_set_state(Swap *s, SwapState state) { SwapState old_state; + Swap *other; assert(s); @@ -503,13 +488,22 @@ static void swap_set_state(Swap *s, SwapState state) { } if (state != old_state) - log_debug_unit(UNIT(s)->id, + log_unit_debug(UNIT(s)->id, "%s changed %s -> %s", UNIT(s)->id, swap_state_to_string(old_state), swap_state_to_string(state)); unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true); + + /* If there other units for the same device node have a job + queued it might be worth checking again if it is runnable + now. This is necessary, since swap_start() refuses + operation with EAGAIN if there's already another job for + the same device node queued. */ + LIST_FOREACH_OTHERS(same_devnode, other, s) + if (UNIT(other)->job) + job_add_to_run_queue(UNIT(other)->job); } static int swap_coldplug(Unit *u) { @@ -624,6 +618,7 @@ static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) { exec_params.confirm_spawn = UNIT(s)->manager->confirm_spawn; exec_params.cgroup_supported = UNIT(s)->manager->cgroup_supported; exec_params.cgroup_path = UNIT(s)->cgroup_path; + exec_params.cgroup_delegate = s->cgroup_context.delegate; exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager); exec_params.unit_id = UNIT(s)->id; @@ -646,7 +641,6 @@ static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) { fail: s->timer_event_source = sd_event_source_unref(s->timer_event_source); - return r; } @@ -684,7 +678,8 @@ static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) { r = unit_kill_context( UNIT(s), &s->kill_context, - state != SWAP_ACTIVATING_SIGTERM && state != SWAP_DEACTIVATING_SIGTERM, + (state != SWAP_ACTIVATING_SIGTERM && state != SWAP_DEACTIVATING_SIGTERM) ? + KILL_KILL : KILL_TERMINATE, -1, s->control_pid, false); @@ -707,77 +702,10 @@ static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) { return; fail: - log_warning_unit(UNIT(s)->id, - "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r)); - + log_unit_warning_errno(UNIT(s)->id, r, "%s failed to kill processes: %m", UNIT(s)->id); swap_enter_dead(s, SWAP_FAILURE_RESOURCES); } -static int mount_find_pri(const char *options, int *ret) { - const char *opt; - char *end; - unsigned long r; - - assert(ret); - - if (!options) - return 0; - - opt = mount_test_option(options, "pri"); - if (!opt) - return 0; - - opt += strlen("pri"); - if (*opt != '=') - return -EINVAL; - - errno = 0; - r = strtoul(opt + 1, &end, 10); - if (errno > 0) - return -errno; - - if (end == opt + 1 || (*end != ',' && *end != 0)) - return -EINVAL; - - *ret = (int) r; - return 1; -} - -static int mount_find_discard(const char *options, char **ret) { - const char *opt; - char *ans; - size_t len; - - assert(ret); - - if (!options) - return 0; - - opt = mount_test_option(options, "discard"); - if (!opt) - return 0; - - opt += strlen("discard"); - if (*opt == ',' || *opt == '\0') - ans = strdup("all"); - else { - if (*opt != '=') - return -EINVAL; - - len = strcspn(opt + 1, ","); - if (len == 0) - return -EINVAL; - - ans = strndup(opt + 1, len); - } - - if (!ans) - return -ENOMEM; - - *ret = ans; - return 1; -} - static void swap_enter_activating(Swap *s) { _cleanup_free_ char *discard = NULL; int r, priority = -1; @@ -788,11 +716,12 @@ static void swap_enter_activating(Swap *s) { s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE; if (s->from_fragment) { - mount_find_discard(s->parameters_fragment.options, &discard); + fstab_filter_options(s->parameters_fragment.options, "discard\0", + NULL, &discard, NULL); priority = s->parameters_fragment.priority; if (priority < 0) - mount_find_pri(s->parameters_fragment.options, &priority); + fstab_find_pri(s->parameters_fragment.options, &priority); } r = exec_command_set(s->control_command, "/sbin/swapon", NULL); @@ -814,7 +743,7 @@ static void swap_enter_activating(Swap *s) { if (streq(discard, "all")) discard_arg = "--discard"; else - discard_arg = strappenda("--discard=", discard); + discard_arg = strjoina("--discard=", discard); r = exec_command_append(s->control_command, discard_arg, NULL); if (r < 0) @@ -836,9 +765,7 @@ static void swap_enter_activating(Swap *s) { return; fail: - log_warning_unit(UNIT(s)->id, - "%s failed to run 'swapon' task: %s", - UNIT(s)->id, strerror(-r)); + log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'swapon' task: %m", UNIT(s)->id); swap_enter_dead(s, SWAP_FAILURE_RESOURCES); } @@ -868,14 +795,12 @@ static void swap_enter_deactivating(Swap *s) { return; fail: - log_warning_unit(UNIT(s)->id, - "%s failed to run 'swapoff' task: %s", - UNIT(s)->id, strerror(-r)); + log_unit_warning_errno(UNIT(s)->id, r, "%s failed to run 'swapoff' task: %m", UNIT(s)->id); swap_enter_active(s, SWAP_FAILURE_RESOURCES); } static int swap_start(Unit *u) { - Swap *s = SWAP(u); + Swap *s = SWAP(u), *other; assert(s); @@ -897,9 +822,16 @@ static int swap_start(Unit *u) { if (detect_container(NULL) > 0) return -EPERM; + /* If there's a job for another swap unit for the same node + * running, then let's not dispatch this one for now, and wait + * until that other job has finished. */ + LIST_FOREACH_OTHERS(same_devnode, other, s) + if (UNIT(other)->job && UNIT(other)->job->state == JOB_RUNNING) + return -EAGAIN; + s->result = SWAP_SUCCESS; swap_enter_activating(s); - return 0; + return 1; } static int swap_stop(Unit *u) { @@ -922,7 +854,7 @@ static int swap_stop(Unit *u) { return -EPERM; swap_enter_deactivating(s); - return 0; + return 1; } static int swap_serialize(Unit *u, FILE *f, FDSet *fds) { @@ -955,7 +887,7 @@ static int swap_deserialize_item(Unit *u, const char *key, const char *value, FD state = swap_state_from_string(value); if (state < 0) - log_debug_unit(u->id, "Failed to parse state value %s", value); + log_unit_debug(u->id, "Failed to parse state value %s", value); else s->deserialized_state = state; } else if (streq(key, "result")) { @@ -963,14 +895,14 @@ static int swap_deserialize_item(Unit *u, const char *key, const char *value, FD f = swap_result_from_string(value); if (f < 0) - log_debug_unit(u->id, "Failed to parse result value %s", value); + log_unit_debug(u->id, "Failed to parse result value %s", value); else if (f != SWAP_SUCCESS) s->result = f; } else if (streq(key, "control-pid")) { pid_t pid; if (parse_pid(value, &pid) < 0) - log_debug_unit(u->id, "Failed to parse control-pid value %s", value); + log_unit_debug(u->id, "Failed to parse control-pid value %s", value); else s->control_pid = pid; @@ -979,13 +911,13 @@ static int swap_deserialize_item(Unit *u, const char *key, const char *value, FD id = swap_exec_command_from_string(value); if (id < 0) - log_debug_unit(u->id, "Failed to parse exec-command value %s", value); + log_unit_debug(u->id, "Failed to parse exec-command value %s", value); else { s->control_command_id = id; s->control_command = s->exec_command + id; } } else - log_debug_unit(u->id, "Unknown serialization key '%s'", key); + log_unit_debug(u->id, "Unknown serialization key '%s'", key); return 0; } @@ -1043,8 +975,8 @@ static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) { s->control_command_id = _SWAP_EXEC_COMMAND_INVALID; } - log_full_unit(f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE, - u->id, + log_unit_full(u->id, + f == SWAP_SUCCESS ? LOG_DEBUG : LOG_NOTICE, "%s swap process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status); @@ -1086,38 +1018,38 @@ static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userd case SWAP_ACTIVATING: case SWAP_ACTIVATING_DONE: - log_warning_unit(UNIT(s)->id, "%s activation timed out. Stopping.", UNIT(s)->id); + log_unit_warning(UNIT(s)->id, "%s activation timed out. Stopping.", UNIT(s)->id); swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT); break; case SWAP_DEACTIVATING: - log_warning_unit(UNIT(s)->id, "%s deactivation timed out. Stopping.", UNIT(s)->id); + log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Stopping.", UNIT(s)->id); swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, SWAP_FAILURE_TIMEOUT); break; case SWAP_ACTIVATING_SIGTERM: if (s->kill_context.send_sigkill) { - log_warning_unit(UNIT(s)->id, "%s activation timed out. Killing.", UNIT(s)->id); + log_unit_warning(UNIT(s)->id, "%s activation timed out. Killing.", UNIT(s)->id); swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT); } else { - log_warning_unit(UNIT(s)->id, "%s activation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id); + log_unit_warning(UNIT(s)->id, "%s activation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id); swap_enter_dead(s, SWAP_FAILURE_TIMEOUT); } break; case SWAP_DEACTIVATING_SIGTERM: if (s->kill_context.send_sigkill) { - log_warning_unit(UNIT(s)->id, "%s deactivation timed out. Killing.", UNIT(s)->id); + log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Killing.", UNIT(s)->id); swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_FAILURE_TIMEOUT); } else { - log_warning_unit(UNIT(s)->id, "%s deactivation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id); + log_unit_warning(UNIT(s)->id, "%s deactivation timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id); swap_enter_dead(s, SWAP_FAILURE_TIMEOUT); } break; case SWAP_ACTIVATING_SIGKILL: case SWAP_DEACTIVATING_SIGKILL: - log_warning_unit(UNIT(s)->id, "%s swap process still around after SIGKILL. Ignoring.", UNIT(s)->id); + log_unit_warning(UNIT(s)->id, "%s swap process still around after SIGKILL. Ignoring.", UNIT(s)->id); swap_enter_dead(s, SWAP_FAILURE_TIMEOUT); break; @@ -1153,15 +1085,17 @@ static int swap_load_proc_swaps(Manager *m, bool set_flags) { if (k == EOF) break; - log_warning("Failed to parse /proc/swaps:%u", i); + log_warning("Failed to parse /proc/swaps:%u.", i); continue; } d = cunescape(dev); if (!d) - return -ENOMEM; + return log_oom(); + + device_found_node(m, d, true, DEVICE_FOUND_SWAP, set_flags); - k = swap_process_new_swap(m, d, prio, set_flags); + k = swap_process_new(m, d, prio, set_flags); if (k < 0) r = k; } @@ -1179,7 +1113,7 @@ static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, v r = swap_load_proc_swaps(m, true); if (r < 0) { - log_error("Failed to reread /proc/swaps: %s", strerror(-r)); + log_error_errno(r, "Failed to reread /proc/swaps: %m"); /* Reset flags, just in case, for late calls */ LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_SWAP]) { @@ -1213,6 +1147,9 @@ static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, v break; } + if (swap->what) + device_found_node(m, swap->what, false, DEVICE_FOUND_SWAP, true); + } else if (swap->just_activated) { /* New swap entry */ @@ -1257,11 +1194,7 @@ static Unit *swap_following(Unit *u) { if (s->from_fragment) return NULL; - LIST_FOREACH_AFTER(same_devnode, other, s) - if (other->from_fragment) - return UNIT(other); - - LIST_FOREACH_BEFORE(same_devnode, other, s) + LIST_FOREACH_OTHERS(same_devnode, other, s) if (other->from_fragment) return UNIT(other); @@ -1303,13 +1236,7 @@ static int swap_following_set(Unit *u, Set **_set) { if (!set) return -ENOMEM; - LIST_FOREACH_AFTER(same_devnode, other, s) { - r = set_put(set, other); - if (r < 0) - goto fail; - } - - LIST_FOREACH_BEFORE(same_devnode, other, s) { + LIST_FOREACH_OTHERS(same_devnode, other, s) { r = set_put(set, other); if (r < 0) goto fail; @@ -1370,7 +1297,7 @@ fail: return r; } -int swap_process_new_device(Manager *m, struct udev_device *dev) { +int swap_process_device_new(Manager *m, struct udev_device *dev) { struct udev_list_entry *item = NULL, *first = NULL; _cleanup_free_ char *e = NULL; const char *dn; @@ -1413,7 +1340,7 @@ int swap_process_new_device(Manager *m, struct udev_device *dev) { return r; } -int swap_process_removed_device(Manager *m, struct udev_device *dev) { +int swap_process_device_remove(Manager *m, struct udev_device *dev) { const char *dn; int r = 0; Swap *s; @@ -1462,6 +1389,21 @@ static int swap_get_timeout(Unit *u, uint64_t *timeout) { return 1; } +static bool swap_supported(Manager *m) { + static int supported = -1; + + /* If swap support is not available in the kernel, or we are + * running in a container we don't support swap units, and any + * attempts to starting one should fail immediately. */ + + if (supported < 0) + supported = + access("/proc/swaps", F_OK) >= 0 && + detect_container(NULL) <= 0; + + return supported; +} + static const char* const swap_state_table[_SWAP_STATE_MAX] = { [SWAP_DEAD] = "dead", [SWAP_ACTIVATING] = "activating", @@ -1548,6 +1490,7 @@ const UnitVTable swap_vtable = { .enumerate = swap_enumerate, .shutdown = swap_shutdown, + .supported = swap_supported, .status_message_formats = { .starting_stopping = {