[systemd-commits] 5 commits - src/device.c src/list.h src/manager.c src/manager.h src/mount.c src/swap.c src/swap.h src/systemctl.c src/unit.c TODO
Lennart Poettering
lennart at kemper.freedesktop.org
Mon Oct 11 19:08:12 PDT 2010
TODO | 8
src/device.c | 4
src/list.h | 6
src/manager.c | 3
src/manager.h | 2
src/mount.c | 50 +--
src/swap.c | 814 +++++++++++++++++++++++++++++++++++++++++++++++++-------
src/swap.h | 51 +++
src/systemctl.c | 10
src/unit.c | 1
10 files changed, 805 insertions(+), 144 deletions(-)
New commits:
commit e04aad61bb5eff117e51631727a3ef2807c75d6b
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Oct 12 04:07:43 2010 +0200
swap: major rework, use /sbin/swapon for setting up swaps, fix merging of aliased swap disks
diff --git a/TODO b/TODO
index 4c8090b..4052945 100644
--- a/TODO
+++ b/TODO
@@ -30,8 +30,6 @@
* set_put(), hashmap_put() return values check. i.e. == 0 doesn't free()!
-* fix merging in .swap units
-
* chkconfig/systemd-install glue
* io priority during initialization
@@ -80,8 +78,6 @@
* beefed up tmpwatch that reads tmpfiles.d
-* use /sbin/swapon
-
* enable syslog.socket by default, activating our kmsg bridge
* when processes remain in a service even though the start command failed enter active
diff --git a/src/device.c b/src/device.c
index 2cbb81a..7b73110 100644
--- a/src/device.c
+++ b/src/device.c
@@ -188,10 +188,6 @@ static int device_update_unit(Manager *m, struct udev_device *dev, const char *p
if ((r = device_find_escape_name(m, path, &u)) < 0)
return r;
- /* If a different unit already claimed this name then let's do
- * nothing. This can happen for example when two disks with
- * the same label are plugged in, and which hence try to get
- * conflicting symlinks in /dev/disk/by-label/xxxx */
if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs))
return -EEXIST;
diff --git a/src/list.h b/src/list.h
index e49d953..3cf18f1 100644
--- a/src/list.h
+++ b/src/list.h
@@ -116,4 +116,10 @@
#define LIST_FOREACH_SAFE(name,i,n,head) \
for ((i) = (head); (i) && (((n) = (i)->name##_next), 1); (i) = (n))
+#define LIST_FOREACH_BEFORE(name,i,p) \
+ for ((i) = (p)->name##_prev; (i); (i) = (i)->name##_prev)
+
+#define LIST_FOREACH_AFTER(name,i,p) \
+ for ((i) = (p)->name##_next; (i); (i) = (i)->name##_next)
+
#endif
diff --git a/src/manager.c b/src/manager.c
index 537ff2e..1fe8936 100644
--- a/src/manager.c
+++ b/src/manager.c
@@ -2217,6 +2217,9 @@ int manager_loop(Manager *m) {
if (manager_dispatch_dbus_queue(m) > 0)
continue;
+ if (swap_dispatch_reload(m) > 0)
+ continue;
+
if ((n = epoll_wait(m->epoll_fd, &event, 1, -1)) < 0) {
if (errno == EINTR)
diff --git a/src/manager.h b/src/manager.h
index 5037127..15ffb2c 100644
--- a/src/manager.h
+++ b/src/manager.h
@@ -155,6 +155,8 @@ struct Manager {
/* Data specific to the swap filesystem */
FILE *proc_swaps;
+ Hashmap *swaps_by_proc_swaps;
+ bool request_reload;
/* Data specific to the D-Bus subsystem */
DBusConnection *api_bus, *system_bus;
diff --git a/src/swap.c b/src/swap.c
index 776b707..487b183 100644
--- a/src/swap.c
+++ b/src/swap.c
@@ -26,6 +26,7 @@
#include <sys/epoll.h>
#include <sys/stat.h>
#include <sys/swap.h>
+#include <libudev.h>
#include "unit.h"
#include "swap.h"
@@ -37,17 +38,64 @@
static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
[SWAP_DEAD] = UNIT_INACTIVE,
+ [SWAP_ACTIVATING] = UNIT_ACTIVATING,
[SWAP_ACTIVE] = UNIT_ACTIVE,
+ [SWAP_DEACTIVATING] = UNIT_DEACTIVATING,
+ [SWAP_ACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
+ [SWAP_ACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
+ [SWAP_DEACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
+ [SWAP_DEACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
[SWAP_FAILED] = UNIT_FAILED
};
-static void swap_init(Unit *u) {
+static void swap_unset_proc_swaps(Swap *s) {
+ Swap *first;
+
+ assert(s);
+
+ if (!s->parameters_proc_swaps.what)
+ return;
+
+ /* Remove this unit from the chain of swaps which share the
+ * same kernel swap device. */
+
+ first = hashmap_get(s->meta.manager->swaps_by_proc_swaps, s->parameters_proc_swaps.what);
+ LIST_REMOVE(Swap, same_proc_swaps, first, s);
+
+ if (first)
+ hashmap_remove_and_replace(s->meta.manager->swaps_by_proc_swaps, s->parameters_proc_swaps.what, first->parameters_proc_swaps.what, first);
+ else
+ hashmap_remove(s->meta.manager->swaps_by_proc_swaps, s->parameters_proc_swaps.what);
+
+ free(s->parameters_proc_swaps.what);
+ s->parameters_proc_swaps.what = NULL;
+}
+
+ static void swap_init(Unit *u) {
Swap *s = SWAP(u);
assert(s);
assert(s->meta.load_state == UNIT_STUB);
+ s->timeout_usec = DEFAULT_TIMEOUT_USEC;
+
+ exec_context_init(&s->exec_context);
+
s->parameters_etc_fstab.priority = s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
+
+ s->timer_watch.type = WATCH_INVALID;
+
+ s->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
+}
+
+static void swap_unwatch_control_pid(Swap *s) {
+ assert(s);
+
+ if (s->control_pid <= 0)
+ return;
+
+ unit_unwatch_pid(UNIT(s), s->control_pid);
+ s->control_pid = 0;
}
static void swap_done(Unit *u) {
@@ -55,10 +103,22 @@ static void swap_done(Unit *u) {
assert(s);
+ swap_unset_proc_swaps(s);
+
free(s->what);
+ s->what = NULL;
+
free(s->parameters_etc_fstab.what);
- free(s->parameters_proc_swaps.what);
free(s->parameters_fragment.what);
+ s->parameters_etc_fstab.what = s->parameters_fragment.what = NULL;
+
+ exec_context_done(&s->exec_context);
+ exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
+ s->control_command = NULL;
+
+ swap_unwatch_control_pid(s);
+
+ unit_unwatch_timer(u, &s->timer_watch);
}
int swap_add_one_mount_link(Swap *s, Mount *m) {
@@ -153,9 +213,8 @@ static int swap_add_default_dependencies(Swap *s) {
if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
return r;
- /* Note that by default we don't disable swap devices
- * on shutdown. i.e. there is no umount.target
- * conflicts here. */
+ if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTED_BY, SPECIAL_UMOUNT_TARGET, NULL, true)) < 0)
+ return r;
}
return 0;
@@ -179,6 +238,11 @@ static int swap_verify(Swap *s) {
return -EINVAL;
}
+ if (s->exec_context.pam_name && s->exec_context.kill_mode != KILL_CONTROL_GROUP) {
+ log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", s->meta.id);
+ return -EINVAL;
+ }
+
return 0;
}
@@ -236,59 +300,18 @@ static int swap_load(Unit *u) {
return swap_verify(s);
}
-static int swap_find(Manager *m, const char *what, Unit **_u) {
- Unit *u;
- char *e;
-
- assert(m);
- assert(what);
- assert(_u);
-
- /* /proc/swaps and /etc/fstab might refer to this device by
- * different names (e.g. one by uuid, the other by the kernel
- * name), we hence need to look for all aliases we are aware
- * of for this device */
-
- if (!(e = unit_name_from_path(what, ".device")))
- return -ENOMEM;
-
- u = manager_get_unit(m, e);
- free(e);
-
- if (u) {
- Iterator i;
- const char *d;
-
- SET_FOREACH(d, u->meta.names, i) {
- Unit *k;
-
- if (!(e = unit_name_change_suffix(d, ".swap")))
- return -ENOMEM;
-
- k = manager_get_unit(m, e);
- free(e);
-
- if (k) {
- *_u = k;
- return 0;
- }
- }
- }
-
- *_u = NULL;
- return 0;
-}
-
int swap_add_one(
Manager *m,
const char *what,
+ const char *what_proc_swaps,
int priority,
bool noauto,
bool nofail,
bool handle,
- bool from_proc_swaps) {
+ bool set_flags) {
+
Unit *u = NULL;
- char *e = NULL, *w = NULL;
+ char *e = NULL, *wp = NULL;
bool delete = false;
int r;
SwapParameters *p;
@@ -299,9 +322,13 @@ int swap_add_one(
if (!(e = unit_name_from_path(what, ".swap")))
return -ENOMEM;
- if (!(u = manager_get_unit(m, e)))
- if ((r = swap_find(m, what, &u)) < 0)
- goto fail;
+ u = manager_get_unit(m, e);
+
+ if (what_proc_swaps &&
+ u &&
+ SWAP(u)->from_proc_swaps &&
+ !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps))
+ return -EEXIST;
if (!u) {
delete = true;
@@ -310,36 +337,72 @@ int swap_add_one(
free(e);
return -ENOMEM;
}
+
+ if ((r = unit_add_name(u, e)) < 0)
+ goto fail;
+
+ if (!(SWAP(u)->what = strdup(what))) {
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ unit_add_to_load_queue(u);
} else
delete = false;
- if ((r = unit_add_name(u, e)) < 0)
- goto fail;
-
- if (!(w = strdup(what))) {
- r = -ENOMEM;
- goto fail;
- }
+ if (what_proc_swaps) {
+ Swap *first;
- if (from_proc_swaps) {
p = &SWAP(u)->parameters_proc_swaps;
+
+ if (!p->what) {
+ if (!(wp = strdup(what_proc_swaps))) {
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ if (!m->swaps_by_proc_swaps)
+ if (!(m->swaps_by_proc_swaps = hashmap_new(string_hash_func, string_compare_func))) {
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ free(p->what);
+ p->what = wp;
+
+ first = hashmap_get(m->swaps_by_proc_swaps, wp);
+ LIST_PREPEND(Swap, same_proc_swaps, first, SWAP(u));
+
+ if ((r = hashmap_replace(m->swaps_by_proc_swaps, wp, first)) < 0)
+ goto fail;
+ }
+
+ if (set_flags) {
+ SWAP(u)->is_active = true;
+ SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
+ }
+
SWAP(u)->from_proc_swaps = true;
+
} else {
p = &SWAP(u)->parameters_etc_fstab;
+
+ if (!(wp = strdup(what))) {
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ free(p->what);
+ p->what = wp;
+
SWAP(u)->from_etc_fstab = true;
}
- free(p->what);
- p->what = w;
-
p->priority = priority;
p->noauto = noauto;
p->nofail = nofail;
p->handle = handle;
- if (delete)
- unit_add_to_load_queue(u);
-
unit_add_to_dbus_queue(u);
free(e);
@@ -347,7 +410,9 @@ int swap_add_one(
return 0;
fail:
- free(w);
+ log_warning("Failed to load swap unit: %s", strerror(-r));
+
+ free(wp);
free(e);
if (delete && u)
@@ -356,13 +421,74 @@ fail:
return r;
}
+static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) {
+ struct stat st;
+ int r = 0, k;
+
+ assert(m);
+
+ if (stat(device, &st) >= 0 && S_ISBLK(st.st_mode)) {
+ struct udev_device *d;
+ const char *dn;
+ struct udev_list_entry *item = NULL, *first = NULL;
+
+ /* So this is a proper swap device. Create swap units
+ * for all names this swap device is known under */
+
+ if (!(d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev)))
+ return -ENOMEM;
+
+ if ((dn = udev_device_get_devnode(d)))
+ r = swap_add_one(m, dn, device, prio, false, false, false, set_flags);
+
+ /* Add additional units for all symlinks */
+ first = udev_device_get_devlinks_list_entry(d);
+ udev_list_entry_foreach(item, first) {
+ const char *p;
+
+ /* Don't bother with the /dev/block links */
+ p = udev_list_entry_get_name(item);
+
+ if (path_startswith(p, "/dev/block/"))
+ continue;
+
+ if (stat(p, &st) >= 0)
+ if ((!S_ISBLK(st.st_mode)) || st.st_rdev != udev_device_get_devnum(d))
+ continue;
+
+ if ((k = swap_add_one(m, p, device, prio, false, false, false, set_flags)) < 0)
+ r = k;
+ }
+
+ udev_device_unref(d);
+ }
+
+ if ((k = swap_add_one(m, device, device, prio, false, false, false, set_flags)) < 0)
+ r = k;
+
+ return r;
+}
+
static void swap_set_state(Swap *s, SwapState state) {
SwapState old_state;
+
assert(s);
old_state = s->state;
s->state = state;
+ if (state != SWAP_ACTIVATING &&
+ state != SWAP_ACTIVATING_SIGTERM &&
+ state != SWAP_ACTIVATING_SIGKILL &&
+ state != SWAP_DEACTIVATING &&
+ state != SWAP_DEACTIVATING_SIGTERM &&
+ state != SWAP_DEACTIVATING_SIGKILL) {
+ unit_unwatch_timer(UNIT(s), &s->timer_watch);
+ swap_unwatch_control_pid(s);
+ s->control_command = NULL;
+ s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
+ }
+
if (state != old_state)
log_debug("%s changed %s -> %s",
s->meta.id,
@@ -375,6 +501,7 @@ static void swap_set_state(Swap *s, SwapState state) {
static int swap_coldplug(Unit *u) {
Swap *s = SWAP(u);
SwapState new_state = SWAP_DEAD;
+ int r;
assert(s);
assert(s->state == SWAP_DEAD);
@@ -384,8 +511,27 @@ static int swap_coldplug(Unit *u) {
else if (s->from_proc_swaps)
new_state = SWAP_ACTIVE;
- if (new_state != s->state)
+ if (new_state != s->state) {
+
+ if (new_state == SWAP_ACTIVATING ||
+ new_state == SWAP_ACTIVATING_SIGTERM ||
+ new_state == SWAP_ACTIVATING_SIGKILL ||
+ new_state == SWAP_DEACTIVATING ||
+ new_state == SWAP_DEACTIVATING_SIGTERM ||
+ new_state == SWAP_DEACTIVATING_SIGKILL) {
+
+ if (s->control_pid <= 0)
+ return -EBADMSG;
+
+ if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
+ return r;
+
+ if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
+ return r;
+ }
+
swap_set_state(s, new_state);
+ }
return 0;
}
@@ -423,50 +569,261 @@ static void swap_dump(Unit *u, FILE *f, const char *prefix) {
prefix, yes_no(s->from_etc_fstab),
prefix, yes_no(s->from_proc_swaps),
prefix, yes_no(s->from_fragment));
+
+ if (s->control_pid > 0)
+ fprintf(f,
+ "%sControl PID: %lu\n",
+ prefix, (unsigned long) s->control_pid);
+
+ exec_context_dump(&s->exec_context, f, prefix);
+}
+
+static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
+ pid_t pid;
+ int r;
+
+ assert(s);
+ assert(c);
+ assert(_pid);
+
+ if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
+ goto fail;
+
+ if ((r = exec_spawn(c,
+ NULL,
+ &s->exec_context,
+ NULL, 0,
+ s->meta.manager->environment,
+ true,
+ true,
+ true,
+ s->meta.manager->confirm_spawn,
+ s->meta.cgroup_bondings,
+ &pid)) < 0)
+ goto fail;
+
+ if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
+ /* FIXME: we need to do something here */
+ goto fail;
+
+ *_pid = pid;
+
+ return 0;
+
+fail:
+ unit_unwatch_timer(UNIT(s), &s->timer_watch);
+
+ return r;
}
static void swap_enter_dead(Swap *s, bool success) {
assert(s);
- swap_set_state(s, success ? SWAP_DEAD : SWAP_FAILED);
+ if (!success)
+ s->failure = true;
+
+ swap_set_state(s, s->failure ? SWAP_FAILED : SWAP_DEAD);
}
-static int swap_start(Unit *u) {
- Swap *s = SWAP(u);
- int priority = -1;
+static void swap_enter_active(Swap *s, bool success) {
+ assert(s);
+
+ if (!success)
+ s->failure = true;
+
+ swap_set_state(s, SWAP_ACTIVE);
+}
+
+static void swap_enter_signal(Swap *s, SwapState state, bool success) {
int r;
+ Set *pid_set = NULL;
+ bool wait_for_exit = false;
assert(s);
- assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
+
+ if (!success)
+ s->failure = true;
+
+ if (s->exec_context.kill_mode != KILL_NONE) {
+ int sig = (state == SWAP_ACTIVATING_SIGTERM ||
+ 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)
+
+ log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
+ else
+ wait_for_exit = true;
+ }
+
+ if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
+
+ if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
+ r = -ENOMEM;
+ goto fail;
+ }
+
+ /* Exclude the control pid from being killed via the cgroup */
+ if (s->control_pid > 0)
+ 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 != -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);
+ }
+ }
+
+ if (wait_for_exit) {
+ if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
+ goto fail;
+
+ swap_set_state(s, state);
+ } else
+ swap_enter_dead(s, true);
+
+ return;
+
+fail:
+ log_warning("%s failed to kill processes: %s", s->meta.id, strerror(-r));
+
+ swap_enter_dead(s, false);
+
+ if (pid_set)
+ set_free(pid_set);
+}
+
+static void swap_enter_activating(Swap *s) {
+ int r, priority;
+
+ assert(s);
+
+ s->control_command_id = SWAP_EXEC_ACTIVATE;
+ s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
if (s->from_fragment)
priority = s->parameters_fragment.priority;
else if (s->from_etc_fstab)
priority = s->parameters_etc_fstab.priority;
+ else
+ priority = -1;
- r = swapon(s->what, (priority << SWAP_FLAG_PRIO_SHIFT) & SWAP_FLAG_PRIO_MASK);
+ if (priority >= 0) {
+ char p[LINE_MAX];
- if (r < 0 && errno != EBUSY) {
- r = -errno;
- swap_enter_dead(s, false);
- return r;
- }
+ snprintf(p, sizeof(p), "%i", priority);
+ char_array_0(p);
- swap_set_state(s, SWAP_ACTIVE);
+ 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 (r < 0)
+ goto fail;
+
+ swap_unwatch_control_pid(s);
+
+ if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
+ goto fail;
+
+ swap_set_state(s, SWAP_ACTIVATING);
+
+ return;
+
+fail:
+ log_warning("%s failed to run 'swapon' task: %s", s->meta.id, strerror(-r));
+ swap_enter_dead(s, false);
+}
+
+static void swap_enter_deactivating(Swap *s, bool success) {
+ int r;
+
+ assert(s);
+
+ if (!success)
+ s->failure = true;
+
+ s->control_command_id = SWAP_EXEC_DEACTIVATE;
+ s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
+
+ if ((r = exec_command_set(
+ s->control_command,
+ "/sbin/swapoff",
+ s->what,
+ NULL)) < 0)
+ goto fail;
+
+ swap_unwatch_control_pid(s);
+
+ if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
+ goto fail;
+
+ swap_set_state(s, SWAP_DEACTIVATING);
+
+ return;
+
+fail:
+ log_warning("%s failed to run 'swapoff' task: %s", s->meta.id, strerror(-r));
+ swap_enter_active(s, false);
+}
+
+static int swap_start(Unit *u) {
+ Swap *s = SWAP(u);
+
+ assert(s);
+
+ /* We cannot fulfill this request right now, try again later
+ * please! */
+
+ if (s->state == SWAP_DEACTIVATING ||
+ s->state == SWAP_DEACTIVATING_SIGTERM ||
+ s->state == SWAP_DEACTIVATING_SIGKILL ||
+ s->state == SWAP_ACTIVATING_SIGTERM ||
+ s->state == SWAP_ACTIVATING_SIGKILL)
+ return -EAGAIN;
+
+ if (s->state == SWAP_ACTIVATING)
+ return 0;
+
+ assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
+
+ s->failure = false;
+ swap_enter_activating(s);
return 0;
}
static int swap_stop(Unit *u) {
Swap *s = SWAP(u);
- int r;
assert(s);
- assert(s->state == SWAP_ACTIVE);
+ if (s->state == SWAP_DEACTIVATING ||
+ s->state == SWAP_DEACTIVATING_SIGTERM ||
+ s->state == SWAP_DEACTIVATING_SIGKILL ||
+ s->state == SWAP_ACTIVATING_SIGTERM ||
+ s->state == SWAP_ACTIVATING_SIGKILL)
+ return 0;
- r = swapoff(s->what);
- swap_enter_dead(s, r >= 0 || errno == EINVAL);
+ assert(s->state == SWAP_ACTIVATING ||
+ s->state == SWAP_ACTIVE);
+ swap_enter_deactivating(s, true);
return 0;
}
@@ -478,6 +835,13 @@ static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
assert(fds);
unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
+ unit_serialize_item(u, f, "failure", yes_no(s->failure));
+
+ if (s->control_pid > 0)
+ unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) 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));
return 0;
}
@@ -495,6 +859,32 @@ static int swap_deserialize_item(Unit *u, const char *key, const char *value, FD
log_debug("Failed to parse state value %s", value);
else
s->deserialized_state = state;
+ } else if (streq(key, "failure")) {
+ int b;
+
+ if ((b = parse_boolean(value)) < 0)
+ log_debug("Failed to parse failure value %s", value);
+ else
+ s->failure = b || s->failure;
+
+ } else if (streq(key, "control-pid")) {
+ pid_t pid;
+
+ if (parse_pid(value, &pid) < 0)
+ log_debug("Failed to parse control-pid value %s", value);
+ else
+ s->control_pid = pid;
+
+ } else if (streq(key, "control-command")) {
+ SwapExecCommand id;
+
+ if ((id = swap_exec_command_from_string(value)) < 0)
+ log_debug("Failed to parse exec-command value %s", value);
+ else {
+ s->control_command_id = id;
+ s->control_command = s->exec_command + id;
+ }
+
} else
log_debug("Unknown serialization key '%s'", key);
@@ -521,28 +911,132 @@ static bool swap_check_gc(Unit *u) {
return s->from_etc_fstab || s->from_proc_swaps;
}
-static int swap_load_proc_swaps(Manager *m) {
+static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
+ Swap *s = SWAP(u);
+ bool success;
+
+ assert(s);
+ assert(pid >= 0);
+
+ if (pid != s->control_pid)
+ return;
+
+ s->control_pid = 0;
+
+ success = is_clean_exit(code, status);
+ s->failure = s->failure || !success;
+
+ if (s->control_command) {
+ exec_status_exit(&s->control_command->exec_status, pid, code, status, s->exec_context.utmp_id);
+ s->control_command = NULL;
+ s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
+ }
+
+ log_full(success ? LOG_DEBUG : LOG_NOTICE,
+ "%s swap process exited, code=%s status=%i", u->meta.id, sigchld_code_to_string(code), status);
+
+ switch (s->state) {
+
+ case SWAP_ACTIVATING:
+ case SWAP_ACTIVATING_SIGTERM:
+ case SWAP_ACTIVATING_SIGKILL:
+
+ if (success)
+ swap_enter_active(s, true);
+ else
+ swap_enter_dead(s, false);
+ break;
+
+ case SWAP_DEACTIVATING:
+ case SWAP_DEACTIVATING_SIGKILL:
+ case SWAP_DEACTIVATING_SIGTERM:
+
+ if (success)
+ swap_enter_dead(s, true);
+ else
+ swap_enter_dead(s, false);
+ break;
+
+ default:
+ assert_not_reached("Uh, control process died at wrong time.");
+ }
+
+ /* Notify clients about changed exit status */
+ unit_add_to_dbus_queue(u);
+
+ /* Request a reload of /proc/swaps, so that following units
+ * can follow our state change */
+ u->meta.manager->request_reload = true;
+}
+
+static void swap_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
+ Swap *s = SWAP(u);
+
+ assert(s);
+ assert(elapsed == 1);
+ assert(w == &s->timer_watch);
+
+ switch (s->state) {
+
+ case SWAP_ACTIVATING:
+ log_warning("%s activation timed out. Stopping.", u->meta.id);
+ swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, false);
+ break;
+
+ case SWAP_DEACTIVATING:
+ log_warning("%s deactivation timed out. Stopping.", u->meta.id);
+ swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, false);
+ break;
+
+ case SWAP_ACTIVATING_SIGTERM:
+ log_warning("%s activation timed out. Killing.", u->meta.id);
+ swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, false);
+ break;
+
+ case SWAP_DEACTIVATING_SIGTERM:
+ log_warning("%s deactivation timed out. Killing.", u->meta.id);
+ swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, false);
+ break;
+
+ case SWAP_ACTIVATING_SIGKILL:
+ case SWAP_DEACTIVATING_SIGKILL:
+ log_warning("%s swap process still around after SIGKILL. Ignoring.", u->meta.id);
+ swap_enter_dead(s, false);
+ break;
+
+ default:
+ assert_not_reached("Timeout at wrong time.");
+ }
+}
+
+static int swap_load_proc_swaps(Manager *m, bool set_flags) {
+ unsigned i;
+ int r = 0;
+
+ assert(m);
+
rewind(m->proc_swaps);
(void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
- for (;;) {
+ for (i = 1;; i++) {
char *dev = NULL, *d;
int prio = 0, k;
if ((k = fscanf(m->proc_swaps,
- "%ms " /* device/file */
- "%*s " /* type of swap */
- "%*s " /* swap size */
- "%*s " /* used */
+ "%ms " /* device/file */
+ "%*s " /* type of swap */
+ "%*s " /* swap size */
+ "%*s " /* used */
"%i\n", /* priority */
&dev, &prio)) != 2) {
if (k == EOF)
break;
+ log_warning("Failed to parse /proc/swaps:%u.", i);
free(dev);
- return -EBADMSG;
+ continue;
}
d = cunescape(dev);
@@ -551,14 +1045,114 @@ static int swap_load_proc_swaps(Manager *m) {
if (!d)
return -ENOMEM;
- k = swap_add_one(m, d, prio, false, false, false, true);
+ k = swap_process_new_swap(m, d, prio, set_flags);
free(d);
if (k < 0)
- return k;
+ r = k;
}
- return 0;
+ return r;
+}
+
+int swap_dispatch_reload(Manager *m) {
+ Meta *meta;
+ int r;
+
+ assert(m);
+
+ if (_likely_(!m->request_reload))
+ return 0;
+
+ m->request_reload = false;
+
+ 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 */
+ LIST_FOREACH(units_per_type, meta, m->units_per_type[UNIT_SWAP]) {
+ Swap *swap = (Swap*) meta;
+
+ swap->is_active = swap->just_activated = false;
+ }
+
+ return 0;
+ }
+
+ manager_dispatch_load_queue(m);
+
+ LIST_FOREACH(units_per_type, meta, m->units_per_type[UNIT_SWAP]) {
+ Swap *swap = (Swap*) meta;
+
+ if (!swap->is_active) {
+ /* This has just been deactivated */
+
+ swap->from_proc_swaps = false;
+ swap_unset_proc_swaps(swap);
+
+ switch (swap->state) {
+
+ case SWAP_ACTIVE:
+ swap_enter_dead(swap, true);
+ break;
+
+ default:
+ swap_set_state(swap, swap->state);
+ break;
+ }
+
+ } else if (swap->just_activated) {
+
+ /* New swap entry */
+
+ switch (swap->state) {
+
+ case SWAP_DEAD:
+ case SWAP_FAILED:
+ swap_enter_active(swap, true);
+ break;
+
+ default:
+ /* Nothing really changed, but let's
+ * issue an notification call
+ * nonetheless, in case somebody is
+ * waiting for this. */
+ swap_set_state(swap, swap->state);
+ break;
+ }
+ }
+
+ /* Reset the flags for later calls */
+ swap->is_active = swap->just_activated = false;
+ }
+
+ return 1;
+}
+
+static Unit *swap_following(Unit *u) {
+ Swap *s = SWAP(u);
+ Swap *other, *first = NULL;
+
+ assert(s);
+
+ if (streq_ptr(s->what, s->parameters_proc_swaps.what))
+ return NULL;
+
+ /* Make everybody follow the unit that's named after the swap
+ * device in the kernel */
+
+ LIST_FOREACH_AFTER(same_proc_swaps, other, s)
+ if (streq_ptr(other->what, other->parameters_proc_swaps.what))
+ return UNIT(other);
+
+ LIST_FOREACH_BEFORE(same_proc_swaps, other, s) {
+ if (streq_ptr(other->what, other->parameters_proc_swaps.what))
+ return UNIT(other);
+
+ first = other;
+ }
+
+ return UNIT(first);
}
static void swap_shutdown(Manager *m) {
@@ -568,6 +1162,9 @@ static void swap_shutdown(Manager *m) {
fclose(m->proc_swaps);
m->proc_swaps = NULL;
}
+
+ hashmap_free(m->swaps_by_proc_swaps);
+ m->swaps_by_proc_swaps = NULL;
}
static int swap_enumerate(Manager *m) {
@@ -578,7 +1175,9 @@ static int swap_enumerate(Manager *m) {
if (!(m->proc_swaps = fopen("/proc/swaps", "re")))
return -errno;
- if ((r = swap_load_proc_swaps(m)) < 0)
+ /* We rely on mount.c to load /etc/fstab for us */
+
+ if ((r = swap_load_proc_swaps(m, false)) < 0)
swap_shutdown(m);
return r;
@@ -591,19 +1190,35 @@ static void swap_reset_failed(Unit *u) {
if (s->state == SWAP_FAILED)
swap_set_state(s, SWAP_DEAD);
+
+ s->failure = false;
}
static const char* const swap_state_table[_SWAP_STATE_MAX] = {
[SWAP_DEAD] = "dead",
+ [SWAP_ACTIVATING] = "activating",
[SWAP_ACTIVE] = "active",
+ [SWAP_DEACTIVATING] = "deactivating",
+ [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
+ [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
+ [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
+ [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
[SWAP_FAILED] = "failed"
};
DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
+static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
+ [SWAP_EXEC_ACTIVATE] = "ExecActivate",
+ [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
+};
+
+DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
+
const UnitVTable swap_vtable = {
.suffix = ".swap",
+ .no_alias = true,
.no_instances = true,
.no_isolate = true,
.show_status = true,
@@ -627,11 +1242,16 @@ const UnitVTable swap_vtable = {
.check_gc = swap_check_gc,
+ .sigchld_event = swap_sigchld_event,
+ .timer_event = swap_timer_event,
+
+ .reset_failed = swap_reset_failed,
+
.bus_interface = "org.freedesktop.systemd1.Swap",
.bus_message_handler = bus_swap_message_handler,
.bus_invalidating_properties = bus_swap_invalidating_properties,
- .reset_failed = swap_reset_failed,
+ .following = swap_following,
.enumerate = swap_enumerate,
.shutdown = swap_shutdown
diff --git a/src/swap.h b/src/swap.h
index 9c249ca..8a60416 100644
--- a/src/swap.h
+++ b/src/swap.h
@@ -29,12 +29,25 @@ typedef struct Swap Swap;
typedef enum SwapState {
SWAP_DEAD,
+ SWAP_ACTIVATING,
SWAP_ACTIVE,
+ SWAP_DEACTIVATING,
+ SWAP_ACTIVATING_SIGTERM,
+ SWAP_ACTIVATING_SIGKILL,
+ SWAP_DEACTIVATING_SIGTERM,
+ SWAP_DEACTIVATING_SIGKILL,
SWAP_FAILED,
_SWAP_STATE_MAX,
_SWAP_STATE_INVALID = -1
} SwapState;
+typedef enum SwapExecCommand {
+ SWAP_EXEC_ACTIVATE,
+ SWAP_EXEC_DEACTIVATE,
+ _SWAP_EXEC_COMMAND_MAX,
+ _SWAP_EXEC_COMMAND_INVALID = -1
+} SwapExecCommand;
+
typedef struct SwapParameters {
char *what;
int priority;
@@ -46,27 +59,55 @@ typedef struct SwapParameters {
struct Swap {
Meta meta;
+ char *what;
+
SwapParameters parameters_etc_fstab;
SwapParameters parameters_proc_swaps;
SwapParameters parameters_fragment;
- char *what;
-
- SwapState state, deserialized_state;
-
bool from_etc_fstab:1;
bool from_proc_swaps:1;
bool from_fragment:1;
+
+ bool failure:1;
+
+ /* Used while looking for swaps that vanished or got added
+ * from/to /proc/swaps */
+ bool is_active:1;
+ bool just_activated:1;
+
+ usec_t timeout_usec;
+
+ ExecCommand exec_command[_SWAP_EXEC_COMMAND_MAX];
+ ExecContext exec_context;
+
+ SwapState state, deserialized_state;
+
+ ExecCommand* control_command;
+ SwapExecCommand control_command_id;
+ pid_t control_pid;
+
+ Watch timer_watch;
+
+ /* In order to be able to distuingish dependencies on
+ different device nodes we might end up creating multiple
+ devices for the same swap. We chain them up here. */
+
+ LIST_FIELDS(struct Swap, same_proc_swaps);
};
extern const UnitVTable swap_vtable;
-int swap_add_one(Manager *m, const char *what, int prio, bool no_auto, bool no_fail, bool handle, bool from_proc_swap);
+int swap_add_one(Manager *m, const char *what, const char *what_proc_swaps, int prio, bool no_auto, bool no_fail, bool handle, bool set_flags);
int swap_add_one_mount_link(Swap *s, Mount *m);
+int swap_dispatch_reload(Manager *m);
+
const char* swap_state_to_string(SwapState i);
SwapState swap_state_from_string(const char *s);
+const char* swap_exec_command_to_string(SwapExecCommand i);
+SwapExecCommand swap_exec_command_from_string(const char *s);
#endif
diff --git a/src/unit.c b/src/unit.c
index a45a1f7..9fc9be5 100644
--- a/src/unit.c
+++ b/src/unit.c
@@ -376,7 +376,6 @@ void unit_free(Unit *u) {
set_free_free(u->meta.names);
free(u->meta.instance);
-
free(u);
}
commit 60b912f6b1c6bce67ec4a979594981f6a3b13987
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Oct 12 04:06:21 2010 +0200
mount: minor cleanups
diff --git a/src/mount.c b/src/mount.c
index 3320bf1..28ed8c3 100644
--- a/src/mount.c
+++ b/src/mount.c
@@ -423,8 +423,6 @@ static int mount_load(Unit *u) {
/* This is a new unit? Then let's add in some extras */
if (u->meta.load_state == UNIT_LOADED) {
- const char *what = NULL;
-
if (m->meta.fragment_path)
m->from_fragment = true;
@@ -438,13 +436,6 @@ static int mount_load(Unit *u) {
if ((r = unit_set_description(u, m->where)) < 0)
return r;
- if (m->from_fragment && m->parameters_fragment.what)
- what = m->parameters_fragment.what;
- else if (m->from_etc_fstab && m->parameters_etc_fstab.what)
- what = m->parameters_etc_fstab.what;
- else if (m->from_proc_self_mountinfo && m->parameters_proc_self_mountinfo.what)
- what = m->parameters_proc_self_mountinfo.what;
-
if ((r = mount_add_device_links(m)) < 0)
return r;
@@ -874,10 +865,8 @@ static void mount_enter_remounting(Mount *m, bool success) {
else
r = -ENOENT;
- if (r < 0) {
- r = -ENOMEM;
+ if (r < 0)
goto fail;
- }
mount_unwatch_control_pid(m);
@@ -902,13 +891,13 @@ static int mount_start(Unit *u) {
* please! */
if (m->state == MOUNT_UNMOUNTING ||
m->state == MOUNT_UNMOUNTING_SIGTERM ||
- m->state == MOUNT_UNMOUNTING_SIGKILL)
+ m->state == MOUNT_UNMOUNTING_SIGKILL ||
+ m->state == MOUNT_MOUNTING_SIGTERM ||
+ m->state == MOUNT_MOUNTING_SIGKILL)
return -EAGAIN;
/* Already on it! */
- if (m->state == MOUNT_MOUNTING ||
- m->state == MOUNT_MOUNTING_SIGTERM ||
- m->state == MOUNT_MOUNTING_SIGKILL)
+ if (m->state == MOUNT_MOUNTING)
return 0;
assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
@@ -926,14 +915,14 @@ static int mount_stop(Unit *u) {
/* Already on it */
if (m->state == MOUNT_UNMOUNTING ||
m->state == MOUNT_UNMOUNTING_SIGKILL ||
- m->state == MOUNT_UNMOUNTING_SIGTERM)
+ m->state == MOUNT_UNMOUNTING_SIGTERM ||
+ m->state == MOUNT_MOUNTING_SIGTERM ||
+ m->state == MOUNT_MOUNTING_SIGKILL)
return 0;
assert(m->state == MOUNT_MOUNTING ||
m->state == MOUNT_MOUNTING_DONE ||
m->state == MOUNT_MOUNTED ||
- m->state == MOUNT_MOUNTING_SIGTERM ||
- m->state == MOUNT_MOUNTING_SIGKILL ||
m->state == MOUNT_REMOUNTING ||
m->state == MOUNT_REMOUNTING_SIGTERM ||
m->state == MOUNT_REMOUNTING_SIGKILL);
@@ -1347,7 +1336,7 @@ static int mount_find_pri(char *options) {
static int mount_load_etc_fstab(Manager *m) {
FILE *f;
- int r;
+ int r = 0;
struct mntent* me;
assert(m);
@@ -1358,6 +1347,7 @@ static int mount_load_etc_fstab(Manager *m) {
while ((me = getmntent(f))) {
char *where, *what;
+ int k;
if (!(what = fstab_node_to_udev_node(me->mnt_fsname))) {
r = -ENOMEM;
@@ -1380,26 +1370,26 @@ static int mount_load_etc_fstab(Manager *m) {
int pri;
if ((pri = mount_find_pri(me->mnt_opts)) < 0)
- r = pri;
+ k = pri;
else
- r = swap_add_one(m,
+ k = swap_add_one(m,
what,
+ NULL,
pri,
!!mount_test_option(me->mnt_opts, MNTOPT_NOAUTO),
!!mount_test_option(me->mnt_opts, "nofail"),
!!mount_test_option(me->mnt_opts, "comment=systemd.swapon"),
false);
} else
- r = mount_add_one(m, what, where, me->mnt_opts, me->mnt_type, false, false);
+ k = mount_add_one(m, what, where, me->mnt_opts, me->mnt_type, false, false);
free(what);
free(where);
if (r < 0)
- goto finish;
+ r = k;
}
- r = 0;
finish:
endmntent(f);
@@ -1407,7 +1397,7 @@ finish:
}
static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
- int r;
+ int r = 0;
unsigned i;
char *device, *path, *options, *options2, *fstype, *d, *p, *o;
@@ -1457,8 +1447,8 @@ static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
goto finish;
}
- if ((r = mount_add_one(m, d, p, o, fstype, true, set_flags)) < 0)
- goto finish;
+ if ((k = mount_add_one(m, d, p, o, fstype, true, set_flags)) < 0)
+ r = k;
clean_up:
free(device);
@@ -1471,8 +1461,6 @@ clean_up:
free(o);
}
- r = 0;
-
finish:
free(device);
free(path);
@@ -1576,7 +1564,7 @@ void mount_fd_event(Manager *m, int events) {
} else if (mount->just_mounted || mount->just_changed) {
- /* New or changed entrymount */
+ /* New or changed mount entry */
switch (mount->state) {
commit 538da63d539ddbddf73c5163a51a8da579aa7708
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Oct 12 04:05:29 2010 +0200
systemctl: drop [] around date in status output
diff --git a/src/systemctl.c b/src/systemctl.c
index 51f5bba..a4a7655 100644
--- a/src/systemctl.c
+++ b/src/systemctl.c
@@ -1679,9 +1679,9 @@ static void print_status_info(UnitStatusInfo *i) {
s2 = format_timestamp(since2, sizeof(since2), timestamp);
if (s1)
- printf(" since [%s; %s]\n", s2, s1);
+ printf(" since %s; %s\n", s2, s1);
else if (s2)
- printf(" since [%s]\n", s2);
+ printf(" since %s\n", s2);
else
printf("\n");
commit 4a9e2fffdff2aade58d0d6052670b0eb0848af64
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Oct 12 04:04:54 2010 +0200
systemctl: show whether we follow somebody in 'status' output
diff --git a/src/systemctl.c b/src/systemctl.c
index c8384ff..51f5bba 100644
--- a/src/systemctl.c
+++ b/src/systemctl.c
@@ -1568,6 +1568,7 @@ typedef struct UnitStatusInfo {
const char *sub_state;
const char *description;
+ const char *following;
const char *path;
const char *default_control_group;
@@ -1629,6 +1630,9 @@ static void print_status_info(UnitStatusInfo *i) {
printf("\n");
+ if (i->following)
+ printf("\t Follow: unit currently follows state of %s\n", i->following);
+
if (streq_ptr(i->load_state, "failed") ||
streq_ptr(i->load_state, "banned")) {
on = ansi_highlight(true);
@@ -1841,6 +1845,8 @@ static int status_property(const char *name, DBusMessageIter *iter, UnitStatusIn
i->where = s;
else if (streq(name, "What"))
i->what = s;
+ else if (streq(name, "Following"))
+ i->following = s;
}
break;
commit 06ae4bfeb0b3aea82ca39acfdc4391850d57a2d8
Author: Lennart Poettering <lennart at poettering.net>
Date: Tue Oct 12 04:04:22 2010 +0200
update fixme
diff --git a/TODO b/TODO
index 3828a11..4c8090b 100644
--- a/TODO
+++ b/TODO
@@ -90,6 +90,10 @@
External:
+* patch kernel to add /proc/swaps change notifications
+
+* patch kernel for xattr support in /dev, /proc/, /sys and /sys/fs/cgroup.
+
* place /etc/inittab with explaining blurb.
* pam_securetty should honour console=
More information about the systemd-commits
mailing list