HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/shared/condition.c
Git blob: f00f3132e6d322889b5f352db91aafdaba3db7a6
Lines 1001–1655 of 1,655
else {
const char *f;
f = startswith(*i, c->parameter);
found = f && IN_SET(*f, 0, '=');
}
if (found)
return true;
}
return false;
}
static int condition_test_path_exists(Condition *c, char **env) {
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_PATH_EXISTS);
return access(c->parameter, F_OK) >= 0;
}
static int condition_test_path_exists_glob(Condition *c, char **env) {
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_PATH_EXISTS_GLOB);
return glob_exists(c->parameter) > 0;
}
static int condition_test_path_is_directory(Condition *c, char **env) {
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_PATH_IS_DIRECTORY);
return is_dir(c->parameter, true) > 0;
}
static int condition_test_path_is_symbolic_link(Condition *c, char **env) {
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_PATH_IS_SYMBOLIC_LINK);
return is_symlink(c->parameter) > 0;
}
static int condition_test_path_is_mount_point(Condition *c, char **env) {
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_PATH_IS_MOUNT_POINT);
return path_is_mount_point_full(c->parameter, /* root= */ NULL, AT_SYMLINK_FOLLOW) > 0;
}
static int condition_test_path_is_read_write(Condition *c, char **env) {
int r;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_PATH_IS_READ_WRITE);
r = path_is_read_only_fs(c->parameter);
return r <= 0 && r != -ENOENT;
}
static int condition_test_cpufeature(Condition *c, char **env) {
_cleanup_free_ char *cpu_arch = NULL, *feature = NULL;
int r;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_CPU_FEATURE);
r = split_pair(c->parameter, ".", &cpu_arch, &feature);
if (r >= 0) {
r = condition_test_architecture_parameter(cpu_arch);
if (r <= 0)
return r;
} else if (r == -EINVAL) {
feature = strdup(c->parameter);
if (!feature)
return -ENOMEM;
} else
return r;
return has_cpu_with_flag(ascii_strlower(feature));
}
static int condition_test_path_is_encrypted(Condition *c, char **env) {
int r;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_PATH_IS_ENCRYPTED);
r = path_is_encrypted(c->parameter);
if (r < 0 && r != -ENOENT)
log_debug_errno(r, "Failed to determine if '%s' is encrypted: %m", c->parameter);
return r > 0;
}
static int condition_test_path_is_socket(Condition *c, char **env) {
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_PATH_IS_SOCKET);
return is_socket(c->parameter) > 0;
}
static int condition_test_directory_not_empty(Condition *c, char **env) {
int r;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_DIRECTORY_NOT_EMPTY);
r = dir_is_empty(c->parameter, /* ignore_hidden_or_backup= */ true);
return r <= 0 && !IN_SET(r, -ENOENT, -ENOTDIR);
}
static int condition_test_file_not_empty(Condition *c, char **env) {
struct stat st;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_FILE_NOT_EMPTY);
return (stat(c->parameter, &st) >= 0 &&
S_ISREG(st.st_mode) &&
st.st_size > 0);
}
static int condition_test_file_is_executable(Condition *c, char **env) {
struct stat st;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_FILE_IS_EXECUTABLE);
return (stat(c->parameter, &st) >= 0 &&
S_ISREG(st.st_mode) &&
(st.st_mode & 0111));
}
static int condition_test_psi(Condition *c, char **env) {
_cleanup_free_ char *first = NULL, *second = NULL, *third = NULL, *fourth = NULL, *pressure_path = NULL;
const char *p, *value, *pressure_type;
loadavg_t *current, limit;
ResourcePressure pressure;
PressureType preferred_pressure_type = PRESSURE_TYPE_FULL;
int r;
assert(c);
assert(c->parameter);
assert(IN_SET(c->type, CONDITION_MEMORY_PRESSURE, CONDITION_CPU_PRESSURE, CONDITION_IO_PRESSURE));
if (!is_pressure_supported()) {
log_debug("Pressure Stall Information (PSI) is not supported, skipping.");
return 1;
}
pressure_type = c->type == CONDITION_MEMORY_PRESSURE ? "memory" :
c->type == CONDITION_CPU_PRESSURE ? "cpu" :
"io";
p = c->parameter;
r = extract_many_words(&p, ":", 0, &first, &second);
if (r <= 0)
return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse condition parameter %s: %m", c->parameter);
/* If only one parameter is passed, then we look at the global system pressure rather than a specific cgroup. */
if (r == 1) {
/* cpu.pressure 'full' is reported but undefined at system level */
if (c->type == CONDITION_CPU_PRESSURE)
preferred_pressure_type = PRESSURE_TYPE_SOME;
pressure_path = path_join("/proc/pressure", pressure_type);
if (!pressure_path)
return log_oom_debug();
value = first;
} else {
const char *controller = strjoina(pressure_type, ".pressure");
_cleanup_free_ char *slice_path = NULL, *root_scope = NULL;
CGroupMask mask, required_mask;
char *slice, *e;
required_mask = c->type == CONDITION_MEMORY_PRESSURE ? CGROUP_MASK_MEMORY :
c->type == CONDITION_CPU_PRESSURE ? CGROUP_MASK_CPU :
CGROUP_MASK_IO;
slice = strstrip(first);
if (!slice)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse condition parameter %s.", c->parameter);
r = cg_mask_supported(&mask);
if (r < 0)
return log_debug_errno(r, "Failed to get supported cgroup controllers: %m");
if (!FLAGS_SET(mask, required_mask)) {
log_debug("Cgroup %s controller not available, skipping PSI condition check.", pressure_type);
return 1;
}
r = cg_slice_to_path(slice, &slice_path);
if (r < 0)
return log_debug_errno(r, "Cannot determine slice \"%s\" cgroup path: %m", slice);
/* We might be running under the user manager, so get the root path and prefix it accordingly. */
r = cg_pid_get_path(getpid_cached(), &root_scope);
if (r < 0)
return log_debug_errno(r, "Failed to get root cgroup path: %m");
/* Drop init.scope, we want the parent. We could get an empty or / path, but that's fine,
* just skip it in that case. */
e = endswith(root_scope, "/" SPECIAL_INIT_SCOPE);
if (e)
*e = 0;
if (!empty_or_root(root_scope)) {
_cleanup_free_ char *slice_joined = NULL;
slice_joined = path_join(root_scope, slice_path);
if (!slice_joined)
return log_oom_debug();
free_and_replace(slice_path, slice_joined);
}
r = cg_get_path(slice_path, controller, &pressure_path);
if (r < 0)
return log_debug_errno(r, "Error getting cgroup pressure path from %s: %m", slice_path);
value = second;
}
/* If a value including a specific timespan (in the intervals allowed by the kernel),
* parse it, otherwise we assume just a plain percentage that will be checked if it is
* smaller or equal to the current pressure average over 5 minutes. */
r = extract_many_words(&value, "/", 0, &third, &fourth);
if (r <= 0)
return log_debug_errno(r < 0 ? r : SYNTHETIC_ERRNO(EINVAL), "Failed to parse condition parameter %s: %m", c->parameter);
if (r == 1)
current = &pressure.avg300;
else {
const char *timespan;
timespan = skip_leading_chars(fourth, NULL);
if (!timespan)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse condition parameter %s.", c->parameter);
if (startswith(timespan, "10sec"))
current = &pressure.avg10;
else if (startswith(timespan, "1min"))
current = &pressure.avg60;
else if (startswith(timespan, "5min"))
current = &pressure.avg300;
else
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse condition parameter %s.", c->parameter);
}
value = strstrip(third);
if (!value)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse condition parameter %s.", c->parameter);
r = parse_permyriad(value);
if (r < 0)
return log_debug_errno(r, "Failed to parse permyriad: %s", c->parameter);
r = store_loadavg_fixed_point(r / 100LU, r % 100LU, &limit);
if (r < 0)
return log_debug_errno(r, "Failed to parse loadavg: %s", c->parameter);
r = read_resource_pressure(pressure_path, preferred_pressure_type, &pressure);
/* cpu.pressure 'full' was recently added at cgroup level, fall back to 'some' */
if (r == -ENODATA && preferred_pressure_type == PRESSURE_TYPE_FULL)
r = read_resource_pressure(pressure_path, PRESSURE_TYPE_SOME, &pressure);
if (r == -ENOENT) {
/* We already checked that /proc/pressure exists, so this means we were given a cgroup
* that doesn't exist or doesn't exist any longer. */
log_debug("\"%s\" not found, skipping PSI check.", pressure_path);
return 1;
}
if (r < 0)
return log_debug_errno(r, "Error parsing pressure from %s: %m", pressure_path);
return *current <= limit;
}
static int condition_test_kernel_module_loaded(Condition *c, char **env) {
int r;
assert(c);
assert(c->parameter);
assert(c->type == CONDITION_KERNEL_MODULE_LOADED);
/* Checks whether a specific kernel module is fully loaded (i.e. with the full initialization routine
* complete). */
_cleanup_free_ char *normalized = strreplace(c->parameter, "-", "_");
if (!normalized)
return log_oom_debug();
if (!filename_is_valid(normalized)) {
log_debug("Kernel module name '%s' is not valid, hence reporting it to not be loaded.", normalized);
return false;
}
_cleanup_free_ char *p = path_join("/sys/module/", normalized);
if (!p)
return log_oom_debug();
_cleanup_close_ int dir_fd = open(p, O_PATH|O_DIRECTORY|O_CLOEXEC);
if (dir_fd < 0) {
if (errno == ENOENT) {
log_debug_errno(errno, "'%s/' does not exist, kernel module '%s' not loaded.", p, normalized);
return false;
}
return log_debug_errno(errno, "Failed to open directory '%s/': %m", p);
}
_cleanup_free_ char *initstate = NULL;
r = read_virtual_file_at(dir_fd, "initstate", SIZE_MAX, &initstate, NULL);
if (r == -ENOENT) {
log_debug_errno(r, "'%s/' exists but '%s/initstate' does not, kernel module '%s' is built-in, hence loaded.", p, p, normalized);
return true;
}
if (r < 0)
return log_debug_errno(r, "Failed to open '%s/initstate': %m", p);
delete_trailing_chars(initstate, WHITESPACE);
if (!streq(initstate, "live")) {
log_debug("Kernel module '%s' is reported as '%s', hence not loaded.", normalized, initstate);
return false;
}
log_debug("Kernel module '%s' detected as loaded.", normalized);
return true;
}
typedef int (*condition_test_func_t)(Condition *c, char **env);
static int condition_test_impl(Condition *c, char **env, const condition_test_func_t table[]) {
int r, b;
assert(c);
assert(c->type >= 0);
assert(c->type < _CONDITION_TYPE_MAX);
assert(table);
assert(table[c->type]);
r = table[c->type](c, env);
if (r < 0) {
c->result = CONDITION_ERROR;
return r;
}
b = (r > 0) == !c->negate;
c->result = b ? CONDITION_SUCCEEDED : CONDITION_FAILED;
return b;
}
static int condition_test_net(Condition *c, char **env) {
static const condition_test_func_t table_net[_CONDITION_TYPE_MAX] = {
[CONDITION_KERNEL_COMMAND_LINE] = condition_test_kernel_command_line,
[CONDITION_VERSION] = condition_test_version,
[CONDITION_CREDENTIAL] = condition_test_credential,
[CONDITION_VIRTUALIZATION] = condition_test_virtualization,
[CONDITION_HOST] = condition_test_host,
[CONDITION_ARCHITECTURE] = condition_test_architecture,
[CONDITION_FIRMWARE] = condition_test_firmware,
[CONDITION_MACHINE_TAG] = condition_test_machine_tag,
};
return condition_test_impl(c, env, table_net);
}
int condition_test(Condition *c, char **env) {
static const condition_test_func_t table[_CONDITION_TYPE_MAX] = {
[CONDITION_PATH_EXISTS] = condition_test_path_exists,
[CONDITION_PATH_EXISTS_GLOB] = condition_test_path_exists_glob,
[CONDITION_PATH_IS_DIRECTORY] = condition_test_path_is_directory,
[CONDITION_PATH_IS_SYMBOLIC_LINK] = condition_test_path_is_symbolic_link,
[CONDITION_PATH_IS_MOUNT_POINT] = condition_test_path_is_mount_point,
[CONDITION_PATH_IS_READ_WRITE] = condition_test_path_is_read_write,
[CONDITION_PATH_IS_ENCRYPTED] = condition_test_path_is_encrypted,
[CONDITION_PATH_IS_SOCKET] = condition_test_path_is_socket,
[CONDITION_DIRECTORY_NOT_EMPTY] = condition_test_directory_not_empty,
[CONDITION_FILE_NOT_EMPTY] = condition_test_file_not_empty,
[CONDITION_FILE_IS_EXECUTABLE] = condition_test_file_is_executable,
[CONDITION_KERNEL_COMMAND_LINE] = condition_test_kernel_command_line,
[CONDITION_VERSION] = condition_test_version,
[CONDITION_CREDENTIAL] = condition_test_credential,
[CONDITION_VIRTUALIZATION] = condition_test_virtualization,
[CONDITION_SECURITY] = condition_test_security,
[CONDITION_CAPABILITY] = condition_test_capability,
[CONDITION_HOST] = condition_test_host,
[CONDITION_FRACTION] = condition_test_fraction,
[CONDITION_AC_POWER] = condition_test_ac_power,
[CONDITION_ARCHITECTURE] = condition_test_architecture,
[CONDITION_FIRMWARE] = condition_test_firmware,
[CONDITION_NEEDS_UPDATE] = condition_test_needs_update,
[CONDITION_FIRST_BOOT] = condition_test_first_boot,
[CONDITION_USER] = condition_test_user,
[CONDITION_GROUP] = condition_test_group,
[CONDITION_CONTROL_GROUP_CONTROLLER] = condition_test_control_group_controller,
[CONDITION_CPUS] = condition_test_cpus,
[CONDITION_MEMORY] = condition_test_memory,
[CONDITION_ENVIRONMENT] = condition_test_environment,
[CONDITION_CPU_FEATURE] = condition_test_cpufeature,
[CONDITION_OS_RELEASE] = condition_test_osrelease,
[CONDITION_MACHINE_TAG] = condition_test_machine_tag,
[CONDITION_MEMORY_PRESSURE] = condition_test_psi,
[CONDITION_CPU_PRESSURE] = condition_test_psi,
[CONDITION_IO_PRESSURE] = condition_test_psi,
[CONDITION_KERNEL_MODULE_LOADED] = condition_test_kernel_module_loaded,
};
return condition_test_impl(c, env, table);
}
static int condition_test_list_impl(
Condition *first,
char **env,
condition_to_string_t to_string,
condition_test_logger_t logger,
condition_test_func_t tester,
void *userdata) {
int non_trigger_error = 0, trigger_error = 0;
bool has_trigger = false, trigger_success = false;
/* If the condition list is empty, then it is true */
if (!first)
return true;
/* Otherwise, if all of the non-trigger conditions apply and
* if any of the trigger conditions apply (unless there are
* none) we return true */
LIST_FOREACH(conditions, c, first) {
int r;
has_trigger = has_trigger || c->trigger;
r = tester(c, env);
if (logger) {
if (r < 0)
logger(userdata, LOG_WARNING, r, PROJECT_FILE, __LINE__, __func__,
"Couldn't determine result for %s=%s%s%s: %m",
to_string(c->type),
c->trigger ? "|" : "",
c->negate ? "!" : "",
c->parameter);
else
logger(userdata, LOG_DEBUG, 0, PROJECT_FILE, __LINE__, __func__,
"%s=%s%s%s %s.",
to_string(c->type),
c->trigger ? "|" : "",
c->negate ? "!" : "",
c->parameter,
condition_result_to_string(c->result));
}
if (r < 0) {
if (c->trigger)
RET_GATHER(trigger_error, r);
else
RET_GATHER(non_trigger_error, r);
continue;
}
if (!c->trigger && r == 0)
return false;
if (c->trigger && r > 0)
trigger_success = true;
}
if (!has_trigger || trigger_success)
return non_trigger_error < 0 ? non_trigger_error : true;
return trigger_error < 0 ? trigger_error : false;
}
bool condition_test_list_net(
Condition *first,
char **env,
condition_to_string_t to_string,
condition_test_logger_t logger,
void *userdata) {
return condition_test_list_impl(first, env, to_string, logger, condition_test_net, userdata) > 0;
}
int condition_test_list(
Condition *first,
char **env,
condition_to_string_t to_string,
condition_test_logger_t logger,
void *userdata) {
return condition_test_list_impl(first, env, to_string, logger, condition_test, userdata);
}
void condition_dump(Condition *c, FILE *f, const char *prefix, condition_to_string_t to_string) {
assert(c);
assert(f);
assert(to_string);
prefix = strempty(prefix);
fprintf(f,
"%s\t%s: %s%s%s %s\n",
prefix,
to_string(c->type),
c->trigger ? "|" : "",
c->negate ? "!" : "",
c->parameter,
condition_result_to_string(c->result));
}
void condition_dump_list(Condition *first, FILE *f, const char *prefix, condition_to_string_t to_string) {
LIST_FOREACH(conditions, c, first)
condition_dump(c, f, prefix, to_string);
}
static const char* const _condition_type_table[_CONDITION_TYPE_MAX] = {
[CONDITION_ARCHITECTURE] = "ConditionArchitecture",
[CONDITION_FIRMWARE] = "ConditionFirmware",
[CONDITION_VIRTUALIZATION] = "ConditionVirtualization",
[CONDITION_HOST] = "ConditionHost",
[CONDITION_FRACTION] = "ConditionFraction",
[CONDITION_KERNEL_COMMAND_LINE] = "ConditionKernelCommandLine",
[CONDITION_VERSION] = "ConditionVersion",
[CONDITION_CREDENTIAL] = "ConditionCredential",
[CONDITION_SECURITY] = "ConditionSecurity",
[CONDITION_CAPABILITY] = "ConditionCapability",
[CONDITION_AC_POWER] = "ConditionACPower",
[CONDITION_NEEDS_UPDATE] = "ConditionNeedsUpdate",
[CONDITION_FIRST_BOOT] = "ConditionFirstBoot",
[CONDITION_PATH_EXISTS] = "ConditionPathExists",
[CONDITION_PATH_EXISTS_GLOB] = "ConditionPathExistsGlob",
[CONDITION_PATH_IS_DIRECTORY] = "ConditionPathIsDirectory",
[CONDITION_PATH_IS_SYMBOLIC_LINK] = "ConditionPathIsSymbolicLink",
[CONDITION_PATH_IS_MOUNT_POINT] = "ConditionPathIsMountPoint",
[CONDITION_PATH_IS_READ_WRITE] = "ConditionPathIsReadWrite",
[CONDITION_PATH_IS_ENCRYPTED] = "ConditionPathIsEncrypted",
[CONDITION_PATH_IS_SOCKET] = "ConditionPathIsSocket",
[CONDITION_DIRECTORY_NOT_EMPTY] = "ConditionDirectoryNotEmpty",
[CONDITION_FILE_NOT_EMPTY] = "ConditionFileNotEmpty",
[CONDITION_FILE_IS_EXECUTABLE] = "ConditionFileIsExecutable",
[CONDITION_USER] = "ConditionUser",
[CONDITION_GROUP] = "ConditionGroup",
[CONDITION_CONTROL_GROUP_CONTROLLER] = "ConditionControlGroupController",
[CONDITION_CPUS] = "ConditionCPUs",
[CONDITION_MEMORY] = "ConditionMemory",
[CONDITION_ENVIRONMENT] = "ConditionEnvironment",
[CONDITION_CPU_FEATURE] = "ConditionCPUFeature",
[CONDITION_OS_RELEASE] = "ConditionOSRelease",
[CONDITION_MACHINE_TAG] = "ConditionMachineTag",
[CONDITION_MEMORY_PRESSURE] = "ConditionMemoryPressure",
[CONDITION_CPU_PRESSURE] = "ConditionCPUPressure",
[CONDITION_IO_PRESSURE] = "ConditionIOPressure",
[CONDITION_KERNEL_MODULE_LOADED] = "ConditionKernelModuleLoaded",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP(_condition_type, ConditionType);
const char* condition_type_to_string(ConditionType t) {
return _condition_type_to_string(t);
}
ConditionType condition_type_from_string(const char *s) {
/* for backward compatibility */
if (streq_ptr(s, "ConditionKernelVersion"))
return CONDITION_VERSION;
return _condition_type_from_string(s);
}
void condition_types_list(void) {
DUMP_STRING_TABLE(_condition_type, ConditionType, _CONDITION_TYPE_MAX);
}
static const char* const _assert_type_table[_CONDITION_TYPE_MAX] = {
[CONDITION_ARCHITECTURE] = "AssertArchitecture",
[CONDITION_FIRMWARE] = "AssertFirmware",
[CONDITION_VIRTUALIZATION] = "AssertVirtualization",
[CONDITION_HOST] = "AssertHost",
[CONDITION_FRACTION] = "AssertFraction",
[CONDITION_KERNEL_COMMAND_LINE] = "AssertKernelCommandLine",
[CONDITION_VERSION] = "AssertVersion",
[CONDITION_CREDENTIAL] = "AssertCredential",
[CONDITION_SECURITY] = "AssertSecurity",
[CONDITION_CAPABILITY] = "AssertCapability",
[CONDITION_AC_POWER] = "AssertACPower",
[CONDITION_NEEDS_UPDATE] = "AssertNeedsUpdate",
[CONDITION_FIRST_BOOT] = "AssertFirstBoot",
[CONDITION_PATH_EXISTS] = "AssertPathExists",
[CONDITION_PATH_EXISTS_GLOB] = "AssertPathExistsGlob",
[CONDITION_PATH_IS_DIRECTORY] = "AssertPathIsDirectory",
[CONDITION_PATH_IS_SYMBOLIC_LINK] = "AssertPathIsSymbolicLink",
[CONDITION_PATH_IS_MOUNT_POINT] = "AssertPathIsMountPoint",
[CONDITION_PATH_IS_READ_WRITE] = "AssertPathIsReadWrite",
[CONDITION_PATH_IS_ENCRYPTED] = "AssertPathIsEncrypted",
[CONDITION_PATH_IS_SOCKET] = "AssertPathIsSocket",
[CONDITION_DIRECTORY_NOT_EMPTY] = "AssertDirectoryNotEmpty",
[CONDITION_FILE_NOT_EMPTY] = "AssertFileNotEmpty",
[CONDITION_FILE_IS_EXECUTABLE] = "AssertFileIsExecutable",
[CONDITION_USER] = "AssertUser",
[CONDITION_GROUP] = "AssertGroup",
[CONDITION_CONTROL_GROUP_CONTROLLER] = "AssertControlGroupController",
[CONDITION_CPUS] = "AssertCPUs",
[CONDITION_MEMORY] = "AssertMemory",
[CONDITION_ENVIRONMENT] = "AssertEnvironment",
[CONDITION_CPU_FEATURE] = "AssertCPUFeature",
[CONDITION_OS_RELEASE] = "AssertOSRelease",
[CONDITION_MACHINE_TAG] = "AssertMachineTag",
[CONDITION_MEMORY_PRESSURE] = "AssertMemoryPressure",
[CONDITION_CPU_PRESSURE] = "AssertCPUPressure",
[CONDITION_IO_PRESSURE] = "AssertIOPressure",
[CONDITION_KERNEL_MODULE_LOADED] = "AssertKernelModuleLoaded",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP(_assert_type, ConditionType);
const char* assert_type_to_string(ConditionType t) {
return _assert_type_to_string(t);
}
ConditionType assert_type_from_string(const char *s) {
/* for backward compatibility */
if (streq_ptr(s, "AssertKernelVersion"))
return CONDITION_VERSION;
return _assert_type_from_string(s);
}
void assert_types_list(void) {
DUMP_STRING_TABLE(_assert_type, ConditionType, _CONDITION_TYPE_MAX);
}
static const char* const condition_result_table[_CONDITION_RESULT_MAX] = {
[CONDITION_UNTESTED] = "untested",
[CONDITION_SUCCEEDED] = "succeeded",
[CONDITION_FAILED] = "failed",
[CONDITION_ERROR] = "error",
};
DEFINE_STRING_TABLE_LOOKUP(condition_result, ConditionResult);