X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fcore%2Fswap.c;h=ef90d0efde1d2e19f1ebced13d579b1fad9a2ab1;hb=cdc8982030271785d650af410230397bbb5a4be9;hp=adcf78b7175985d3187ea9658105056b847d0fe2;hpb=290837072b136624f1f3d941c7274e4b1b275021;p=elogind.git diff --git a/src/core/swap.c b/src/core/swap.c index adcf78b71..ef90d0efd 100644 --- a/src/core/swap.c +++ b/src/core/swap.c @@ -59,29 +59,55 @@ static int swap_dispatch_timer(sd_event_source *source, usec_t usec, void *userd static int swap_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata); static void swap_unset_proc_swaps(Swap *s) { + assert(s); + + if (!s->from_proc_swaps) + return; + + free(s->parameters_proc_swaps.what); + s->parameters_proc_swaps.what = NULL; + + s->from_proc_swaps = false; +} + +static int swap_set_devnode(Swap *s, const char *devnode) { Hashmap *swaps; Swap *first; + int r; assert(s); - if (!s->parameters_proc_swaps.what) - return; + r = hashmap_ensure_allocated(&UNIT(s)->manager->swaps_by_devnode, &string_hash_ops); + if (r < 0) + return r; - /* Remove this unit from the chain of swaps which share the - * same kernel swap device. */ - swaps = UNIT(s)->manager->swaps_by_proc_swaps; - first = hashmap_get(swaps, s->parameters_proc_swaps.what); - LIST_REMOVE(same_proc_swaps, first, s); + swaps = UNIT(s)->manager->swaps_by_devnode; - if (first) - hashmap_remove_and_replace(swaps, s->parameters_proc_swaps.what, first->parameters_proc_swaps.what, first); - else - hashmap_remove(swaps, s->parameters_proc_swaps.what); + if (s->devnode) { + first = hashmap_get(swaps, s->devnode); - free(s->parameters_proc_swaps.what); - s->parameters_proc_swaps.what = NULL; + LIST_REMOVE(same_devnode, first, s); + if (first) + hashmap_replace(swaps, first->devnode, first); + else + hashmap_remove(swaps, s->devnode); - s->from_proc_swaps = false; + free(s->devnode); + s->devnode = NULL; + } + + if (devnode) { + s->devnode = strdup(devnode); + if (!s->devnode) + return -ENOMEM; + + first = hashmap_get(swaps, s->devnode); + LIST_PREPEND(same_devnode, first, s); + + return hashmap_replace(swaps, first->devnode, first); + } + + return 0; } static void swap_init(Unit *u) { @@ -92,11 +118,8 @@ static void swap_init(Unit *u) { s->timeout_usec = u->manager->default_timeout_start_usec; - exec_context_init(&s->exec_context); s->exec_context.std_output = u->manager->default_std_output; s->exec_context.std_error = u->manager->default_std_error; - kill_context_init(&s->kill_context); - cgroup_context_init(&s->cgroup_context); s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1; @@ -121,6 +144,7 @@ static void swap_done(Unit *u) { assert(s); swap_unset_proc_swaps(s); + swap_set_devnode(s, NULL); free(s->what); s->what = NULL; @@ -128,12 +152,13 @@ static void swap_done(Unit *u) { free(s->parameters_fragment.what); s->parameters_fragment.what = NULL; - exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager)); + free(s->parameters_fragment.discard); + s->parameters_fragment.discard = NULL; + + s->exec_runtime = exec_runtime_unref(s->exec_runtime); exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX); s->control_command = NULL; - cgroup_context_done(&s->cgroup_context); - swap_unwatch_control_pid(s); s->timer_event_source = sd_event_source_unref(s->timer_event_source); @@ -157,7 +182,12 @@ static int swap_arm_timer(Swap *s) { return sd_event_source_set_enabled(s->timer_event_source, SD_EVENT_ONESHOT); } - return sd_event_add_monotonic(UNIT(s)->manager->event, now(CLOCK_MONOTONIC) + s->timeout_usec, 0, swap_dispatch_timer, s, &s->timer_event_source); + return sd_event_add_time( + UNIT(s)->manager->event, + &s->timer_event_source, + CLOCK_MONOTONIC, + now(CLOCK_MONOTONIC) + s->timeout_usec, 0, + swap_dispatch_timer, s); } static int swap_add_device_links(Swap *s) { @@ -242,6 +272,27 @@ static int swap_verify(Swap *s) { return 0; } +static int swap_load_devnode(Swap *s) { + _cleanup_udev_device_unref_ struct udev_device *d = NULL; + struct stat st; + const char *p; + + assert(s); + + if (stat(s->what, &st) < 0 || !S_ISBLK(st.st_mode)) + return 0; + + d = udev_device_new_from_devnum(UNIT(s)->manager->udev, 'b', st.st_rdev); + if (!d) + return 0; + + p = udev_device_get_devnode(d); + if (!p) + return 0; + + return swap_set_devnode(s, p); +} + static int swap_load(Unit *u) { int r; Swap *s = SWAP(u); @@ -255,9 +306,6 @@ static int swap_load(Unit *u) { return r; if (u->load_state == UNIT_LOADED) { - r = unit_add_exec_dependencies(u, &s->exec_context); - if (r < 0) - return r; if (UNIT(s)->fragment_path) s->from_fragment = true; @@ -290,7 +338,19 @@ static int swap_load(Unit *u) { if (r < 0) return r; - r = unit_add_default_slice(u); + r = swap_load_devnode(s); + if (r < 0) + return r; + + r = unit_patch_contexts(u); + if (r < 0) + return r; + + r = unit_add_exec_dependencies(u, &s->exec_context); + if (r < 0) + return r; + + r = unit_add_default_slice(u, &s->cgroup_context); if (r < 0) return r; @@ -299,10 +359,6 @@ static int swap_load(Unit *u) { if (r < 0) return r; } - - r = unit_exec_context_defaults(u, &s->exec_context); - if (r < 0) - return r; } return swap_verify(s); @@ -322,7 +378,6 @@ static int swap_add_one( Unit *u = NULL; int r; SwapParameters *p; - Swap *first; assert(m); assert(what); @@ -368,17 +423,6 @@ static int swap_add_one( r = -ENOMEM; goto fail; } - - r = hashmap_ensure_allocated(&m->swaps_by_proc_swaps, string_hash_func, string_compare_func); - if (r < 0) - goto fail; - - first = hashmap_get(m->swaps_by_proc_swaps, p->what); - LIST_PREPEND(same_proc_swaps, first, SWAP(u)); - - r = hashmap_replace(m->swaps_by_proc_swaps, p->what, first); - if (r < 0) - goto fail; } if (set_flags) { @@ -554,19 +598,24 @@ static void swap_dump(Unit *u, FILE *f, const char *prefix) { prefix, yes_no(s->from_proc_swaps), prefix, yes_no(s->from_fragment)); + if (s->devnode) + fprintf(f, "%sDevice Node: %s\n", prefix, s->devnode); + if (p) fprintf(f, "%sPriority: %i\n" "%sNoAuto: %s\n" - "%sNoFail: %s\n", + "%sNoFail: %s\n" + "%sDiscard: %s\n", prefix, p->priority, prefix, yes_no(p->noauto), - prefix, yes_no(p->nofail)); + prefix, yes_no(p->nofail), + prefix, p->discard ?: "none"); if (s->control_pid > 0) fprintf(f, - "%sControl PID: %lu\n", - prefix, (unsigned long) s->control_pid); + "%sControl PID: "PID_FMT"\n", + prefix, s->control_pid); exec_context_dump(&s->exec_context, f, prefix); kill_context_dump(&s->kill_context, f, prefix); @@ -575,6 +624,11 @@ static void swap_dump(Unit *u, FILE *f, const char *prefix) { static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) { pid_t pid; int r; + ExecParameters exec_params = { + .apply_permissions = true, + .apply_chroot = true, + .apply_tty_stdin = true, + }; assert(s); assert(c); @@ -582,23 +636,25 @@ static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) { unit_realize_cgroup(UNIT(s)); + r = unit_setup_exec_runtime(UNIT(s)); + if (r < 0) + goto fail; + r = swap_arm_timer(s); if (r < 0) goto fail; + exec_params.environment = UNIT(s)->manager->environment; + 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.runtime_prefix = manager_get_runtime_prefix(UNIT(s)->manager); + exec_params.unit_id = UNIT(s)->id; + r = exec_spawn(c, - NULL, &s->exec_context, - NULL, 0, - UNIT(s)->manager->environment, - true, - true, - true, - UNIT(s)->manager->confirm_spawn, - UNIT(s)->manager->cgroup_supported, - UNIT(s)->cgroup_path, - UNIT(s)->id, - NULL, + &exec_params, + s->exec_runtime, &pid); if (r < 0) goto fail; @@ -624,7 +680,11 @@ static void swap_enter_dead(Swap *s, SwapResult f) { if (f != SWAP_SUCCESS) s->result = f; - exec_context_tmp_dirs_done(&s->exec_context); + exec_runtime_destroy(s->exec_runtime); + s->exec_runtime = exec_runtime_unref(s->exec_runtime); + + exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager)); + swap_set_state(s, s->result != SWAP_SUCCESS ? SWAP_FAILED : SWAP_DEAD); } @@ -661,7 +721,11 @@ static void swap_enter_signal(Swap *s, SwapState state, SwapResult f) { goto fail; swap_set_state(s, state); - } else + } else if (state == SWAP_ACTIVATING_SIGTERM) + swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, SWAP_SUCCESS); + else if (state == SWAP_DEACTIVATING_SIGTERM) + swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, SWAP_SUCCESS); + else swap_enter_dead(s, SWAP_SUCCESS); return; @@ -675,36 +739,46 @@ fail: static void swap_enter_activating(Swap *s) { int r, priority; + char *discard; assert(s); s->control_command_id = SWAP_EXEC_ACTIVATE; s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE; - if (s->from_fragment) + if (s->from_fragment) { priority = s->parameters_fragment.priority; - else + discard = s->parameters_fragment.discard; + } else { priority = -1; + discard = NULL; + } + + r = exec_command_set(s->control_command, "/sbin/swapon", NULL); + if (r < 0) + goto fail; if (priority >= 0) { char p[DECIMAL_STR_MAX(int)]; sprintf(p, "%i", priority); + r = exec_command_append(s->control_command, "-p", p, NULL); + if (r < 0) + goto fail; + } - r = exec_command_set( - s->control_command, - "/sbin/swapon", - "-p", - p, - s->what, - NULL); - } else - r = exec_command_set( - s->control_command, - "/sbin/swapon", - s->what, - NULL); + if (discard && !streq(discard, "none")) { + const char *discard_arg = "--discard"; + + if (!streq(discard, "all")) + discard_arg = strappenda("--discard=", discard); + + r = exec_command_append(s->control_command, discard_arg, NULL); + if (r < 0) + goto fail; + } + r = exec_command_append(s->control_command, s->what, NULL); if (r < 0) goto fail; @@ -819,13 +893,11 @@ static int swap_serialize(Unit *u, FILE *f, FDSet *fds) { unit_serialize_item(u, f, "result", swap_result_to_string(s->result)); if (s->control_pid > 0) - unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid); + unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid); if (s->control_command_id >= 0) unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id)); - exec_context_serialize(&s->exec_context, UNIT(s), f); - return 0; } @@ -869,22 +941,6 @@ static int swap_deserialize_item(Unit *u, const char *key, const char *value, FD s->control_command_id = id; s->control_command = s->exec_command + id; } - } else if (streq(key, "tmp-dir")) { - char *t; - - t = strdup(value); - if (!t) - return log_oom(); - - s->exec_context.tmp_dir = t; - } else if (streq(key, "var-tmp-dir")) { - char *t; - - t = strdup(value); - if (!t) - return log_oom(); - - s->exec_context.var_tmp_dir = t; } else log_debug_unit(u->id, "Unknown serialization key '%s'", key); @@ -966,10 +1022,7 @@ static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) { case SWAP_DEACTIVATING_SIGKILL: case SWAP_DEACTIVATING_SIGTERM: - if (f == SWAP_SUCCESS) - swap_enter_dead(s, f); - else - swap_enter_dead(s, f); + swap_enter_dead(s, f); break; default: @@ -1155,23 +1208,38 @@ static Unit *swap_following(Unit *u) { assert(s); - if (streq_ptr(s->what, s->parameters_proc_swaps.what)) + /* If the user configured the swap through /etc/fstab or + * a device unit, follow that. */ + + if (s->from_fragment) return NULL; - /* Make everybody follow the unit that's named after the swap - * device in the kernel */ + LIST_FOREACH_AFTER(same_devnode, other, s) + if (other->from_fragment) + return UNIT(other); + + LIST_FOREACH_BEFORE(same_devnode, other, s) + if (other->from_fragment) + return UNIT(other); + + /* Otherwise make everybody follow the unit that's named after + * the swap device in the kernel */ + + if (streq_ptr(s->what, s->devnode)) + return NULL; - LIST_FOREACH_AFTER(same_proc_swaps, other, s) - if (streq_ptr(other->what, other->parameters_proc_swaps.what)) + LIST_FOREACH_AFTER(same_devnode, other, s) + if (streq_ptr(other->what, other->devnode)) return UNIT(other); - LIST_FOREACH_BEFORE(same_proc_swaps, other, s) { - if (streq_ptr(other->what, other->parameters_proc_swaps.what)) + LIST_FOREACH_BEFORE(same_devnode, other, s) { + if (streq_ptr(other->what, other->devnode)) return UNIT(other); first = other; } + /* Fall back to the first on the list */ return UNIT(first); } @@ -1183,22 +1251,22 @@ static int swap_following_set(Unit *u, Set **_set) { assert(s); assert(_set); - if (LIST_JUST_US(same_proc_swaps, s)) { + if (LIST_JUST_US(same_devnode, s)) { *_set = NULL; return 0; } - set = set_new(NULL, NULL); + set = set_new(NULL); if (!set) return -ENOMEM; - LIST_FOREACH_AFTER(same_proc_swaps, other, s) { + LIST_FOREACH_AFTER(same_devnode, other, s) { r = set_put(set, other); if (r < 0) goto fail; } - LIST_FOREACH_BEFORE(same_proc_swaps, other, s) { + LIST_FOREACH_BEFORE(same_devnode, other, s) { r = set_put(set, other); if (r < 0) goto fail; @@ -1222,12 +1290,13 @@ static void swap_shutdown(Manager *m) { m->proc_swaps = NULL; } - hashmap_free(m->swaps_by_proc_swaps); - m->swaps_by_proc_swaps = NULL; + hashmap_free(m->swaps_by_devnode); + m->swaps_by_devnode = NULL; } static int swap_enumerate(Manager *m) { int r; + assert(m); if (!m->proc_swaps) { @@ -1235,7 +1304,7 @@ static int swap_enumerate(Manager *m) { if (!m->proc_swaps) return errno == ENOENT ? 0 : -errno; - r = sd_event_add_io(m->event, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m, &m->swap_event_source); + r = sd_event_add_io(m->event, &m->swap_event_source, fileno(m->proc_swaps), EPOLLPRI, swap_dispatch_io, m); if (r < 0) goto fail; @@ -1258,6 +1327,69 @@ fail: return r; } +int swap_process_new_device(Manager *m, struct udev_device *dev) { + struct udev_list_entry *item = NULL, *first = NULL; + _cleanup_free_ char *e = NULL; + const char *dn; + Swap *s; + int r = 0; + + assert(m); + assert(dev); + + dn = udev_device_get_devnode(dev); + if (!dn) + return 0; + + e = unit_name_from_path(dn, ".swap"); + if (!e) + return -ENOMEM; + + s = hashmap_get(m->units, e); + if (s) + r = swap_set_devnode(s, dn); + + first = udev_device_get_devlinks_list_entry(dev); + udev_list_entry_foreach(item, first) { + _cleanup_free_ char *n = NULL; + + n = unit_name_from_path(udev_list_entry_get_name(item), ".swap"); + if (!n) + return -ENOMEM; + + s = hashmap_get(m->units, n); + if (s) { + int q; + + q = swap_set_devnode(s, dn); + if (q < 0) + r = q; + } + } + + return r; +} + +int swap_process_removed_device(Manager *m, struct udev_device *dev) { + const char *dn; + int r = 0; + Swap *s; + + dn = udev_device_get_devnode(dev); + if (!dn) + return 0; + + while ((s = hashmap_get(m->swaps_by_devnode, dn))) { + int q; + + q = swap_set_devnode(s, NULL); + if (q < 0) + r = q; + } + + return r; +} + static void swap_reset_failed(Unit *u) { Swap *s = SWAP(u); @@ -1273,6 +1405,20 @@ static int swap_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) { return unit_kill_common(u, who, signo, -1, SWAP(u)->control_pid, error); } +static int swap_get_timeout(Unit *u, uint64_t *timeout) { + Swap *s = SWAP(u); + int r; + + if (!s->timer_event_source) + return 0; + + r = sd_event_source_get_time(s->timer_event_source, timeout); + if (r < 0) + return r; + + return 1; +} + static const char* const swap_state_table[_SWAP_STATE_MAX] = { [SWAP_DEAD] = "dead", [SWAP_ACTIVATING] = "activating", @@ -1311,6 +1457,7 @@ const UnitVTable swap_vtable = { .exec_context_offset = offsetof(Swap, exec_context), .cgroup_context_offset = offsetof(Swap, cgroup_context), .kill_context_offset = offsetof(Swap, kill_context), + .exec_runtime_offset = offsetof(Swap, exec_runtime), .sections = "Unit\0" @@ -1334,6 +1481,8 @@ const UnitVTable swap_vtable = { .kill = swap_kill, + .get_timeout = swap_get_timeout, + .serialize = swap_serialize, .deserialize_item = swap_deserialize_item, @@ -1348,7 +1497,6 @@ const UnitVTable swap_vtable = { .bus_interface = "org.freedesktop.systemd1.Swap", .bus_vtable = bus_swap_vtable, - .bus_changing_properties = bus_swap_changing_properties, .bus_set_property = bus_swap_set_property, .bus_commit_properties = bus_swap_commit_properties,