remount-fs: do not remount filesystem to match fstab if something different is mounted

As reported in ostreedev/ostree#3193, when the system
has mounted a different file system on "/" than what is configured in
/etc/fstab, we still try to execute "mount -o remount /", and that fails because
the filesystem that is actually mounted doesn't know about the options relevant
for the filesystem listed in /etc/fstab. I don't think it's useful to try to
apply options from /etc/fstab if the file system type or device are different.
In fact, it could be dangerous or destructive. If the user mounted something
different than what the fstab specifies, no matter by what means, we should leave
that mount point alone.

If the filesystem is (potentially) multi-device, we only require the file
system type to match.

Author: keszybz

src/remount-fs/remount-fs.c

@@ -14,6 +14,7 @@
 #include "main-func.h"
 #include "mount-setup.h"
 #include "mount-util.h"
+#include "mountpoint-util.h"
 #include "path-util.h"
 #include "process-util.h"
 #include "signal-util.h"
@@ -69,11 +70,87 @@ static int do_remount(const char *path, bool force_rw, Hashmap **pids) {
         return track_pid(pids, path, pid);
 }
 
+static int device_node_uuid(const char *path, sd_id128_t *ret_uuid) {
+        _cleanup_(sd_device_unrefp) sd_device *device = NULL;
+        int r;
+
+        r = sd_device_new_from_devname(&device, path);
+        if (r < 0)
+                return log_warning_errno(r, "Failed to create device from %s: %m", path);
+
+        const char *uuid;
+        r = sd_device_get_property_value(device, "ID_FS_UUID", &uuid);
+        if (r < 0)
+                return log_warning_errno(r, "Failed to get filesystem UUID for device %s: %m", path);
+
+        r = sd_id128_from_string(uuid, ret_uuid);
+        if (r < 0)
+                return log_warning_errno(r, "Failed to parse ID_FS_UUID '%s' for device %s: %m",
+                                         uuid, path);
+        return 0;
+}
+
+static int mount_point_matches(const struct mntent *me) {
+        _cleanup_free_ char *what = NULL, *where = NULL, *type = NULL;
+        int r;
+
+        r = path_get_mount_info(ASSERT_PTR(me)->mnt_dir, &what, &where, &type, /* options= */ NULL);
+        if (r < 0)
+                return log_warning_errno(r, "Failed to acquire information about mount point %s: %m", me->mnt_dir);
+        if (!path_equal(me->mnt_dir, where)) { /* We got the containing mount point */
+                log_info("Mount point \"%s\" is not mounted.", me->mnt_dir);
+                return false;
+        }
+
+        if (!streq(type, me->mnt_type) && !streq(me->mnt_type, "auto")) {
+                log_info("File system mounted at \"%s\" doesn't match fstab (type %s vs. %s), ignoring.",
+                         me->mnt_dir, type, me->mnt_type);
+                return false;
+        }
+
+        if (!fstype_is_blockdev_backed(type)) {
+                log_debug("File system mounted at \"%s\" matches fstab.", me->mnt_dir);
+                return true; /* Nothing more to check, the "device" is not important. */
+        }
+
+        /* Figure out if the two paths point at the same device node */
+        _cleanup_free_ char *node = fstab_node_to_udev_node(me->mnt_fsname);
+        if (!node)
+                return log_oom();
+
+        r = path_equal_or_inode_same_full(what, node, AT_NO_AUTOMOUNT);
+        if (r < 0)
+                return log_warning_errno(r, "Failed to determine if %s and %s for mount point \"%s\" are same: %m",
+                                         what, node, me->mnt_dir);
+        if (r == 0) {
+                /* Try to figure out if the file system identifier matches…
+                 * This way we cover multi-device file systems like btrfs or bcachefs. */
+                sd_id128_t uuid_a, uuid_b;
+
+                r = device_node_uuid(what, &uuid_a);
+                if (r < 0)
+                        return r;
+
+                r = device_node_uuid(node, &uuid_b);
+                if (r < 0)
+                        return r;
+
+                r = sd_id128_equal(uuid_a, uuid_b);
+        }
+
+        if (r > 0)
+                log_debug("File system mounted at \"%s\" matches fstab.", me->mnt_dir);
+        else
+                log_info("File system mounted at \"%s\" doesn't match fstab (%s vs. %s), ignoring.",
+                         me->mnt_dir, what, me->mnt_fsname);
+        return r;
+}
+
 static int remount_by_fstab(Hashmap **ret_pids) {
         _cleanup_hashmap_free_ Hashmap *pids = NULL;
         _cleanup_endmntent_ FILE *f = NULL;
         bool has_root = false;
-        struct mntent* me;
+        struct mntent *me;
         int r;
 
         assert(ret_pids);
@@ -95,6 +172,10 @@ static int remount_by_fstab(Hashmap **ret_pids) {
                     !PATH_IN_SET(me->mnt_dir, "/", "/usr"))
                         continue;
 
+                r = mount_point_matches(me);
+                if (r <= 0)
+                        continue;
+
                 if (path_equal(me->mnt_dir, "/"))
                         has_root = true;