From ff6c50a1451e0e8fdca72039a0a00ebb0a20ba6c Mon Sep 17 00:00:00 2001
From: Lennart Poettering <lennart@poettering.net>
Date: Fri, 24 Apr 2015 12:29:05 +0200
Subject: [PATCH] device: rework how we enter tentative state
This reworks how we enter tentative state and does so only when a device
was previously not announced via udev. The previous check actually just
checked whether a new state bit was set, which is not correct.
Also, to be able to reliably maintain the tentative state across daemon
reloads, we need to serialize and deserialize it.
Cherry-picked from: f62009410
Resolves: #1283579
---
src/core/device.c | 79 ++++++++++++++++++++++++++++++++++++++++-------
src/core/device.h | 2 +-
2 files changed, 69 insertions(+), 12 deletions(-)
diff --git a/src/core/device.c b/src/core/device.c
index cc4ebd2c87..8a6855dfc3 100644
--- a/src/core/device.c
+++ b/src/core/device.c
@@ -151,14 +151,47 @@ static int device_coldplug(Unit *u, Hashmap *deferred_work) {
if (d->found & DEVICE_FOUND_UDEV)
/* If udev says the device is around, it's around */
device_set_state(d, DEVICE_PLUGGED);
- else if (d->found != DEVICE_NOT_FOUND)
+ else if (d->found != DEVICE_NOT_FOUND && d->deserialized_state != DEVICE_PLUGGED)
/* If a device is found in /proc/self/mountinfo or
- * /proc/swaps, it's "tentatively" around. */
+ * /proc/swaps, and was not yet announced via udev,
+ * it's "tentatively" around. */
device_set_state(d, DEVICE_TENTATIVE);
return 0;
}
+static int device_serialize(Unit *u, FILE *f, FDSet *fds) {
+ Device *d = DEVICE(u);
+
+ assert(u);
+ assert(f);
+ assert(fds);
+
+ unit_serialize_item(u, f, "state", device_state_to_string(d->state));
+}
+
+static int device_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
+ Device *d = DEVICE(u);
+
+ assert(u);
+ assert(key);
+ assert(value);
+ assert(fds);
+
+ if (streq(key, "state")) {
+ DeviceState state;
+
+ state = device_state_from_string(value);
+ if (state < 0)
+ log_unit_debug(u->id, "Failed to parse state value %s", value);
+ else
+ d->deserialized_state = state;
+ } else
+ log_unit_debug(u->id, "Unknown serialization key '%s'", key);
+
+ return 0;
+}
+
static void device_dump(Unit *u, FILE *f, const char *prefix) {
Device *d = DEVICE(u);
@@ -408,7 +441,7 @@ static int device_process_new(Manager *m, struct udev_device *dev) {
}
static void device_update_found_one(Device *d, bool add, DeviceFound found, bool now) {
- DeviceFound n;
+ DeviceFound n, previous;
assert(d);
@@ -416,16 +449,27 @@ static void device_update_found_one(Device *d, bool add, DeviceFound found, bool
if (n == d->found)
return;
+ previous = d->found;
d->found = n;
- if (now) {
- if (d->found & DEVICE_FOUND_UDEV)
- device_set_state(d, DEVICE_PLUGGED);
- else if (add && d->found != DEVICE_NOT_FOUND)
- device_set_state(d, DEVICE_TENTATIVE);
- else
- device_set_state(d, DEVICE_DEAD);
- }
+ if (!now)
+ return;
+
+ if (d->found & DEVICE_FOUND_UDEV)
+ /* When the device is known to udev we consider it
+ * plugged. */
+ device_set_state(d, DEVICE_PLUGGED);
+ else if (d->found != DEVICE_NOT_FOUND && (previous & DEVICE_FOUND_UDEV) == 0)
+ /* If the device has not been seen by udev yet, but is
+ * now referenced by the kernel, then we assume the
+ * kernel knows it now, and udev might soon too. */
+ device_set_state(d, DEVICE_TENTATIVE);
+ else
+ /* If nobody sees the device, or if the device was
+ * previously seen by udev and now is only referenced
+ * from the kernel, then we consider the device is
+ * gone, the kernel just hasn't noticed it yet. */
+ device_set_state(d, DEVICE_DEAD);
}
static int device_update_found_by_sysfs(Manager *m, const char *sysfs, bool add, DeviceFound found, bool now) {
@@ -735,6 +779,16 @@ int device_found_node(Manager *m, const char *node, bool add, DeviceFound found,
if (!path_startswith(node, "/dev"))
return 0;
+ /* We make an extra check here, if the device node
+ * actually exists. If it's missing, then this is an
+ * indication that device was unplugged but is still
+ * referenced in /proc/swaps or
+ * /proc/self/mountinfo. Note that this check doesn't
+ * really cover all cases where a device might be gone
+ * away, since drives that can have a medium inserted
+ * will still have a device node even when the medium
+ * is not there... */
+
if (stat(node, &st) < 0) {
if (errno == ENOENT)
return 0;
@@ -788,6 +842,9 @@ const UnitVTable device_vtable = {
.coldplug = device_coldplug,
+ .serialize = device_serialize,
+ .deserialize_item = device_deserialize_item,
+
.dump = device_dump,
.active_state = device_active_state,
diff --git a/src/core/device.h b/src/core/device.h
index 0609b20fdb..6724ab21ea 100644
--- a/src/core/device.h
+++ b/src/core/device.h
@@ -53,7 +53,7 @@ struct Device {
devices for the same sysfs path. We chain them up here. */
LIST_FIELDS(struct Device, same_sysfs);
- DeviceState state;
+ DeviceState state, deserialized_state;
};
extern const UnitVTable device_vtable;