HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/condition.c

63,130 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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);