HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/repart/repart.c
Git blob: b40c7a91acf99c5ac898f4de16e45b142c19fa8c
Lines 2001–3000 of 11,995
uint32_t *w = ASSERT_PTR(data), v;
int r;
assert(rvalue);
r = safe_atou32(rvalue, &v);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse weight value, ignoring: %s", rvalue);
return 0;
}
if (v > 1000U*1000U) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Weight needs to be in range 0…10000000, ignoring: %" PRIu32, v);
return 0;
}
*w = v;
return 0;
}
static int config_parse_size4096(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
uint64_t *sz = data, parsed;
int r;
assert(rvalue);
assert(data);
r = parse_size(rvalue, 1024, &parsed);
if (r < 0)
return log_syntax(unit, LOG_ERR, filename, line, r,
"Failed to parse size value: %s", rvalue);
if (ltype > 0)
*sz = round_up_size(parsed, 4096);
else if (ltype < 0)
*sz = round_down_size(parsed, 4096);
else
*sz = parsed;
if (*sz != parsed)
log_syntax(unit, LOG_NOTICE, filename, line, r, "Rounded %s= size %" PRIu64 " %s %" PRIu64 ", a multiple of 4096.",
lvalue, parsed, glyph(GLYPH_ARROW_RIGHT), *sz);
return 0;
}
static int config_parse_block_size(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
uint64_t *blksz = ASSERT_PTR(data), parsed;
int r;
assert(rvalue);
r = parse_size(rvalue, 1024, &parsed);
if (r < 0)
return log_syntax(unit, LOG_ERR, filename, line, r,
"Failed to parse size value: %s", rvalue);
if (parsed < 512 || parsed > 4096)
return log_syntax(unit, LOG_ERR, filename, line, SYNTHETIC_ERRNO(EINVAL),
"Value not between 512 and 4096: %s", rvalue);
if (!ISPOWEROF2(parsed))
return log_syntax(unit, LOG_ERR, filename, line, SYNTHETIC_ERRNO(EINVAL),
"Value not a power of 2: %s", rvalue);
*blksz = parsed;
return 0;
}
static int config_parse_fs_sector_size(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
uint64_t *fssecsz = ASSERT_PTR(data), parsed;
int r;
assert(rvalue);
if (isempty(rvalue)) {
*fssecsz = UINT64_MAX;
return 0;
}
r = parse_size(rvalue, 1024, &parsed);
if (r < 0)
return log_syntax(unit, LOG_ERR, filename, line, r,
"Failed to parse size value: %s", rvalue);
if (!ISPOWEROF2(parsed))
return log_syntax(unit, LOG_ERR, filename, line, SYNTHETIC_ERRNO(EINVAL),
"Value not a power of 2: %s", rvalue);
/* NB: we make no upper restriction here, since the maximum logical sector sizes file systems support
* vary greatly, and can be much larger than 4K. (That's also the reason we don't use
* parse_sector_size() here.) */
*fssecsz = parsed;
return 0;
}
static int config_parse_fstype(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
char **fstype = ASSERT_PTR(data);
const char *e;
assert(rvalue);
/* Let's provide an easy way to override the chosen fstype for file system partitions */
e = secure_getenv("SYSTEMD_REPART_OVERRIDE_FSTYPE");
if (e && !streq(rvalue, e)) {
log_syntax(unit, LOG_NOTICE, filename, line, 0,
"Overriding defined file system type '%s' with '%s'.", rvalue, e);
rvalue = e;
}
if (!filename_is_valid(rvalue))
return log_syntax(unit, LOG_ERR, filename, line, 0,
"File system type is not valid, refusing: %s", rvalue);
return free_and_strdup_warn(fstype, rvalue);
}
static int config_parse_copy_files(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_free_ char *source = NULL, *buffer = NULL, *resolved_source = NULL, *resolved_target = NULL, *options = NULL;
Partition *partition = ASSERT_PTR(data);
const char *p = rvalue, *target;
int r;
assert(rvalue);
r = extract_first_word(&p, &source, ":", EXTRACT_CUNESCAPE|EXTRACT_DONT_COALESCE_SEPARATORS);
if (r < 0)
return log_syntax(unit, LOG_ERR, filename, line, r, "Failed to extract source path: %s", rvalue);
if (r == 0) {
log_syntax(unit, LOG_WARNING, filename, line, 0, "No argument specified: %s", rvalue);
return 0;
}
r = extract_first_word(&p, &buffer, ":", EXTRACT_CUNESCAPE|EXTRACT_DONT_COALESCE_SEPARATORS);
if (r < 0)
return log_syntax(unit, LOG_ERR, filename, line, r, "Failed to extract target path: %s", rvalue);
if (r == 0)
target = source; /* No target, then it's the same as the source */
else
target = buffer;
r = extract_first_word(&p, &options, ":", EXTRACT_CUNESCAPE|EXTRACT_DONT_COALESCE_SEPARATORS);
if (r < 0)
return log_syntax(unit, LOG_ERR, filename, line, r, "Failed to extract options: %s", rvalue);
if (!isempty(p))
return log_syntax(unit, LOG_ERR, filename, line, SYNTHETIC_ERRNO(EINVAL), "Too many arguments: %s", rvalue);
CopyFlags flags = COPY_HOLES|COPY_MERGE|COPY_REPLACE|COPY_SIGINT|COPY_HARDLINKS|COPY_ALL_XATTRS|COPY_GRACEFUL_WARN|COPY_TRUNCATE|COPY_RESTORE_DIRECTORY_TIMESTAMPS;
for (const char *opts = options;;) {
_cleanup_free_ char *word = NULL;
const char *val;
r = extract_first_word(&opts, &word, ",", EXTRACT_DONT_COALESCE_SEPARATORS | EXTRACT_UNESCAPE_SEPARATORS);
if (r < 0)
return log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse CopyFile options: %s", options);
if (r == 0)
break;
if (isempty(word))
continue;
if ((val = startswith(word, "fsverity="))) {
if (streq(val, "copy"))
flags |= COPY_PRESERVE_FS_VERITY;
else if (streq(val, "off"))
flags &= ~COPY_PRESERVE_FS_VERITY;
else
log_syntax(unit, LOG_WARNING, filename, line, 0, "fsverity= expects either 'off' or 'copy'.");
} else
log_syntax(unit, LOG_WARNING, filename, line, 0, "Encountered unknown option '%s', ignoring.", word);
}
r = specifier_printf(source, PATH_MAX-1, system_and_tmp_specifier_table, arg_root, NULL, &resolved_source);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to expand specifiers in CopyFiles= source, ignoring: %s", rvalue);
return 0;
}
r = path_simplify_and_warn(resolved_source, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
if (r < 0)
return 0;
r = specifier_printf(target, PATH_MAX-1, system_and_tmp_specifier_table, arg_root, NULL, &resolved_target);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to expand specifiers in CopyFiles= target, ignoring: %s", resolved_target);
return 0;
}
r = path_simplify_and_warn(resolved_target, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
if (r < 0)
return 0;
if (!GREEDY_REALLOC(partition->copy_files, partition->n_copy_files + 1))
return log_oom();
partition->copy_files[partition->n_copy_files++] = (CopyFiles) {
.source = TAKE_PTR(resolved_source),
.target = TAKE_PTR(resolved_target),
.flags = flags,
};
return 0;
}
static int config_parse_exclude_files(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
char ***exclude_files = ASSERT_PTR(data);
const char *p = ASSERT_PTR(rvalue);
int r;
if (isempty(rvalue)) {
*exclude_files = strv_free(*exclude_files);
return 0;
}
for (;;) {
_cleanup_free_ char *word = NULL, *resolved = NULL;
r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", p);
return 0;
}
if (r == 0)
return 0;
r = specifier_printf(word, PATH_MAX-1, system_and_tmp_specifier_table, arg_root, NULL, &resolved);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to expand specifiers in %s path, ignoring: %s", lvalue, word);
return 0;
}
r = path_simplify_and_warn(resolved, PATH_CHECK_ABSOLUTE|PATH_KEEP_TRAILING_SLASH, unit, filename, line, lvalue);
if (r < 0)
return 0;
if (strv_consume(exclude_files, TAKE_PTR(resolved)) < 0)
return log_oom();
}
return 0;
}
static int config_parse_copy_blocks(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_free_ char *d = NULL;
Partition *partition = ASSERT_PTR(data);
int r;
assert(rvalue);
if (isempty(rvalue)) {
partition->copy_blocks_path = mfree(partition->copy_blocks_path);
partition->copy_blocks_auto = false;
return 0;
}
if (streq(rvalue, "auto")) {
partition->copy_blocks_path = mfree(partition->copy_blocks_path);
partition->copy_blocks_auto = true;
partition->copy_blocks_root = arg_root;
return 0;
}
r = specifier_printf(rvalue, PATH_MAX-1, system_and_tmp_specifier_table, arg_root, NULL, &d);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to expand specifiers in CopyBlocks= source path, ignoring: %s", rvalue);
return 0;
}
r = path_simplify_and_warn(d, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
if (r < 0)
return 0;
free_and_replace(partition->copy_blocks_path, d);
partition->copy_blocks_auto = false;
partition->copy_blocks_root = arg_root;
return 0;
}
static int config_parse_make_dirs(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
char ***sv = ASSERT_PTR(data);
const char *p = ASSERT_PTR(rvalue);
int r;
for (;;) {
_cleanup_free_ char *word = NULL, *d = NULL;
r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", rvalue);
return 0;
}
if (r == 0)
return 0;
r = specifier_printf(word, PATH_MAX-1, system_and_tmp_specifier_table, arg_root, NULL, &d);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to expand specifiers in MakeDirectories= parameter, ignoring: %s", word);
continue;
}
r = path_simplify_and_warn(d, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
if (r < 0)
continue;
if (strv_contains(*sv, d))
continue;
r = strv_consume(sv, TAKE_PTR(d));
if (r < 0)
return log_oom();
}
}
static int config_parse_make_symlinks(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
char ***sv = ASSERT_PTR(data);
const char *p = ASSERT_PTR(rvalue);
int r;
for (;;) {
_cleanup_free_ char *word = NULL, *source = NULL, *target = NULL, *resolved_source = NULL, *resolved_target = NULL;
r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", rvalue);
return 0;
}
if (r == 0)
return 0;
const char *q = word;
r = extract_many_words(&q, ":", EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS, &source, &target);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", q);
continue;
}
if (r != 2) {
log_syntax(unit, LOG_WARNING, filename, line, SYNTHETIC_ERRNO(EINVAL),
"Missing source or target in %s, ignoring", rvalue);
continue;
}
r = specifier_printf(source, PATH_MAX-1, system_and_tmp_specifier_table, arg_root, /* userdata= */ NULL, &resolved_source);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to expand specifiers in MakeSymlinks= source, ignoring: %s", source);
continue;
}
r = path_simplify_and_warn(resolved_source, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
if (r < 0)
continue;
r = specifier_printf(target, PATH_MAX-1, system_and_tmp_specifier_table, arg_root, /* userdata= */ NULL, &resolved_target);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to expand specifiers in MakeSymlinks= target, ignoring: %s", target);
continue;
}
/* Don't simplify the symlink target, preserve the exact argument including relative components */
r = strv_consume_pair(sv, TAKE_PTR(resolved_source), TAKE_PTR(resolved_target));
if (r < 0)
return log_error_errno(r, "Failed to add symlink to list: %m");
}
}
static int config_parse_subvolumes(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
OrderedHashmap **subvolumes = ASSERT_PTR(data);
const char *p = ASSERT_PTR(rvalue);
int r;
for (;;) {
_cleanup_free_ char *word = NULL, *path = NULL, *f = NULL, *d = NULL;
Subvolume *s = NULL;
r = extract_first_word(&p, &word, NULL, EXTRACT_UNQUOTE);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", rvalue);
return 0;
}
if (r == 0)
return 0;
const char *q = word;
r = extract_many_words(&q, ":", EXTRACT_UNQUOTE|EXTRACT_DONT_COALESCE_SEPARATORS, &path, &f);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Invalid syntax, ignoring: %s", q);
continue;
}
r = specifier_printf(path, PATH_MAX-1, system_and_tmp_specifier_table, arg_root, /* userdata= */ NULL, &d);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to expand specifiers in Subvolumes= parameter, ignoring: %s", path);
continue;
}
r = path_simplify_and_warn(d, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
if (r < 0)
continue;
s = ordered_hashmap_get(*subvolumes, d);
if (!s) {
s = new(Subvolume, 1);
if (!s)
return log_oom();
*s = (Subvolume) {
.path = TAKE_PTR(d),
};
r = ordered_hashmap_ensure_put(subvolumes, &subvolume_hash_ops, s->path, s);
if (r < 0) {
subvolume_free(s);
return r;
}
}
if (f) {
BtrfsSubvolFlags flags = subvolume_flags_from_string(f);
if (flags == -EBADRQC) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Unknown subvolume flag in subvolume, ignoring: %s", f);
continue;
}
if (flags < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse subvolume flags, ignoring: %s", f);
continue;
}
s->flags = flags;
}
}
}
static int config_parse_default_subvolume(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
char **subvol = ASSERT_PTR(data);
_cleanup_free_ char *p = NULL;
int r;
if (isempty(rvalue)) {
*subvol = mfree(*subvol);
return 0;
}
r = specifier_printf(rvalue, PATH_MAX-1, system_and_tmp_specifier_table, arg_root, NULL, &p);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to expand specifiers in DefaultSubvolume= parameter, ignoring: %s", rvalue);
return 0;
}
r = path_simplify_and_warn(p, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
if (r < 0)
return 0;
return free_and_replace(*subvol, p);
}
static DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(config_parse_encrypt, encrypt_mode, EncryptMode, ENCRYPT_OFF);
static int config_parse_gpt_flags(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
uint64_t *gpt_flags = ASSERT_PTR(data);
int r;
assert(rvalue);
r = safe_atou64(rvalue, gpt_flags);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Failed to parse Flags= value, ignoring: %s", rvalue);
return 0;
}
return 0;
}
static int config_parse_uuid(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
Partition *partition = ASSERT_PTR(data);
int r;
if (isempty(rvalue)) {
partition->new_uuid = SD_ID128_NULL;
partition->new_uuid_is_set = false;
return 0;
}
if (streq(rvalue, "null")) {
partition->new_uuid = SD_ID128_NULL;
partition->new_uuid_is_set = true;
return 0;
}
r = sd_id128_from_string(rvalue, &partition->new_uuid);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r, "Failed to parse 128-bit ID/UUID, ignoring: %s", rvalue);
return 0;
}
partition->new_uuid_is_set = true;
return 0;
}
static int config_parse_mountpoint(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_free_ char *where = NULL, *options = NULL;
Partition *p = ASSERT_PTR(data);
int r;
if (isempty(rvalue)) {
partition_mountpoint_free_many(p->mountpoints, p->n_mountpoints);
return 0;
}
const char *q = rvalue;
r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_DONT_COALESCE_SEPARATORS|EXTRACT_UNQUOTE,
&where, &options);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Invalid syntax in %s=, ignoring: %s", lvalue, rvalue);
return 0;
}
if (r < 1) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Too few arguments in %s=, ignoring: %s", lvalue, rvalue);
return 0;
}
if (!isempty(q)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Too many arguments in %s=, ignoring: %s", lvalue, rvalue);
return 0;
}
r = path_simplify_and_warn(where, PATH_CHECK_ABSOLUTE, unit, filename, line, lvalue);
if (r < 0)
return 0;
if (!GREEDY_REALLOC(p->mountpoints, p->n_mountpoints + 1))
return log_oom();
p->mountpoints[p->n_mountpoints++] = (PartitionMountPoint) {
.where = TAKE_PTR(where),
.options = TAKE_PTR(options),
};
return 0;
}
static int config_parse_encrypted_volume(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
_cleanup_free_ char *volume = NULL, *keyfile = NULL, *options = NULL, *extra = NULL;
bool fixate_volume_key = false;
Partition *p = ASSERT_PTR(data);
int r;
if (isempty(rvalue)) {
p->encrypted_volume = mfree(p->encrypted_volume);
return 0;
}
const char *q = rvalue;
r = extract_many_words(&q, ":", EXTRACT_CUNESCAPE|EXTRACT_DONT_COALESCE_SEPARATORS|EXTRACT_UNQUOTE,
&volume, &keyfile, &options, &extra);
if (r == -ENOMEM)
return log_oom();
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, r,
"Invalid syntax in %s=, ignoring: %s", lvalue, rvalue);
return 0;
}
if (r < 1) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Too few arguments in %s=, ignoring: %s", lvalue, rvalue);
return 0;
}
if (!isempty(q)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Too many arguments in %s=, ignoring: %s", lvalue, rvalue);
return 0;
}
if (isempty(volume))
volume = mfree(volume);
else if (!filename_is_valid(volume)) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Volume name %s is not valid, ignoring", volume);
return 0;
}
partition_encrypted_volume_free(p->encrypted_volume);
p->encrypted_volume = new(PartitionEncryptedVolume, 1);
if (!p->encrypted_volume)
return log_oom();
for (const char *e = extra;;) {
_cleanup_free_ char *word = NULL;
r = extract_first_word(&e, &word, ",", EXTRACT_DONT_COALESCE_SEPARATORS | EXTRACT_UNESCAPE_SEPARATORS);
if (r < 0) {
log_syntax(unit, LOG_WARNING, filename, line, 0,
"Failed to parse extra options '%s', ignoring", word);
break;
}
if (r == 0)
break;
if (streq(word, "fixate-volume-key"))
fixate_volume_key = true;
else
log_syntax(unit, LOG_WARNING, filename, line, 0, "Unknown extra option '%s', ignoring", word);
}
*p->encrypted_volume = (PartitionEncryptedVolume) {
.name = TAKE_PTR(volume),
.keyfile = TAKE_PTR(keyfile),
.options = TAKE_PTR(options),
.fixate_volume_key = fixate_volume_key,
};
return 0;
}
static int config_parse_tpm2_pcrs(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
Partition *partition = ASSERT_PTR(data);
assert(rvalue);
if (isempty(rvalue)) {
/* Clear existing PCR values if empty */
partition->tpm2_hash_pcr_values = mfree(partition->tpm2_hash_pcr_values);
partition->tpm2_n_hash_pcr_values = 0;
return 0;
}
return tpm2_parse_pcr_argument_append(rvalue, &partition->tpm2_hash_pcr_values,
&partition->tpm2_n_hash_pcr_values);
}
static int parse_key_file(const char *filename, struct iovec *key) {
_cleanup_(erase_and_freep) char *k = NULL;
size_t n = 0;
int r;
assert(key);
r = read_full_file_full(
AT_FDCWD, filename,
/* offset= */ UINT64_MAX,
/* size= */ SIZE_MAX,
READ_FULL_FILE_SECURE|READ_FULL_FILE_WARN_WORLD_READABLE|READ_FULL_FILE_CONNECT_SOCKET,
/* bind_name= */ NULL,
&k, &n);
if (r < 0)
return log_error_errno(r, "Failed to read key file '%s': %m", filename);
iovec_done_erase(key);
*key = IOVEC_MAKE(TAKE_PTR(k), n);
return 0;
}
static int config_parse_key_file(
const char *unit,
const char *filename,
unsigned line,
const char *section,
unsigned section_line,
const char *lvalue,
int ltype,
const char *rvalue,
void *data,
void *userdata) {
Partition *partition = ASSERT_PTR(userdata);
assert(rvalue);
if (isempty(rvalue)) {
iovec_done_erase(&partition->key);
return 0;
}
return parse_key_file(rvalue, &partition->key);
}
static DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(config_parse_integrity, integrity_mode, IntegrityMode, INTEGRITY_OFF);
static DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(config_parse_integrity_alg, integrity_alg, IntegrityAlg, INTEGRITY_ALG_HMAC_SHA256);
static DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(config_parse_encrypt_kdf, encrypt_kdf, EncryptKDF, _ENCRYPT_KDF_INVALID);
static DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(config_parse_verity, verity_mode, VerityMode, VERITY_OFF);
static DEFINE_CONFIG_PARSE_ENUM_WITH_DEFAULT(config_parse_minimize, minimize_mode, MinimizeMode, MINIMIZE_OFF);
static int partition_finalize_fstype(Partition *p, const char *path) {
_cleanup_free_ char *e = NULL, *upper = NULL;
assert(p);
assert(path);
if (!gpt_partition_type_has_filesystem(p->type))
return 0;
upper = strdup(partition_designator_to_string(p->type.designator));
if (!upper)
return log_oom();
e = strjoin("SYSTEMD_REPART_OVERRIDE_FSTYPE_", string_replace_char(ascii_strupper(upper), '-', '_'));
if (!e)
return log_oom();
const char *v = secure_getenv(e);
if (!v || streq_ptr(p->format, v))
return 0;
log_syntax(NULL, LOG_NOTICE, path, 1, 0,
"Overriding defined file system type '%s' for '%s' partition with '%s'.",
p->format, partition_designator_to_string(p->type.designator), v);
return free_and_strdup_warn(&p->format, v);
}
static bool partition_add_validatefs(const Partition *p) {
assert(p);
if (p->add_validatefs >= 0)
return p->add_validatefs;
return p->format && !STR_IN_SET(p->format, "swap", "vfat");
}
static bool partition_needs_populate(const Partition *p) {
assert(p);
assert(!p->supplement_for || !p->suppressing_supplement); /* Avoid infinite recursion */
return p->n_copy_files > 0 ||
!strv_isempty(p->make_directories) ||
!strv_isempty(p->make_symlinks) ||
partition_add_validatefs(p) ||
(p->suppressing_supplement && partition_needs_populate(p->supplemented_by));
}
static MakeFileSystemFlags partition_mkfs_flags(const Partition *p) {
MakeFileSystemFlags flags = 0;
if (arg_discard && !p->discarded)
flags |= MKFS_DISCARD;
if (streq(p->format, "erofs") && !DEBUG_LOGGING && !isatty_safe(STDERR_FILENO))
flags |= MKFS_QUIET;
FOREACH_ARRAY(cf, p->copy_files, p->n_copy_files)
if (cf->flags & COPY_PRESERVE_FS_VERITY) {
flags |= MKFS_FS_VERITY;
break;
}
return flags;
}
static int context_notify(
Context *c,
ProgressPhase phase,
const char *object,
unsigned percent) {
int r;
assert(c);
assert(phase >= 0);
assert(phase < _PROGRESS_PHASE_MAX);
/* Send progress information, via sd_notify() and via varlink (if client asked for it by setting "more" flag) */
_cleanup_free_ char *n = NULL;
if (asprintf(&n,
"STATUS=Phase %1$s\n"
"X_SYSTEMD_PHASE=%1$s",
progress_phase_to_string(phase)) < 0)
return log_oom_debug();
if (percent != UINT_MAX)
if (strextendf(&n, "\nX_SYSTEMD_PHASE_PROGRESS=%u", percent) < 0)
return log_oom_debug();
r = sd_notify(/* unset_environment= */ false, n);
if (r < 0)
log_debug_errno(r, "Failed to send sd_notify() progress notification, ignoring: %m");
if (c->link) {
r = sd_varlink_notifybo(
c->link,
JSON_BUILD_PAIR_ENUM("phase", progress_phase_to_string(phase)),
JSON_BUILD_PAIR_STRING_NON_EMPTY("object", object),
JSON_BUILD_PAIR_UNSIGNED_NOT_EQUAL("progress", percent, UINT_MAX));
if (r < 0)
log_debug_errno(r, "Failed to send varlink notify progress notification, ignoring: %m");
r = sd_varlink_flush(c->link);
if (r < 0)
log_debug_errno(r, "Failed to flush varlink notify progress notification, ignoring: %m");
}
return 0;
}
static int partition_read_definition(
Context *c,