#if HAVE_VALGRIND_MEMCHECK_H

#include <valgrind/memcheck.h>

#include <linux/dm-ioctl.h>

#include <linux/loop.h>

#include <sys/mount.h>

#include <sys/prctl.h>

#include <sys/wait.h>

#include <sysexits.h>

#if HAVE_OPENSSL

#include <openssl/err.h>

#include <openssl/pem.h>

#include <openssl/x509.h>

#include "sd-device.h"

#include "sd-id128.h"

#include "architecture.h"

#include "ask-password-api.h"

#include "blkid-util.h"

#include "blockdev-util.h"

#include "chase-symlinks.h"

#include "conf-files.h"

#include "copy.h"

#include "cryptsetup-util.h"

#include "def.h"

#include "device-nodes.h"

#include "device-util.h"

#include "discover-image.h"

#include "dissect-image.h"

#include "dm-util.h"

#include "env-file.h"

#include "env-util.h"

#include "extension-release.h"

#include "fd-util.h"

#include "fileio.h"

#include "fs-util.h"

#include "fsck-util.h"

#include "gpt.h"

#include "hexdecoct.h"

#include "hostname-setup.h"

#include "id128-util.h"

#include "import-util.h"

#include "io-util.h"

#include "mkdir-label.h"

#include "mount-util.h"

#include "mountpoint-util.h"

#include "namespace-util.h"

#include "nulstr-util.h"

#include "openssl-util.h"

#include "os-util.h"

#include "path-util.h"

#include "process-util.h"

#include "raw-clone.h"

#include "resize-fs.h"

#include "signal-util.h"

#include "stat-util.h"

#include "stdio-util.h"

#include "string-table.h"

#include "string-util.h"

#include "strv.h"

#include "tmpfile-util.h"

#include "udev-util.h"

#include "user-util.h"

#include "xattr-util.h"

#define N_DEVICE_NODE_LIST_ATTEMPTS 10

int probe_filesystem(const char *node, char **ret_fstype) {

/* Try to find device content type and return it in *ret_fstype. If nothing is found,

#if HAVE_BLKID

_cleanup_(blkid_free_probep) blkid_probe b = NULL;

const char *fstype;

int r;

errno = 0;

b = blkid_new_probe_from_filename(node);

if (!b)

return errno_or_else(ENOMEM);

blkid_probe_enable_superblocks(b, 1);

blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE);

errno = 0;

r = blkid_do_safeprobe(b);

if (r == 1) {

log_debug("No type detected on partition %s", node);

goto not_found;

}

if (r == -2)

return log_debug_errno(SYNTHETIC_ERRNO(EUCLEAN),

"Results ambiguous for partition %s", node);

if (r != 0)

return errno_or_else(EIO);

(void) blkid_probe_lookup_value(b, "TYPE", &fstype, NULL);

if (fstype) {

char *t;

t = strdup(fstype);

if (!t)

return -ENOMEM;

*ret_fstype = t;

return 1;

}

not_found:

*ret_fstype = NULL;

return 0;

return -EOPNOTSUPP;

}

#if HAVE_BLKID

static int enumerator_for_parent(sd_device *d, sd_device_enumerator **ret) {

_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;

int r;

assert(d);

assert(ret);

r = sd_device_enumerator_new(&e);

if (r < 0)

return r;

r = sd_device_enumerator_add_match_subsystem(e, "block", true);

if (r < 0)

return r;

r = sd_device_enumerator_add_match_parent(e, d);

if (r < 0)

return r;

r = sd_device_enumerator_add_match_sysattr(e, "partition", NULL, true);

if (r < 0)

return r;

*ret = TAKE_PTR(e);

return 0;

}

static int device_is_partition(

sd_device *d,

sd_device *expected_parent,

blkid_partition pp) {

const char *v, *parent_syspath, *expected_parent_syspath;

blkid_loff_t bsize, bstart;

uint64_t size, start;

int partno, bpartno, r;

sd_device *parent;

assert(d);

assert(expected_parent);

assert(pp);

r = sd_device_get_subsystem(d, &v);

if (r < 0)

return r;

if (!streq(v, "block"))

return false;

if (sd_device_get_devtype(d, &v) < 0 || !streq(v, "partition"))

return false;

r = sd_device_get_parent(d, &parent);

if (r < 0)

return false; /* Doesn't have a parent? No relevant to us */

r = sd_device_get_syspath(parent, &parent_syspath); /* Check parent of device of this action */

if (r < 0)

return r;

r = sd_device_get_syspath(expected_parent, &expected_parent_syspath); /* Check parent of device we are looking for */

if (r < 0)

return r;

if (!path_equal(parent_syspath, expected_parent_syspath))

return false; /* Has a different parent than what we need, not interesting to us */

/* On kernel uevents we may find the partition number in the PARTN= field. Let's use that preferably,

r = sd_device_get_property_value(d, "PARTN", &v);

if (r == -ENOENT)

r = sd_device_get_sysattr_value(d, "partition", &v);

if (r < 0)

return r;

r = safe_atoi(v, &partno);

if (r < 0)

return r;

errno = 0;

bpartno = blkid_partition_get_partno(pp);

if (bpartno < 0)

return errno_or_else(EIO);

if (partno != bpartno)

return false;

r = sd_device_get_sysattr_value(d, "start", &v);

if (r < 0)

return r;

r = safe_atou64(v, &start);

if (r < 0)

return r;

errno = 0;

bstart = blkid_partition_get_start(pp);

if (bstart < 0)

return errno_or_else(EIO);

if (start != (uint64_t) bstart)

return false;

r = sd_device_get_sysattr_value(d, "size", &v);

if (r < 0)

return r;

r = safe_atou64(v, &size);

if (r < 0)

return r;

errno = 0;

bsize = blkid_partition_get_size(pp);

if (bsize < 0)

return errno_or_else(EIO);

if (size != (uint64_t) bsize)

return false;

return true;

}

static int find_partition(

sd_device **ret) {

_cleanup_(sd_device_enumerator_unrefp) sd_device_enumerator *e = NULL;

sd_device *q;

int r;

assert(parent);

assert(pp);

assert(ret);

r = enumerator_for_parent(parent, &e);

if (r < 0)

return r;

FOREACH_DEVICE(e, q) {

uint64_t usec;

if (!FLAGS_SET(flags, DISSECT_IMAGE_NO_UDEV)) {

r = sd_device_get_usec_initialized(q, &usec);

if (r == -EBUSY) /* Not initialized yet */

continue;

if (r < 0)

return r;

if (timestamp_not_before != USEC_INFINITY &&

usec < timestamp_not_before) /* udev database entry older than our attachment? Then it's not ours */

continue;

}

r = device_is_partition(q, parent, pp);

if (r < 0)

return r;

if (r > 0) {

*ret = sd_device_ref(q);

return 0;

}

}

return -ENXIO;

}

struct wait_data {

};

static inline void wait_data_done(struct wait_data *d) {

sd_device_unref(d->found);

}

static int device_monitor_handler(sd_device_monitor *monitor, sd_device *device, void *userdata) {

struct wait_data *w = userdata;

int r;

assert(w);

if (device_for_action(device, SD_DEVICE_REMOVE))

return 0;

if (w->diskseq != 0) {

uint64_t diskseq;

/* If w->diskseq is non-zero, then we must have a disk seqnum */

r = sd_device_get_diskseq(device, &diskseq);

if (r < 0) {

log_debug_errno(r, "Dropping event because it has no diskseq, but waiting for %" PRIu64, w->diskseq);

return 0;

}

if (diskseq < w->diskseq) {

log_debug("Dropping event because diskseq too old (%" PRIu64 " < %" PRIu64 ")",

diskseq, w->diskseq);

return 0;

}

if (diskseq > w->diskseq) {

r = -EBUSY;

goto finish; /* Newer than what we were expecting, so we missed it, stop waiting */

}

} else if (w->uevent_seqnum_not_before != UINT64_MAX) {

uint64_t seqnum;

r = sd_device_get_seqnum(device, &seqnum);

if (r < 0)

goto finish;

if (seqnum <= w->uevent_seqnum_not_before) { /* From an older use of this loop device */

log_debug("Dropping event because seqnum too old (%" PRIu64 " <= %" PRIu64 ")",

seqnum, w->uevent_seqnum_not_before);

return 0;

}

}

r = device_is_partition(device, w->parent_device, w->blkidp);

if (r < 0)

goto finish;

if (r == 0) /* Not the one we need */

return 0;

/* It's the one we need! Yay! */

assert(!w->found);

w->found = sd_device_ref(device);

r = 0;

finish:

return sd_event_exit(sd_device_monitor_get_event(monitor), r);

}

static int timeout_handler(sd_event_source *s, uint64_t usec, void *userdata) {

struct wait_data *w = userdata;

int r;

assert(w);

/* Why partition not appeared within the timeout? We may lost some uevent, as some properties

r = find_partition(w->parent_device, w->blkidp, w->timestamp_not_before, w->flags, &w->found);

if (r == -ENXIO)

return log_debug_errno(SYNTHETIC_ERRNO(ETIMEDOUT),

"Partition still not appeared after timeout reached.");

if (r < 0)

return log_debug_errno(r, "Failed to find partition: %m");

log_debug("Partition appeared after timeout reached.");

return sd_event_exit(sd_event_source_get_event(s), 0);

}

static int retry_handler(sd_event_source *s, uint64_t usec, void *userdata) {

struct wait_data *w = userdata;

int r;

assert(w);

r = find_partition(w->parent_device, w->blkidp, w->timestamp_not_before, w->flags, &w->found);

if (r != -ENXIO) {

if (r < 0)

return log_debug_errno(r, "Failed to find partition: %m");

log_debug("Partition found by a periodic search.");

return sd_event_exit(sd_event_source_get_event(s), 0);

}

r = sd_event_source_set_time_relative(s, 500 * USEC_PER_MSEC);

if (r < 0)

return r;

return sd_event_source_set_enabled(s, SD_EVENT_ONESHOT);

}

static int wait_for_partition_device(

sd_device **ret) {

_cleanup_(sd_event_source_unrefp) sd_event_source *timeout_source = NULL, *retry_source = NULL;

_cleanup_(sd_device_monitor_unrefp) sd_device_monitor *monitor = NULL;

_cleanup_(sd_event_unrefp) sd_event *event = NULL;

int r;

assert(parent);

assert(pp);

assert(ret);

r = find_partition(parent, pp, timestamp_not_before, flags, ret);

if (r != -ENXIO)

return r;

r = sd_event_new(&event);

if (r < 0)

return r;

r = sd_device_monitor_new(&monitor);

if (r < 0)

return r;

r = sd_device_monitor_filter_add_match_subsystem_devtype(monitor, "block", "partition");

if (r < 0)

return r;

r = sd_device_monitor_filter_add_match_parent(monitor, parent, true);

if (r < 0)

return r;

r = sd_device_monitor_filter_add_match_sysattr(monitor, "partition", NULL, true);

if (r < 0)

return r;

r = sd_device_monitor_attach_event(monitor, event);

if (r < 0)

return r;

_cleanup_(wait_data_done) struct wait_data w = {

.parent_device = parent,

.blkidp = pp,

.diskseq = diskseq,

.uevent_seqnum_not_before = uevent_seqnum_not_before,

.timestamp_not_before = timestamp_not_before,

.flags = flags,

};

r = sd_device_monitor_start(monitor, device_monitor_handler, &w);

if (r < 0)

return r;

/* Check again, the partition might have appeared in the meantime */

r = find_partition(parent, pp, timestamp_not_before, flags, ret);

if (r != -ENXIO)

return r;

if (deadline != USEC_INFINITY) {

r = sd_event_add_time(

event, &timeout_source,

CLOCK_MONOTONIC, deadline, 0,

timeout_handler, &w);

if (r < 0)

return r;

r = sd_event_source_set_exit_on_failure(timeout_source, true);

if (r < 0)

return r;

}

/* If we don't have a disk sequence number then we cannot do exact matching,

if (diskseq == 0) {

r = sd_event_add_time_relative(

event, &retry_source,

CLOCK_MONOTONIC, 500 * USEC_PER_MSEC, 0,

retry_handler, &w);

if (r < 0)

return r;

r = sd_event_source_set_exit_on_failure(retry_source, true);

if (r < 0)

return r;

}

r = sd_event_loop(event);

if (r < 0)

return r;

assert(w.found);

*ret = TAKE_PTR(w.found);

return 0;

}

static void check_partition_flags(

const char *node,

unsigned long long pflags,

unsigned long long supported) {

assert(node);

/* Mask away all flags supported by this partition's type and the three flags the UEFI spec defines generically */

pflags &= ~(supported | GPT_FLAG_REQUIRED_PARTITION | GPT_FLAG_NO_BLOCK_IO_PROTOCOL | GPT_FLAG_LEGACY_BIOS_BOOTABLE);

if (pflags == 0)

return;

/* If there are other bits set, then log about it, to make things discoverable */

for (unsigned i = 0; i < sizeof(pflags) * 8; i++) {

unsigned long long bit = 1ULL << i;

if (!FLAGS_SET(pflags, bit))

continue;

log_debug("Unexpected partition flag %llu set on %s!", bit, node);

}

}

static int device_wait_for_initialization_harder(

sd_device **ret) {

usec_t start, left, retrigger_timeout;

int r;

start = now(CLOCK_MONOTONIC);

left = usec_sub_unsigned(deadline, start);

if (DEBUG_LOGGING) {

const char *sn = NULL;

(void) sd_device_get_sysname(device, &sn);

log_device_debug(device,

"Will wait up to %s for '%s' to initialize…", FORMAT_TIMESPAN(left, 0), strna(sn));

}

if (left != USEC_INFINITY)

retrigger_timeout = CLAMP(left / 4, 1 * USEC_PER_SEC, 5 * USEC_PER_SEC); /* A fourth of the total timeout, but let's clamp to 1s…5s range */

else

retrigger_timeout = 2 * USEC_PER_SEC;

for (;;) {

usec_t local_deadline, n;

bool last_try;

n = now(CLOCK_MONOTONIC);

assert(n >= start);

/* Find next deadline, when we'll retrigger */

local_deadline = start +

DIV_ROUND_UP(n - start, retrigger_timeout) * retrigger_timeout;

if (deadline != USEC_INFINITY && deadline <= local_deadline) {

local_deadline = deadline;

last_try = true;

} else

last_try = false;

r = device_wait_for_initialization(device, subsystem, local_deadline, ret);

if (r >= 0 && DEBUG_LOGGING) {

const char *sn = NULL;

(void) sd_device_get_sysname(device, &sn);

log_device_debug(device,

"Successfully waited for device '%s' to initialize for %s.",

strna(sn),

FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), start), 0));

}

if (r != -ETIMEDOUT || last_try)

return r;

if (DEBUG_LOGGING)

log_device_debug(device,

"Device didn't initialize within %s, assuming lost event. Retriggering device.",

FORMAT_TIMESPAN(usec_sub_unsigned(now(CLOCK_MONOTONIC), start), 0));

r = sd_device_trigger(device, SD_DEVICE_CHANGE);

if (r < 0)

return r;

}

}

#define DEVICE_TIMEOUT_USEC (45 * USEC_PER_SEC)

static void dissected_partition_done(DissectedPartition *p) {

assert(p);

free(p->fstype);

free(p->node);

free(p->label);

free(p->decrypted_fstype);

free(p->decrypted_node);

free(p->mount_options);

*p = (DissectedPartition) {

.partno = -1,

.architecture = -1

};

}

int dissect_image(

DissectedImage **ret) {

#if HAVE_BLKID

sd_id128_t root_uuid = SD_ID128_NULL, root_verity_uuid = SD_ID128_NULL;

sd_id128_t usr_uuid = SD_ID128_NULL, usr_verity_uuid = SD_ID128_NULL;

bool is_gpt, is_mbr, multiple_generic = false,

generic_rw = false, /* initialize to appease gcc */

generic_growfs = false;

_cleanup_(sd_device_unrefp) sd_device *d = NULL;

_cleanup_(dissected_image_unrefp) DissectedImage *m = NULL;

_cleanup_(blkid_free_probep) blkid_probe b = NULL;

_cleanup_free_ char *generic_node = NULL;

sd_id128_t generic_uuid = SD_ID128_NULL;

const char *pttype = NULL, *sysname = NULL;

blkid_partlist pl;

int r, generic_nr = -1, n_partitions;

struct stat st;

usec_t deadline;

assert(fd >= 0);

assert(ret);

assert(!verity || verity->designator < 0 || IN_SET(verity->designator, PARTITION_ROOT, PARTITION_USR));

assert(!verity || verity->root_hash || verity->root_hash_size == 0);

assert(!verity || verity->root_hash_sig || verity->root_hash_sig_size == 0);

assert(!verity || (verity->root_hash || !verity->root_hash_sig));

assert(!((flags & DISSECT_IMAGE_GPT_ONLY) && (flags & DISSECT_IMAGE_NO_PARTITION_TABLE)));

/* Probes a disk image, and returns information about what it found in *ret.

if (verity && verity->root_hash) {

sd_id128_t fsuuid, vuuid;

/* If a root hash is supplied, then we use the root partition that has a UUID that match the

if (verity->root_hash_size < sizeof(sd_id128_t))

return -EINVAL;

memcpy(&fsuuid, verity->root_hash, sizeof(sd_id128_t));

memcpy(&vuuid, (const uint8_t*) verity->root_hash + verity->root_hash_size - sizeof(sd_id128_t), sizeof(sd_id128_t));

if (sd_id128_is_null(fsuuid))

return -EINVAL;

if (sd_id128_is_null(vuuid))

return -EINVAL;

/* If the verity data declares it's for the /usr partition, then search for that, in all

if (verity->designator == PARTITION_USR) {

usr_uuid = fsuuid;

usr_verity_uuid = vuuid;

} else {

root_uuid = fsuuid;

root_verity_uuid = vuuid;

}

}

if (fstat(fd, &st) < 0)

return -errno;

if (!S_ISBLK(st.st_mode))

return -ENOTBLK;

r = sd_device_new_from_stat_rdev(&d, &st);

if (r < 0)

return r;

if (!FLAGS_SET(flags, DISSECT_IMAGE_NO_UDEV)) {

_cleanup_(sd_device_unrefp) sd_device *initialized = NULL;

/* If udev support is enabled, then let's wait for the device to be initialized before we doing anything. */

r = device_wait_for_initialization_harder(

d,

"block",

usec_add(now(CLOCK_MONOTONIC), DEVICE_TIMEOUT_USEC),

&initialized);

if (r < 0)

return r;

sd_device_unref(d);

d = TAKE_PTR(initialized);

}

b = blkid_new_probe();

if (!b)

return -ENOMEM;

errno = 0;

r = blkid_probe_set_device(b, fd, 0, 0);

if (r != 0)

return errno_or_else(ENOMEM);

if ((flags & DISSECT_IMAGE_GPT_ONLY) == 0) {

/* Look for file system superblocks, unless we only shall look for GPT partition tables */

blkid_probe_enable_superblocks(b, 1);

blkid_probe_set_superblocks_flags(b, BLKID_SUBLKS_TYPE|BLKID_SUBLKS_USAGE);

}

blkid_probe_enable_partitions(b, 1);

blkid_probe_set_partitions_flags(b, BLKID_PARTS_ENTRY_DETAILS);

errno = 0;

r = blkid_do_safeprobe(b);

if (IN_SET(r, -2, 1))

return log_debug_errno(SYNTHETIC_ERRNO(ENOPKG), "Failed to identify any partition table.");

if (r != 0)

return errno_or_else(EIO);

m = new(DissectedImage, 1);

if (!m)

return -ENOMEM;

*m = (DissectedImage) {

.has_init_system = -1,

};

r = sd_device_get_sysname(d, &sysname);

if (r < 0)

return log_debug_errno(r, "Failed to get device sysname: %m");

if (startswith(sysname, "loop")) {

_cleanup_free_ char *name_stripped = NULL;

const char *full_path;

r = sd_device_get_sysattr_value(d, "loop/backing_file", &full_path);

if (r < 0)

log_debug_errno(r, "Failed to lookup image name via loop device backing file sysattr, ignoring: %m");

else {

r = raw_strip_suffixes(basename(full_path), &name_stripped);

if (r < 0)

return r;

}

free_and_replace(m->image_name, name_stripped);

} else {

r = free_and_strdup(&m->image_name, sysname);

if (r < 0)

return r;

}

if (!image_name_is_valid(m->image_name)) {

log_debug("Image name %s is not valid, ignoring", strempty(m->image_name));

m->image_name = mfree(m->image_name);

}

if ((!(flags & DISSECT_IMAGE_GPT_ONLY) &&

(flags & DISSECT_IMAGE_GENERIC_ROOT)) ||

(flags & DISSECT_IMAGE_NO_PARTITION_TABLE)) {

const char *usage = NULL;

/* If flags permit this, also allow using non-partitioned single-filesystem images */

(void) blkid_probe_lookup_value(b, "USAGE", &usage, NULL);

if (STRPTR_IN_SET(usage, "filesystem", "crypto")) {

const char *fstype = NULL, *options = NULL, *devname = NULL;

_cleanup_free_ char *t = NULL, *n = NULL, *o = NULL;

/* OK, we have found a file system, that's our root partition then. */

(void) blkid_probe_lookup_value(b, "TYPE", &fstype, NULL);

if (fstype) {

t = strdup(fstype);

if (!t)

return -ENOMEM;

}

r = sd_device_get_devname(d, &devname);

if (r < 0)

return r;

n = strdup(devname);

if (!n)

return -ENOMEM;

m->single_file_system = true;

m->encrypted = streq_ptr(fstype, "crypto_LUKS");

m->has_verity = verity && verity->data_path;

m->verity_ready = m->has_verity &&

verity->root_hash &&

(verity->designator < 0 || verity->designator == PARTITION_ROOT);

m->has_verity_sig = false; /* signature not embedded, must be specified */

m->verity_sig_ready = m->verity_ready &&

verity->root_hash_sig;

options = mount_options_from_designator(mount_options, PARTITION_ROOT);

if (options) {

o = strdup(options);

if (!o)

return -ENOMEM;

}

m->partitions[PARTITION_ROOT] = (DissectedPartition) {

.found = true,

.rw = !m->verity_ready && !fstype_is_ro(fstype),

.partno = -1,

.architecture = _ARCHITECTURE_INVALID,

.fstype = TAKE_PTR(t),

.node = TAKE_PTR(n),

.mount_options = TAKE_PTR(o),

.offset = 0,

.size = UINT64_MAX,

};

*ret = TAKE_PTR(m);

return 0;

}

}

(void) blkid_probe_lookup_value(b, "PTTYPE", &pttype, NULL);

if (!pttype)

return -ENOPKG;

is_gpt = streq_ptr(pttype, "gpt");

is_mbr = streq_ptr(pttype, "dos");

if (!is_gpt && ((flags & DISSECT_IMAGE_GPT_ONLY) || !is_mbr))

return -ENOPKG;

/* We support external verity data partitions only if the image has no partition table */

if (verity && verity->data_path)

return -EBADR;

/* Safety check: refuse block devices that carry a partition table but for which the kernel doesn't

r = blockdev_partscan_enabled(fd);

if (r < 0)

return r;

if (r == 0)

return -EPROTONOSUPPORT;

errno = 0;

pl = blkid_probe_get_partitions(b);

if (!pl)

return errno_or_else(ENOMEM);

errno = 0;

n_partitions = blkid_partlist_numof_partitions(pl);

if (n_partitions < 0)

return errno_or_else(EIO);

deadline = usec_add(now(CLOCK_MONOTONIC), DEVICE_TIMEOUT_USEC);

for (int i = 0; i < n_partitions; i++) {

_cleanup_(sd_device_unrefp) sd_device *q = NULL;

unsigned long long pflags;

blkid_loff_t start, size;

blkid_partition pp;

const char *node;

int nr;

errno = 0;

pp = blkid_partlist_get_partition(pl, i);

if (!pp)

return errno_or_else(EIO);

r = wait_for_partition_device(d, pp, deadline, diskseq, uevent_seqnum_not_before, timestamp_not_before, flags, &q);

if (r < 0)

return r;

r = sd_device_get_devname(q, &node);

if (r < 0)

return r;

pflags = blkid_partition_get_flags(pp);

errno = 0;

nr = blkid_partition_get_partno(pp);

if (nr < 0)

return errno_or_else(EIO);

errno = 0;

start = blkid_partition_get_start(pp);

if (start < 0)

return errno_or_else(EIO);

assert((uint64_t) start < UINT64_MAX/512);

errno = 0;

size = blkid_partition_get_size(pp);

if (size < 0)

return errno_or_else(EIO);

assert((uint64_t) size < UINT64_MAX/512);

if (is_gpt) {

PartitionDesignator designator = _PARTITION_DESIGNATOR_INVALID;

int architecture = _ARCHITECTURE_INVALID;

const char *stype, *sid, *fstype = NULL, *label;

sd_id128_t type_id, id;

bool rw = true, growfs = false;

sid = blkid_partition_get_uuid(pp);

if (!sid)

continue;

if (sd_id128_from_string(sid, &id) < 0)

continue;

stype = blkid_partition_get_type_string(pp);

if (!stype)

continue;

if (sd_id128_from_string(stype, &type_id) < 0)

continue;

label = blkid_partition_get_name(pp); /* libblkid returns NULL here if empty */

if (sd_id128_equal(type_id, GPT_HOME)) {

check_partition_flags(node, pflags, GPT_FLAG_NO_AUTO|GPT_FLAG_READ_ONLY|GPT_FLAG_GROWFS);

if (pflags & GPT_FLAG_NO_AUTO)

continue;

designator = PARTITION_HOME;

rw = !(pflags & GPT_FLAG_READ_ONLY);

growfs = FLAGS_SET(pflags, GPT_FLAG_GROWFS);

} else if (sd_id128_equal(type_id, GPT_SRV)) {

check_partition_flags(node, pflags, GPT_FLAG_NO_AUTO|GPT_FLAG_READ_ONLY|GPT_FLAG_GROWFS);

if (pflags & GPT_FLAG_NO_AUTO)

continue;

designator = PARTITION_SRV;

rw = !(pflags & GPT_FLAG_READ_ONLY);

growfs = FLAGS_SET(pflags, GPT_FLAG_GROWFS);

} else if (sd_id128_equal(type_id, GPT_ESP)) {

/* Note that we don't check the GPT_FLAG_NO_AUTO flag for the ESP, as it is

if (pflags & GPT_FLAG_NO_BLOCK_IO_PROTOCOL)

continue;

designator = PARTITION_ESP;

fstype = "vfat";

} else if (sd_id128_equal(type_id, GPT_XBOOTLDR)) {

check_partition_flags(node, pflags, GPT_FLAG_NO_AUTO|GPT_FLAG_READ_ONLY|GPT_FLAG_GROWFS);

if (pflags & GPT_FLAG_NO_AUTO)

continue;

designator = PARTITION_XBOOTLDR;

rw = !(pflags & GPT_FLAG_READ_ONLY);

growfs = FLAGS_SET(pflags, GPT_FLAG_GROWFS);

} else if (gpt_partition_type_is_root(type_id)) {

check_partition_flags(node, pflags, GPT_FLAG_NO_AUTO|GPT_FLAG_READ_ONLY|GPT_FLAG_GROWFS);

if (pflags & GPT_FLAG_NO_AUTO)

continue;

/* If a root ID is specified, ignore everything but the root id */

if (!sd_id128_is_null(root_uuid) && !sd_id128_equal(root_uuid, id))

continue;

assert_se((architecture = gpt_partition_type_uuid_to_arch(type_id)) >= 0);

designator = PARTITION_ROOT_OF_ARCH(architecture);

rw = !(pflags & GPT_FLAG_READ_ONLY);

growfs = FLAGS_SET(pflags, GPT_FLAG_GROWFS);