blockdev-util: re-implement block_get_originating() by using sd_device
And split out the core logic as block_device_get_originating(). Hopefully, this changes no behavior. Just refactoring and preparation for later commits.
This commit is contained in:
Yu Watanabe
+54
-72
@@ -119,6 +119,54 @@ int block_device_get_whole_disk(sd_device *dev, sd_device **ret) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int block_device_get_originating(sd_device *dev, sd_device **ret) {
|
||||
_cleanup_(sd_device_unrefp) sd_device *first_found = NULL;
|
||||
const char *suffix;
|
||||
sd_device *child;
|
||||
dev_t devnum = 0; /* avoid false maybe-uninitialized warning */
|
||||
|
||||
/* For the specified block device tries to chase it through the layers, in case LUKS-style DM
|
||||
* stacking is used, trying to find the next underlying layer. */
|
||||
|
||||
assert(dev);
|
||||
assert(ret);
|
||||
|
||||
FOREACH_DEVICE_CHILD_WITH_SUFFIX(dev, child, suffix) {
|
||||
sd_device *child_whole_disk;
|
||||
dev_t n;
|
||||
|
||||
if (!path_startswith(suffix, "slaves"))
|
||||
continue;
|
||||
|
||||
if (block_device_get_whole_disk(child, &child_whole_disk) < 0)
|
||||
continue;
|
||||
|
||||
if (sd_device_get_devnum(child_whole_disk, &n) < 0)
|
||||
continue;
|
||||
|
||||
if (!first_found) {
|
||||
first_found = sd_device_ref(child);
|
||||
devnum = n;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* We found a device backed by multiple other devices. We don't really support automatic
|
||||
* discovery on such setups, with the exception of dm-verity partitions. In this case there
|
||||
* are two backing devices: the data partition and the hash partition. We are fine with such
|
||||
* setups, however, only if both partitions are on the same physical device. Hence, let's
|
||||
* verify this by iterating over every node in the 'slaves/' directory and comparing them with
|
||||
* the first that gets returned by readdir(), to ensure they all point to the same device. */
|
||||
if (n != devnum)
|
||||
return -ENOTUNIQ;
|
||||
}
|
||||
|
||||
if (!first_found)
|
||||
return -ENOENT;
|
||||
|
||||
*ret = TAKE_PTR(first_found);
|
||||
return 1; /* found */
|
||||
}
|
||||
|
||||
int block_get_whole_disk(dev_t d, dev_t *ret) {
|
||||
char p[SYS_BLOCK_PATH_MAX("/partition")];
|
||||
_cleanup_free_ char *s = NULL;
|
||||
@@ -219,86 +267,20 @@ int get_block_device(const char *path, dev_t *ret) {
|
||||
}
|
||||
|
||||
int block_get_originating(dev_t dt, dev_t *ret) {
|
||||
_cleanup_closedir_ DIR *d = NULL;
|
||||
_cleanup_free_ char *t = NULL;
|
||||
char p[SYS_BLOCK_PATH_MAX("/slaves")];
|
||||
_cleanup_free_ char *first_found = NULL;
|
||||
const char *q;
|
||||
dev_t devt;
|
||||
_cleanup_(sd_device_unrefp) sd_device *dev = NULL, *origin = NULL;
|
||||
int r;
|
||||
|
||||
/* For the specified block device tries to chase it through the layers, in case LUKS-style DM stacking is used,
|
||||
* trying to find the next underlying layer. */
|
||||
assert(ret);
|
||||
|
||||
xsprintf_sys_block_path(p, "/slaves", dt);
|
||||
d = opendir(p);
|
||||
if (!d)
|
||||
return -errno;
|
||||
|
||||
FOREACH_DIRENT_ALL(de, d, return -errno) {
|
||||
|
||||
if (dot_or_dot_dot(de->d_name))
|
||||
continue;
|
||||
|
||||
if (!IN_SET(de->d_type, DT_LNK, DT_UNKNOWN))
|
||||
continue;
|
||||
|
||||
if (first_found) {
|
||||
_cleanup_free_ char *u = NULL, *v = NULL, *a = NULL, *b = NULL;
|
||||
|
||||
/* We found a device backed by multiple other devices. We don't really support
|
||||
* automatic discovery on such setups, with the exception of dm-verity partitions. In
|
||||
* this case there are two backing devices: the data partition and the hash
|
||||
* partition. We are fine with such setups, however, only if both partitions are on
|
||||
* the same physical device. Hence, let's verify this by iterating over every node
|
||||
* in the 'slaves/' directory and comparing them with the first that gets returned by
|
||||
* readdir(), to ensure they all point to the same device. */
|
||||
|
||||
u = path_join(p, de->d_name, "../dev");
|
||||
if (!u)
|
||||
return -ENOMEM;
|
||||
|
||||
v = path_join(p, first_found, "../dev");
|
||||
if (!v)
|
||||
return -ENOMEM;
|
||||
|
||||
r = read_one_line_file(u, &a);
|
||||
if (r < 0)
|
||||
return log_debug_errno(r, "Failed to read %s: %m", u);
|
||||
|
||||
r = read_one_line_file(v, &b);
|
||||
if (r < 0)
|
||||
return log_debug_errno(r, "Failed to read %s: %m", v);
|
||||
|
||||
/* Check if the parent device is the same. If not, then the two backing devices are on
|
||||
* different physical devices, and we don't support that. */
|
||||
if (!streq(a, b))
|
||||
return -ENOTUNIQ;
|
||||
} else {
|
||||
first_found = strdup(de->d_name);
|
||||
if (!first_found)
|
||||
return -ENOMEM;
|
||||
}
|
||||
}
|
||||
|
||||
if (!first_found)
|
||||
return -ENOENT;
|
||||
|
||||
q = strjoina(p, "/", first_found, "/dev");
|
||||
|
||||
r = read_one_line_file(q, &t);
|
||||
r = sd_device_new_from_devnum(&dev, 'b', dt);
|
||||
if (r < 0)
|
||||
return r;
|
||||
|
||||
r = parse_devnum(t, &devt);
|
||||
r = block_device_get_originating(dev, &origin);
|
||||
if (r < 0)
|
||||
return -EINVAL;
|
||||
return r;
|
||||
|
||||
if (major(devt) == 0)
|
||||
return -ENOENT;
|
||||
|
||||
*ret = devt;
|
||||
return 1;
|
||||
return sd_device_get_devnum(origin, ret);
|
||||
}
|
||||
|
||||
int get_block_device_harder_fd(int fd, dev_t *ret) {
|
||||
|
||||
Reference in New Issue
Block a user