Fix creating dm devices when there are mounted partitions on the disk.

The idea is to use LDM protective partition block devices for dm calls
instead of the whole disk block device.
This allows scenarios like booting Linux from LDM, when a separate
protective partition is created exactly over the rootfs LDM partition,
which allows mounting it directly, i.e. without ldmtool. Originally,
it then prevents using ldmtool after such direct mount. This change
fixes that.

Author: constrictor

src/ldm.c

@@ -2729,6 +2729,121 @@ _dm_remove(const gchar * const name, uint32_t udev_cookie, GError ** const err)
     return r;
 }
 
+static int _find_partition(GString* target_params,
+    const gchar* dev_name, guint64 abs_part_start, guint64 part_size)
+{
+    char *dev_name_copy = strdup(dev_name); // basename might modify its arg
+    if (!dev_name_copy) {
+        return -1;
+    }
+    char *base_name = basename(dev_name_copy);
+    if (!base_name || strlen(base_name) == 0) {
+        free(dev_name_copy);
+        return -1;
+    }
+
+    char sysfs_path[PATH_MAX];
+    snprintf(sysfs_path, sizeof(sysfs_path), "/sys/block/%s", base_name);
+
+    DIR *dir = opendir(sysfs_path);
+    if (!dir) {
+        free(dev_name_copy);
+        return -1;
+    }
+
+    struct dirent *entry;
+    int found = 0;
+    while ((entry = readdir(dir)) != NULL && !found) {
+        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
+            continue;
+        }
+
+        char partition_file_path[PATH_MAX];
+        if (snprintf(partition_file_path, sizeof(partition_file_path),
+            "%s/%s/partition", sysfs_path, entry->d_name) < 0)
+            continue;
+
+        char start_file_path[PATH_MAX];
+        if (snprintf(start_file_path, sizeof(start_file_path), "%s/%s/start",
+                 sysfs_path, entry->d_name) < 0)
+            continue;
+
+        char size_file_path[PATH_MAX];
+        if (snprintf(size_file_path, sizeof(size_file_path), "%s/%s/size",
+                 sysfs_path, entry->d_name) < 0)
+            continue;
+
+        // Check if the 'partition' file exists within this subdirectory
+        // This is a filter against other subdirectories that do not
+        // refer to partitions
+        if (access(partition_file_path, F_OK) == 0 &&
+            access(start_file_path, F_OK) == 0 &&
+            access(size_file_path, F_OK) == 0) {
+
+            FILE *fstart = fopen(start_file_path, "r");
+            if (fstart) {
+                guint64 curr_part_start = 0;
+                if (fscanf(fstart, "%" PRIu64, &curr_part_start) == 1) {
+                    FILE *fsize = fopen(size_file_path, "r");
+                    if (fsize) {
+                        guint64 curr_part_size = 0;
+                        if (fscanf(fsize, "%" PRIu64, &curr_part_size) == 1) {
+                            if (abs_part_start >= curr_part_start &&
+                                abs_part_start + part_size <=
+                                curr_part_start + curr_part_size)
+                            {
+                                char *dir_name = strdup(dev_name);
+                                int last_slash = strlen(dev_name) - strlen(base_name);
+                                dir_name[last_slash] = '\0';
+
+                                g_string_printf(target_params, "%s%s %" PRIu64,
+                                            dir_name, entry->d_name,
+                                            abs_part_start - curr_part_start);
+                                found = 1;
+                                free(dir_name);
+                            }
+                        }
+                        fclose(fsize);
+                    }
+                }
+                fclose(fstart);
+            }
+        }
+    }
+
+    closedir(dir);
+    free(dev_name_copy);
+
+    return found ? 0 : -1;
+}
+
+static void _refine_partition(GString* target_params,
+    const LDMDiskPrivate * const disk, guint64 part_start, guint64 part_size)
+{
+    // The goal here is to try to use partition's block device instead
+    // of whole disk's device. The problem of using the whole disk is this:
+    // If LDM disk has at least one partition mounted directly, then it won't
+    // be possible to create *any* LDM devmapper device using that disk.
+    //
+    // Mounting LDM partition directly may make sense for cases like Linux
+    // system booting from LDM. The approach is the following:
+    // 1. First, you need to split GPT/MBR's LDM protective partition into a few
+    // separate protective partitions, so that your target LDM partition is
+    // exactly matched by one protective partition.
+    // 2. Then you'll be able to mount it as usual, boot from it and so on.
+    // Windows actually does this for its C:\ partition is the respective
+    // disk is converted to LDM.
+
+    if (_find_partition(target_params, disk->device,
+        disk->data_start + part_start, part_size) == 0) {
+        return;
+    }
+
+    // fallback
+    g_string_printf(target_params, "%s %" PRIu64,
+                disk->device, disk->data_start + part_start);
+}
+
 static GString *
 _dm_create_part(const LDMPartitionPrivate * const part, uint32_t cookie,
                 GError ** const err)
@@ -2747,8 +2862,7 @@ _dm_create_part(const LDMPartitionPrivate * const part, uint32_t cookie,
     target.size = part->size;
     target.type = "linear";
     target.params = g_string_new("");
-    g_string_printf(target.params, "%s %" PRIu64,
-                    disk->device, disk->data_start + part->start);
+    _refine_partition(target.params, disk, part->start, part->size);
 
     GString *name = _dm_part_name(part);
     GString *uuid = _dm_part_uuid(part);
@@ -2817,9 +2931,8 @@ _dm_create_spanned(const LDMVolumePrivate * const vol, GError ** const err)
         target->size = part->size;
         target->type = "linear";
         target->params = g_string_new("");
-        g_string_append_printf(target->params, "%s %" PRIu64,
-                                               disk->device,
-                                               disk->data_start + part->start);
+        _refine_partition(target->params, disk, part->start, part->size);
+
         pos += part->size;
     }
 
@@ -2878,9 +2991,7 @@ _dm_create_striped(const LDMVolumePrivate * const vol, GError ** const err)
             goto out;
         }
 
-        g_string_append_printf(target.params, " %s %" PRIu64,
-                                               disk->device,
-                                               disk->data_start + part->start);
+        _refine_partition(target.params, disk, part->start, part->size);
     }
 
     uint32_t cookie;