ARCHITECTURE_ARC,
ARCHITECTURE_ARC_BE,
_ARCHITECTURE_MAX,
- _ARCHITECTURE_INVALID = -1
+ _ARCHITECTURE_INVALID = -EINVAL,
};
int uname_architecture(void);
CGROUP_CONTROLLER_BPF_DEVICES,
_CGROUP_CONTROLLER_MAX,
- _CGROUP_CONTROLLER_INVALID = -1,
+ _CGROUP_CONTROLLER_INVALID = -EINVAL,
} CGroupController;
#define CGROUP_CONTROLLER_TO_MASK(c) (1U << (c))
CGROUP_IO_WIOPS_MAX,
_CGROUP_IO_LIMIT_TYPE_MAX,
- _CGROUP_IO_LIMIT_TYPE_INVALID = -1
+ _CGROUP_IO_LIMIT_TYPE_INVALID = -EINVAL,
} CGroupIOLimitType;
extern const uint64_t cgroup_io_limit_defaults[_CGROUP_IO_LIMIT_TYPE_MAX];
MANAGED_OOM_AUTO,
MANAGED_OOM_KILL,
_MANAGED_OOM_MODE_MAX,
- _MANAGED_OOM_MODE_INVALID = -1,
+ _MANAGED_OOM_MODE_INVALID = -EINVAL,
} ManagedOOMMode;
const char* managed_oom_mode_to_string(ManagedOOMMode m) _const_;
VARIABLE_LC_MEASUREMENT,
VARIABLE_LC_IDENTIFICATION,
_VARIABLE_LC_MAX,
- _VARIABLE_LC_INVALID = -1
+ _VARIABLE_LC_INVALID = -EINVAL,
} LocaleVariable;
int get_locales(char ***l);
LOG_TARGET_AUTO, /* console if stderr is not journal, JOURNAL_OR_KMSG otherwise */
LOG_TARGET_NULL,
_LOG_TARGET_MAX,
- _LOG_TARGET_INVALID = -1
+ _LOG_TARGET_INVALID = -EINVAL,
} LogTarget;
/* Note to readers: << and >> have lower precedence than & and | */
SMACK_ATTR_IPIN,
SMACK_ATTR_IPOUT,
_SMACK_ATTR_MAX,
- _SMACK_ATTR_INVALID = -1,
+ _SMACK_ATTR_INVALID = -EINVAL,
} SmackAttr;
bool mac_smack_use(void);
SOCKET_ADDRESS_BOTH,
SOCKET_ADDRESS_IPV6_ONLY,
_SOCKET_ADDRESS_BIND_IPV6_ONLY_MAX,
- _SOCKET_ADDRESS_BIND_IPV6_ONLY_INVALID = -1
+ _SOCKET_ADDRESS_BIND_IPV6_ONLY_INVALID = -EINVAL,
} SocketAddressBindIPv6Only;
#define socket_address_family(a) ((a)->sockaddr.sa.sa_family)
/* Only 256 colors. */
COLOR_256 = 256,
- _COLOR_INVALID = -1,
+ _COLOR_INVALID = -EINVAL,
} ColorMode;
int acquire_terminal(const char *name, AcquireTerminalFlags flags, usec_t timeout);
TIMESTAMP_UTC,
TIMESTAMP_US_UTC,
_TIMESTAMP_STYLE_MAX,
- _TIMESTAMP_STYLE_INVALID = -1,
+ _TIMESTAMP_STYLE_INVALID = -EINVAL,
} TimestampStyle;
#define USEC_INFINITY ((usec_t) UINT64_MAX)
UNIT_SLICE,
UNIT_SCOPE,
_UNIT_TYPE_MAX,
- _UNIT_TYPE_INVALID = -1
+ _UNIT_TYPE_INVALID = -EINVAL,
} UnitType;
typedef enum UnitLoadState {
UNIT_MERGED,
UNIT_MASKED,
_UNIT_LOAD_STATE_MAX,
- _UNIT_LOAD_STATE_INVALID = -1
+ _UNIT_LOAD_STATE_INVALID = -EINVAL,
} UnitLoadState;
typedef enum UnitActiveState {
UNIT_DEACTIVATING,
UNIT_MAINTENANCE,
_UNIT_ACTIVE_STATE_MAX,
- _UNIT_ACTIVE_STATE_INVALID = -1
+ _UNIT_ACTIVE_STATE_INVALID = -EINVAL,
} UnitActiveState;
typedef enum FreezerState {
FREEZER_FROZEN,
FREEZER_THAWING,
_FREEZER_STATE_MAX,
- _FREEZER_STATE_INVALID = -1
+ _FREEZER_STATE_INVALID = -EINVAL,
} FreezerState;
typedef enum AutomountState {
AUTOMOUNT_RUNNING,
AUTOMOUNT_FAILED,
_AUTOMOUNT_STATE_MAX,
- _AUTOMOUNT_STATE_INVALID = -1
+ _AUTOMOUNT_STATE_INVALID = -EINVAL,
} AutomountState;
/* We simply watch devices, we cannot plug/unplug them. That
DEVICE_TENTATIVE, /* mounted or swapped, but not (yet) announced by udev */
DEVICE_PLUGGED, /* announced by udev */
_DEVICE_STATE_MAX,
- _DEVICE_STATE_INVALID = -1
+ _DEVICE_STATE_INVALID = -EINVAL,
} DeviceState;
typedef enum MountState {
MOUNT_FAILED,
MOUNT_CLEANING,
_MOUNT_STATE_MAX,
- _MOUNT_STATE_INVALID = -1
+ _MOUNT_STATE_INVALID = -EINVAL,
} MountState;
typedef enum PathState {
PATH_RUNNING,
PATH_FAILED,
_PATH_STATE_MAX,
- _PATH_STATE_INVALID = -1
+ _PATH_STATE_INVALID = -EINVAL,
} PathState;
typedef enum ScopeState {
SCOPE_STOP_SIGKILL,
SCOPE_FAILED,
_SCOPE_STATE_MAX,
- _SCOPE_STATE_INVALID = -1
+ _SCOPE_STATE_INVALID = -EINVAL,
} ScopeState;
typedef enum ServiceState {
SERVICE_AUTO_RESTART,
SERVICE_CLEANING,
_SERVICE_STATE_MAX,
- _SERVICE_STATE_INVALID = -1
+ _SERVICE_STATE_INVALID = -EINVAL,
} ServiceState;
typedef enum SliceState {
SLICE_DEAD,
SLICE_ACTIVE,
_SLICE_STATE_MAX,
- _SLICE_STATE_INVALID = -1
+ _SLICE_STATE_INVALID = -EINVAL,
} SliceState;
typedef enum SocketState {
SOCKET_FAILED,
SOCKET_CLEANING,
_SOCKET_STATE_MAX,
- _SOCKET_STATE_INVALID = -1
+ _SOCKET_STATE_INVALID = -EINVAL,
} SocketState;
typedef enum SwapState {
SWAP_FAILED,
SWAP_CLEANING,
_SWAP_STATE_MAX,
- _SWAP_STATE_INVALID = -1
+ _SWAP_STATE_INVALID = -EINVAL,
} SwapState;
typedef enum TargetState {
TARGET_DEAD,
TARGET_ACTIVE,
_TARGET_STATE_MAX,
- _TARGET_STATE_INVALID = -1
+ _TARGET_STATE_INVALID = -EINVAL,
} TargetState;
typedef enum TimerState {
TIMER_ELAPSED,
TIMER_FAILED,
_TIMER_STATE_MAX,
- _TIMER_STATE_INVALID = -1
+ _TIMER_STATE_INVALID = -EINVAL,
} TimerState;
typedef enum UnitDependency {
UNIT_REFERENCED_BY,
_UNIT_DEPENDENCY_MAX,
- _UNIT_DEPENDENCY_INVALID = -1
+ _UNIT_DEPENDENCY_INVALID = -EINVAL,
} UnitDependency;
typedef enum NotifyAccess {
NOTIFY_MAIN,
NOTIFY_EXEC,
_NOTIFY_ACCESS_MAX,
- _NOTIFY_ACCESS_INVALID = -1
+ _NOTIFY_ACCESS_INVALID = -EINVAL,
} NotifyAccess;
char *unit_dbus_path_from_name(const char *name);
UNIT_FILE_TRANSIENT,
UNIT_FILE_BAD,
_UNIT_FILE_STATE_MAX,
- _UNIT_FILE_STATE_INVALID = -1
+ _UNIT_FILE_STATE_INVALID = -EINVAL,
};
enum UnitFileScope {
UNIT_FILE_GLOBAL,
UNIT_FILE_USER,
_UNIT_FILE_SCOPE_MAX,
- _UNIT_FILE_SCOPE_INVALID = -1
+ _UNIT_FILE_SCOPE_INVALID = -EINVAL,
};
bool unit_type_may_alias(UnitType type) _const_;
UNIT_NAME_TEMPLATE = 1 << 1, /* Allow foo@.service */
UNIT_NAME_INSTANCE = 1 << 2, /* Allow foo@bar.service */
UNIT_NAME_ANY = UNIT_NAME_PLAIN|UNIT_NAME_TEMPLATE|UNIT_NAME_INSTANCE,
- _UNIT_NAME_INVALID = -1,
+ _UNIT_NAME_INVALID = -EINVAL,
} UnitNameFlags;
bool unit_name_is_valid(const char *n, UnitNameFlags flags) _pure_;
VIRTUALIZATION_CONTAINER_LAST = VIRTUALIZATION_CONTAINER_OTHER,
_VIRTUALIZATION_MAX,
- _VIRTUALIZATION_INVALID = -1
+ _VIRTUALIZATION_INVALID = -EINVAL,
};
static inline bool VIRTUALIZATION_IS_VM(int x) {
#pragma once
#include <efi.h>
+#include <errno.h>
typedef enum RandomSeedMode {
RANDOM_SEED_OFF,
RANDOM_SEED_WITH_SYSTEM_TOKEN,
RANDOM_SEED_ALWAYS,
_RANDOM_SEED_MODE_MAX,
- _RANDOM_SEED_MODE_INVALID = -1,
+ _RANDOM_SEED_MODE_INVALID = -EINVAL,
} RandomSeedMode;
EFI_STATUS process_random_seed(EFI_FILE *root_dir, RandomSeedMode mode);
AUTOMOUNT_FAILURE_START_LIMIT_HIT,
AUTOMOUNT_FAILURE_MOUNT_START_LIMIT_HIT,
_AUTOMOUNT_RESULT_MAX,
- _AUTOMOUNT_RESULT_INVALID = -1
+ _AUTOMOUNT_RESULT_INVALID = -EINVAL,
} AutomountResult;
struct Automount {
CGROUP_DEVICE_POLICY_STRICT,
_CGROUP_DEVICE_POLICY_MAX,
- _CGROUP_DEVICE_POLICY_INVALID = -1
+ _CGROUP_DEVICE_POLICY_INVALID = -EINVAL,
} CGroupDevicePolicy;
typedef enum FreezerAction {
FREEZER_THAW,
_FREEZER_ACTION_MAX,
- _FREEZER_ACTION_INVALID = -1,
+ _FREEZER_ACTION_INVALID = -EINVAL,
} FreezerAction;
struct CGroupDeviceAllow {
CGROUP_IP_EGRESS_BYTES,
CGROUP_IP_EGRESS_PACKETS,
_CGROUP_IP_ACCOUNTING_METRIC_MAX,
- _CGROUP_IP_ACCOUNTING_METRIC_INVALID = -1,
+ _CGROUP_IP_ACCOUNTING_METRIC_INVALID = -EINVAL,
} CGroupIPAccountingMetric;
/* Used when querying IO accounting data */
CGROUP_IO_READ_OPERATIONS,
CGROUP_IO_WRITE_OPERATIONS,
_CGROUP_IO_ACCOUNTING_METRIC_MAX,
- _CGROUP_IO_ACCOUNTING_METRIC_INVALID = -1,
+ _CGROUP_IO_ACCOUNTING_METRIC_INVALID = -EINVAL,
} CGroupIOAccountingMetric;
typedef struct Unit Unit;
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include <errno.h>
+
typedef enum EmergencyAction {
EMERGENCY_ACTION_NONE,
EMERGENCY_ACTION_REBOOT,
_EMERGENCY_ACTION_FIRST_USER_ACTION = EMERGENCY_ACTION_EXIT,
EMERGENCY_ACTION_EXIT_FORCE,
_EMERGENCY_ACTION_MAX,
- _EMERGENCY_ACTION_INVALID = -1
+ _EMERGENCY_ACTION_INVALID = -EINVAL,
} EmergencyAction;
typedef enum EmergencyActionFlags {
EXEC_UTMP_LOGIN,
EXEC_UTMP_USER,
_EXEC_UTMP_MODE_MAX,
- _EXEC_UTMP_MODE_INVALID = -1
+ _EXEC_UTMP_MODE_INVALID = -EINVAL,
} ExecUtmpMode;
typedef enum ExecInput {
EXEC_INPUT_DATA,
EXEC_INPUT_FILE,
_EXEC_INPUT_MAX,
- _EXEC_INPUT_INVALID = -1
+ _EXEC_INPUT_INVALID = -EINVAL,
} ExecInput;
typedef enum ExecOutput {
EXEC_OUTPUT_FILE_APPEND,
EXEC_OUTPUT_FILE_TRUNCATE,
_EXEC_OUTPUT_MAX,
- _EXEC_OUTPUT_INVALID = -1
+ _EXEC_OUTPUT_INVALID = -EINVAL,
} ExecOutput;
typedef enum ExecPreserveMode {
EXEC_PRESERVE_YES,
EXEC_PRESERVE_RESTART,
_EXEC_PRESERVE_MODE_MAX,
- _EXEC_PRESERVE_MODE_INVALID = -1
+ _EXEC_PRESERVE_MODE_INVALID = -EINVAL,
} ExecPreserveMode;
typedef enum ExecKeyringMode {
EXEC_KEYRING_PRIVATE,
EXEC_KEYRING_SHARED,
_EXEC_KEYRING_MODE_MAX,
- _EXEC_KEYRING_MODE_INVALID = -1,
+ _EXEC_KEYRING_MODE_INVALID = -EINVAL,
} ExecKeyringMode;
/* Contains start and exit information about an executed command. */
EXEC_DIRECTORY_LOGS,
EXEC_DIRECTORY_CONFIGURATION,
_EXEC_DIRECTORY_TYPE_MAX,
- _EXEC_DIRECTORY_TYPE_INVALID = -1,
+ _EXEC_DIRECTORY_TYPE_INVALID = -EINVAL,
} ExecDirectoryType;
typedef struct ExecDirectory {
EXEC_CLEAN_CONFIGURATION = 1U << EXEC_DIRECTORY_CONFIGURATION,
EXEC_CLEAN_NONE = 0,
EXEC_CLEAN_ALL = (1U << _EXEC_DIRECTORY_TYPE_MAX) - 1,
- _EXEC_CLEAN_MASK_INVALID = -1,
+ _EXEC_CLEAN_MASK_INVALID = -EINVAL,
} ExecCleanMask;
/* A credential configured with SetCredential= */
JOB_RELOAD_OR_START, /* if running, reload, otherwise start */
_JOB_TYPE_MAX,
- _JOB_TYPE_INVALID = -1
+ _JOB_TYPE_INVALID = -EINVAL,
};
enum JobState {
JOB_WAITING,
JOB_RUNNING,
_JOB_STATE_MAX,
- _JOB_STATE_INVALID = -1
+ _JOB_STATE_INVALID = -EINVAL,
};
enum JobMode {
JOB_IGNORE_REQUIREMENTS, /* Ignore requirement dependencies */
JOB_TRIGGERING, /* Adds TRIGGERED_BY dependencies to the same transaction */
_JOB_MODE_MAX,
- _JOB_MODE_INVALID = -1
+ _JOB_MODE_INVALID = -EINVAL,
};
enum JobResult {
JOB_COLLECTED, /* Job was garbage collected, since nothing needed it anymore */
JOB_ONCE, /* Unit was started before, and hence can't be started again */
_JOB_RESULT_MAX,
- _JOB_RESULT_INVALID = -1
+ _JOB_RESULT_INVALID = -EINVAL,
};
#include "unit.h"
KILL_MIXED,
KILL_NONE,
_KILL_MODE_MAX,
- _KILL_MODE_INVALID = -1
+ _KILL_MODE_INVALID = -EINVAL,
} KillMode;
struct KillContext {
KILL_CONTROL_FAIL,
KILL_ALL_FAIL,
_KILL_WHO_MAX,
- _KILL_WHO_INVALID = -1
+ _KILL_WHO_INVALID = -EINVAL,
} KillWho;
void kill_context_init(KillContext *c);
MANAGER_MAINTENANCE,
MANAGER_STOPPING,
_MANAGER_STATE_MAX,
- _MANAGER_STATE_INVALID = -1
+ _MANAGER_STATE_INVALID = -EINVAL,
} ManagerState;
typedef enum ManagerObjective {
MANAGER_KEXEC,
MANAGER_SWITCH_ROOT,
_MANAGER_OBJECTIVE_MAX,
- _MANAGER_OBJECTIVE_INVALID = -1
+ _MANAGER_OBJECTIVE_INVALID = -EINVAL,
} ManagerObjective;
typedef enum StatusType {
OOM_STOP, /* The kernel kills the process it wants to kill, and we stop the unit */
OOM_KILL, /* The kernel kills the process it wants to kill, and all others in the unit, and we stop the unit */
_OOM_POLICY_MAX,
- _OOM_POLICY_INVALID = -1
+ _OOM_POLICY_INVALID = -EINVAL,
} OOMPolicy;
/* Notes:
MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_START,
MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_FINISH,
_MANAGER_TIMESTAMP_MAX,
- _MANAGER_TIMESTAMP_INVALID = -1,
+ _MANAGER_TIMESTAMP_INVALID = -EINVAL,
} ManagerTimestamp;
typedef enum WatchdogType {
MOUNT_EXEC_UNMOUNT,
MOUNT_EXEC_REMOUNT,
_MOUNT_EXEC_COMMAND_MAX,
- _MOUNT_EXEC_COMMAND_INVALID = -1
+ _MOUNT_EXEC_COMMAND_INVALID = -EINVAL,
} MountExecCommand;
typedef enum MountResult {
MOUNT_FAILURE_START_LIMIT_HIT,
MOUNT_FAILURE_PROTOCOL,
_MOUNT_RESULT_MAX,
- _MOUNT_RESULT_INVALID = -1
+ _MOUNT_RESULT_INVALID = -EINVAL,
} MountResult;
typedef struct MountParameters {
PROTECT_HOME_READ_ONLY,
PROTECT_HOME_TMPFS,
_PROTECT_HOME_MAX,
- _PROTECT_HOME_INVALID = -1
+ _PROTECT_HOME_INVALID = -EINVAL,
} ProtectHome;
typedef enum NamespaceType {
NAMESPACE_PID,
NAMESPACE_NET,
_NAMESPACE_TYPE_MAX,
- _NAMESPACE_TYPE_INVALID = -1,
+ _NAMESPACE_TYPE_INVALID = -EINVAL,
} NamespaceType;
typedef enum ProtectSystem {
PROTECT_SYSTEM_FULL,
PROTECT_SYSTEM_STRICT,
_PROTECT_SYSTEM_MAX,
- _PROTECT_SYSTEM_INVALID = -1
+ _PROTECT_SYSTEM_INVALID = -EINVAL,
} ProtectSystem;
typedef enum ProtectProc {
PROTECT_PROC_INVISIBLE, /* hidepid=invisible */
PROTECT_PROC_PTRACEABLE, /* hidepid=ptraceable */
_PROTECT_PROC_MAX,
- _PROTECT_PROC_INVALID = -1,
+ _PROTECT_PROC_INVALID = -EINVAL,
} ProtectProc;
typedef enum ProcSubset {
PROC_SUBSET_ALL,
PROC_SUBSET_PID, /* subset=pid */
_PROC_SUBSET_MAX,
- _PROC_SUBSET_INVALID = -1,
+ _PROC_SUBSET_INVALID = -EINVAL,
} ProcSubset;
struct NamespaceInfo {
PATH_CHANGED,
PATH_MODIFIED,
_PATH_TYPE_MAX,
- _PATH_TYPE_INVALID = -1
+ _PATH_TYPE_INVALID = -EINVAL,
} PathType;
typedef struct PathSpec {
PATH_FAILURE_START_LIMIT_HIT,
PATH_FAILURE_UNIT_START_LIMIT_HIT,
_PATH_RESULT_MAX,
- _PATH_RESULT_INVALID = -1
+ _PATH_RESULT_INVALID = -EINVAL,
} PathResult;
struct Path {
SCOPE_FAILURE_RESOURCES,
SCOPE_FAILURE_TIMEOUT,
_SCOPE_RESULT_MAX,
- _SCOPE_RESULT_INVALID = -1
+ _SCOPE_RESULT_INVALID = -EINVAL,
} ScopeResult;
struct Scope {
STATE_EXEC_COMMAND_PATH,
STATE_EXEC_COMMAND_ARGS,
_STATE_EXEC_COMMAND_MAX,
- _STATE_EXEC_COMMAND_INVALID = -1,
+ _STATE_EXEC_COMMAND_INVALID = -EINVAL,
} state;
assert(s);
SERVICE_RESTART_ON_ABORT,
SERVICE_RESTART_ALWAYS,
_SERVICE_RESTART_MAX,
- _SERVICE_RESTART_INVALID = -1
+ _SERVICE_RESTART_INVALID = -EINVAL,
} ServiceRestart;
typedef enum ServiceType {
SERVICE_IDLE, /* much like simple, but delay exec() until all jobs are dispatched. */
SERVICE_EXEC, /* we fork and wait until we execute exec() (this means our own setup is waited for) */
_SERVICE_TYPE_MAX,
- _SERVICE_TYPE_INVALID = -1
+ _SERVICE_TYPE_INVALID = -EINVAL,
} ServiceType;
typedef enum ServiceExecCommand {
SERVICE_EXEC_STOP,
SERVICE_EXEC_STOP_POST,
_SERVICE_EXEC_COMMAND_MAX,
- _SERVICE_EXEC_COMMAND_INVALID = -1
+ _SERVICE_EXEC_COMMAND_INVALID = -EINVAL,
} ServiceExecCommand;
typedef enum NotifyState {
NOTIFY_RELOADING,
NOTIFY_STOPPING,
_NOTIFY_STATE_MAX,
- _NOTIFY_STATE_INVALID = -1
+ _NOTIFY_STATE_INVALID = -EINVAL,
} NotifyState;
/* The values of this enum are referenced in man/systemd.exec.xml and src/shared/bus-unit-util.c.
SERVICE_FAILURE_OOM_KILL,
SERVICE_SKIP_CONDITION,
_SERVICE_RESULT_MAX,
- _SERVICE_RESULT_INVALID = -1
+ _SERVICE_RESULT_INVALID = -EINVAL,
} ServiceResult;
typedef enum ServiceTimeoutFailureMode {
SERVICE_TIMEOUT_ABORT,
SERVICE_TIMEOUT_KILL,
_SERVICE_TIMEOUT_FAILURE_MODE_MAX,
- _SERVICE_TIMEOUT_FAILURE_MODE_INVALID = -1
+ _SERVICE_TIMEOUT_FAILURE_MODE_INVALID = -EINVAL,
} ServiceTimeoutFailureMode;
struct ServiceFDStore {
SHOW_STATUS_TEMPORARY, /* enabled temporarily, may flip back to _AUTO */
SHOW_STATUS_YES, /* printing of status is enabled */
_SHOW_STATUS_MAX,
- _SHOW_STATUS_INVALID = -1,
+ _SHOW_STATUS_INVALID = -EINVAL,
} ShowStatus;
typedef enum ShowStatusFlags {
STATUS_UNIT_FORMAT_NAME,
STATUS_UNIT_FORMAT_DESCRIPTION,
_STATUS_UNIT_FORMAT_MAX,
- _STATUS_UNIT_FORMAT_INVALID = -1,
+ _STATUS_UNIT_FORMAT_INVALID = -EINVAL,
} StatusUnitFormat;
static inline bool show_status_on(ShowStatus s) {
SOCKET_EXEC_STOP_PRE,
SOCKET_EXEC_STOP_POST,
_SOCKET_EXEC_COMMAND_MAX,
- _SOCKET_EXEC_COMMAND_INVALID = -1
+ _SOCKET_EXEC_COMMAND_INVALID = -EINVAL,
} SocketExecCommand;
typedef enum SocketType {
SOCKET_MQUEUE,
SOCKET_USB_FUNCTION,
_SOCKET_TYPE_MAX,
- _SOCKET_TYPE_INVALID = -1
+ _SOCKET_TYPE_INVALID = -EINVAL,
} SocketType;
typedef enum SocketResult {
SOCKET_FAILURE_TRIGGER_LIMIT_HIT,
SOCKET_FAILURE_SERVICE_START_LIMIT_HIT,
_SOCKET_RESULT_MAX,
- _SOCKET_RESULT_INVALID = -1
+ _SOCKET_RESULT_INVALID = -EINVAL,
} SocketResult;
typedef struct SocketPort {
SOCKET_TIMESTAMPING_US, /* SO_TIMESTAMP */
SOCKET_TIMESTAMPING_NS, /* SO_TIMESTAMPNS */
_SOCKET_TIMESTAMPING_MAX,
- _SOCKET_TIMESTAMPING_INVALID = -1,
+ _SOCKET_TIMESTAMPING_INVALID = -EINVAL,
} SocketTimestamping;
struct Socket {
SWAP_EXEC_ACTIVATE,
SWAP_EXEC_DEACTIVATE,
_SWAP_EXEC_COMMAND_MAX,
- _SWAP_EXEC_COMMAND_INVALID = -1
+ _SWAP_EXEC_COMMAND_INVALID = -EINVAL,
} SwapExecCommand;
typedef enum SwapResult {
SWAP_FAILURE_CORE_DUMP,
SWAP_FAILURE_START_LIMIT_HIT,
_SWAP_RESULT_MAX,
- _SWAP_RESULT_INVALID = -1
+ _SWAP_RESULT_INVALID = -EINVAL,
} SwapResult;
typedef struct SwapParameters {
TIMER_UNIT_INACTIVE,
TIMER_CALENDAR,
_TIMER_BASE_MAX,
- _TIMER_BASE_INVALID = -1
+ _TIMER_BASE_INVALID = -EINVAL,
} TimerBase;
typedef struct TimerValue {
TIMER_FAILURE_RESOURCES,
TIMER_FAILURE_START_LIMIT_HIT,
_TIMER_RESULT_MAX,
- _TIMER_RESULT_INVALID = -1
+ _TIMER_RESULT_INVALID = -EINVAL,
} TimerResult;
struct Timer {
KILL_KILL,
KILL_WATCHDOG,
_KILL_OPERATION_MAX,
- _KILL_OPERATION_INVALID = -1
+ _KILL_OPERATION_INVALID = -EINVAL,
} KillOperation;
typedef enum CollectMode {
COLLECT_INACTIVE,
COLLECT_INACTIVE_OR_FAILED,
_COLLECT_MODE_MAX,
- _COLLECT_MODE_INVALID = -1,
+ _COLLECT_MODE_INVALID = -EINVAL,
} CollectMode;
static inline bool UNIT_IS_ACTIVE_OR_RELOADING(UnitActiveState t) {
COREDUMP_STORAGE_EXTERNAL,
COREDUMP_STORAGE_JOURNAL,
_COREDUMP_STORAGE_MAX,
- _COREDUMP_STORAGE_INVALID = -1
+ _COREDUMP_STORAGE_INVALID = -EINVAL,
} CoredumpStorage;
static const char* const coredump_storage_table[_COREDUMP_STORAGE_MAX] = {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include <errno.h>
+
typedef enum EnrollType {
ENROLL_PASSWORD,
ENROLL_RECOVERY,
ENROLL_FIDO2,
ENROLL_TPM2,
_ENROLL_TYPE_MAX,
- _ENROLL_TYPE_INVALID = -1,
+ _ENROLL_TYPE_INVALID = -EINVAL,
} EnrollType;
typedef enum WipeScope {
WIPE_ALL, /* wipe all slots */
WIPE_EMPTY_PASSPHRASE, /* wipe slots with empty passphrases plus listed slots */
_WIPE_SCOPE_MAX,
- _WIPE_SCOPE_INVALID = -1,
+ _WIPE_SCOPE_INVALID = -EINVAL,
} WipeScope;
const char* enroll_type_to_string(EnrollType t);
HOME_AUTHENTICATING_WHILE_ACTIVE,
HOME_AUTHENTICATING_FOR_ACQUIRE, /* authenticating because Acquire() was called */
_HOME_STATE_MAX,
- _HOME_STATE_INVALID = -1
+ _HOME_STATE_INVALID = -EINVAL,
} HomeState;
static inline bool HOME_STATE_IS_ACTIVE(HomeState state) {
OPERATION_DEACTIVATE_FORCE, /* enqueued on hard $HOME unplug */
OPERATION_IMMEDIATE, /* this is never enqueued, it's just a marker we immediately started executing an operation without enqueuing anything first. */
_OPERATION_MAX,
- _OPERATION_INVALID = -1,
+ _OPERATION_INVALID = -EINVAL,
} OperationType;
/* Encapsulates an operation on one or more home directories. This has two uses:
USER_RECONCILE_REQUIRE_NEWER, /* host version must be newer than embedded version */
USER_RECONCILE_REQUIRE_NEWER_OR_EQUAL, /* similar, but may also be equal */
_USER_RECONCILE_MODE_MAX,
- _USER_RECONCILE_MODE_INVALID = -1,
+ _USER_RECONCILE_MODE_INVALID = -EINVAL,
} UserReconcileMode;
enum { /* return values */
PROP_OS_CPE_NAME,
PROP_OS_HOME_URL,
_PROP_MAX,
- _PROP_INVALID = -1,
+ _PROP_INVALID = -EINVAL,
};
typedef struct Context {
IMPORT_COMPRESS_GZIP,
IMPORT_COMPRESS_BZIP2,
_IMPORT_COMPRESS_TYPE_MAX,
- _IMPORT_COMPRESS_TYPE_INVALID = -1,
+ _IMPORT_COMPRESS_TYPE_INVALID = -EINVAL,
} ImportCompressType;
typedef struct ImportCompress {
TRANSFER_PULL_TAR,
TRANSFER_PULL_RAW,
_TRANSFER_TYPE_MAX,
- _TRANSFER_TYPE_INVALID = -1,
+ _TRANSFER_TYPE_INVALID = -EINVAL,
} TransferType;
struct Transfer {
VERIFICATION_PER_FILE, /* SuSE-style ".sha256" files with inline gpg signature */
VERIFICATION_PER_DIRECTORY, /* Ubuntu-style SHA256SUM files with detached SHA256SUM.gpg signatures */
_VERIFICATION_STYLE_MAX,
- _VERIFICATION_STYLE_INVALID = -1,
+ _VERIFICATION_STYLE_INVALID = -EINVAL,
} VerificationStyle;
int verification_style_from_url(const char *url, VerificationStyle *style);
PULL_JOB_DONE,
PULL_JOB_FAILED,
_PULL_JOB_STATE_MAX,
- _PULL_JOB_STATE_INVALID = -1,
+ _PULL_JOB_STATE_INVALID = -EINVAL,
} PullJobState;
#define PULL_JOB_IS_COMPLETE(j) (IN_SET((j)->state, PULL_JOB_DONE, PULL_JOB_FAILED))
JOURNAL_WRITE_SPLIT_NONE,
JOURNAL_WRITE_SPLIT_HOST,
_JOURNAL_WRITE_SPLIT_MAX,
- _JOURNAL_WRITE_SPLIT_INVALID = -1
+ _JOURNAL_WRITE_SPLIT_INVALID = -EINVAL,
} JournalWriteSplitMode;
STORAGE_PERSISTENT,
STORAGE_NONE,
_STORAGE_MAX,
- _STORAGE_INVALID = -1
+ _STORAGE_INVALID = -EINVAL,
} Storage;
typedef enum SplitMode {
SPLIT_LOGIN, /* deprecated */
SPLIT_NONE,
_SPLIT_MAX,
- _SPLIT_INVALID = -1
+ _SPLIT_INVALID = -EINVAL,
} SplitMode;
typedef struct JournalCompressOptions {
LINE_BREAK_EOF,
LINE_BREAK_PID_CHANGE,
_LINE_BREAK_MAX,
- _LINE_BREAK_INVALID = -1,
+ _LINE_BREAK_INVALID = -EINVAL,
} LineBreak;
struct StdoutStream {
IPV4ACD_STATE_ANNOUNCING,
IPV4ACD_STATE_RUNNING,
_IPV4ACD_STATE_MAX,
- _IPV4ACD_STATE_INVALID = -1
+ _IPV4ACD_STATE_INVALID = -EINVAL,
} IPv4ACDState;
struct sd_ipv4acd {
BUS_NODE_ENUMERATOR,
BUS_NODE_VTABLE,
BUS_NODE_OBJECT_MANAGER,
- _BUS_SLOT_INVALID = -1,
+ _BUS_SLOT_INVALID = -EINVAL,
} BusSlotType;
struct sd_bus_slot {
BUS_MATCH_ARG_HAS,
BUS_MATCH_ARG_HAS_LAST = BUS_MATCH_ARG_HAS + 63,
_BUS_MATCH_NODE_TYPE_MAX,
- _BUS_MATCH_NODE_TYPE_INVALID = -1
+ _BUS_MATCH_NODE_TYPE_INVALID = -EINVAL,
};
struct bus_match_node {
DEVICE_ENUMERATION_TYPE_DEVICES,
DEVICE_ENUMERATION_TYPE_SUBSYSTEMS,
_DEVICE_ENUMERATION_TYPE_MAX,
- _DEVICE_ENUMERATION_TYPE_INVALID = -1,
+ _DEVICE_ENUMERATION_TYPE_INVALID = -EINVAL,
} DeviceEnumerationType;
struct sd_device_enumerator {
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#pragma once
+#include <errno.h>
+
#include "sd-device.h"
typedef enum MonitorNetlinkGroup {
MONITOR_GROUP_KERNEL,
MONITOR_GROUP_UDEV,
_MONITOR_NETLINK_GROUP_MAX,
- _MONITOR_NETLINK_GROUP_INVALID = -1,
+ _MONITOR_NETLINK_GROUP_INVALID = -EINVAL,
} MonitorNetlinkGroup;
int device_monitor_new_full(sd_device_monitor **ret, MonitorNetlinkGroup group, int fd);
DEVICE_ACTION_BIND,
DEVICE_ACTION_UNBIND,
_DEVICE_ACTION_MAX,
- _DEVICE_ACTION_INVALID = -1,
+ _DEVICE_ACTION_INVALID = -EINVAL,
} DeviceAction;
int device_new_from_nulstr(sd_device **ret, uint8_t *nulstr, size_t len);
SOURCE_WATCHDOG,
SOURCE_INOTIFY,
_SOURCE_EVENT_SOURCE_TYPE_MAX,
- _SOURCE_EVENT_SOURCE_TYPE_INVALID = -1
+ _SOURCE_EVENT_SOURCE_TYPE_INVALID = -EINVAL,
} EventSourceType;
/* All objects we use in epoll events start with this value, so that
WAKEUP_SIGNAL_DATA,
WAKEUP_INOTIFY_DATA,
_WAKEUP_TYPE_MAX,
- _WAKEUP_TYPE_INVALID = -1,
+ _WAKEUP_TYPE_INVALID = -EINVAL,
} WakeupType;
struct inode_data;
typedef enum NetlinkSlotType {
NETLINK_REPLY_CALLBACK,
NETLINK_MATCH_CALLBACK,
- _NETLINK_SLOT_INVALID = -1,
+ _NETLINK_SLOT_INVALID = -EINVAL,
} NetlinkSlotType;
struct sd_netlink_slot {
NL_UNION_LINK_INFO_DATA_IFB,
NL_UNION_LINK_INFO_DATA_BAREUDP,
_NL_UNION_LINK_INFO_DATA_MAX,
- _NL_UNION_LINK_INFO_DATA_INVALID = -1
+ _NL_UNION_LINK_INFO_DATA_INVALID = -EINVAL,
} NLUnionLinkInfoData;
const char *nl_union_link_info_data_to_string(NLUnionLinkInfoData p) _const_;
NL_UNION_TCA_OPTION_DATA_SFB,
NL_UNION_TCA_OPTION_DATA_TBF,
_NL_UNION_TCA_OPTION_DATA_MAX,
- _NL_UNION_TCA_OPTION_DATA_INVALID = -1,
+ _NL_UNION_TCA_OPTION_DATA_INVALID = -EINVAL,
} NLUnionTCAOptionData;
const char *nl_union_tca_option_data_to_string(NLUnionTCAOptionData p) _const_;
NL_UNION_NFT_EXPR_DATA_META,
NL_UNION_NFT_EXPR_DATA_NAT,
_NL_UNION_NFT_EXPR_DATA_MAX,
- _NL_UNION_NFT_EXPR_DATA_INVALID = -1,
+ _NL_UNION_NFT_EXPR_DATA_INVALID = -EINVAL,
} NLUnionNFTExprData;
const char *nl_union_nft_expr_data_to_string(NLUnionNFTExprData p) _const_;
LINK_OPERSTATE_ENSLAVED,
LINK_OPERSTATE_ROUTABLE,
_LINK_OPERSTATE_MAX,
- _LINK_OPERSTATE_INVALID = -1
+ _LINK_OPERSTATE_INVALID = -EINVAL,
} LinkOperationalState;
typedef enum LinkCarrierState {
LINK_CARRIER_STATE_CARRIER = LINK_OPERSTATE_CARRIER,
LINK_CARRIER_STATE_ENSLAVED = LINK_OPERSTATE_ENSLAVED,
_LINK_CARRIER_STATE_MAX,
- _LINK_CARRIER_STATE_INVALID = -1
+ _LINK_CARRIER_STATE_INVALID = -EINVAL,
} LinkCarrierState;
typedef enum LinkAddressState {
LINK_ADDRESS_STATE_DEGRADED,
LINK_ADDRESS_STATE_ROUTABLE,
_LINK_ADDRESS_STATE_MAX,
- _LINK_ADDRESS_STATE_INVALID = -1
+ _LINK_ADDRESS_STATE_INVALID = -EINVAL,
} LinkAddressState;
const char* link_operstate_to_string(LinkOperationalState s) _const_;
HANDLE_SUSPEND_THEN_HIBERNATE,
HANDLE_LOCK,
_HANDLE_ACTION_MAX,
- _HANDLE_ACTION_INVALID = -1
+ _HANDLE_ACTION_INVALID = -EINVAL,
} HandleAction;
#include "logind-inhibit.h"
INHIBIT_HANDLE_LID_SWITCH = 1 << 6,
INHIBIT_HANDLE_REBOOT_KEY = 1 << 7,
_INHIBIT_WHAT_MAX = 1 << 8,
- _INHIBIT_WHAT_INVALID = -1
+ _INHIBIT_WHAT_INVALID = -EINVAL,
} InhibitWhat;
typedef enum InhibitMode {
INHIBIT_BLOCK,
INHIBIT_DELAY,
_INHIBIT_MODE_MAX,
- _INHIBIT_MODE_INVALID = -1
+ _INHIBIT_MODE_INVALID = -EINVAL,
} InhibitMode;
#include "logind.h"
SESSION_ACTIVE, /* Logged in and in the fg */
SESSION_CLOSING, /* Logged out, but scope is still there */
_SESSION_STATE_MAX,
- _SESSION_STATE_INVALID = -1
+ _SESSION_STATE_INVALID = -EINVAL,
} SessionState;
typedef enum SessionClass {
SESSION_LOCK_SCREEN,
SESSION_BACKGROUND,
_SESSION_CLASS_MAX,
- _SESSION_CLASS_INVALID = -1
+ _SESSION_CLASS_INVALID = -EINVAL,
} SessionClass;
typedef enum SessionType {
SESSION_MIR,
SESSION_WEB,
_SESSION_TYPE_MAX,
- _SESSION_TYPE_INVALID = -1
+ _SESSION_TYPE_INVALID = -EINVAL,
} SessionType;
#define SESSION_TYPE_IS_GRAPHICAL(type) IN_SET(type, SESSION_X11, SESSION_WAYLAND, SESSION_MIR)
KILL_LEADER,
KILL_ALL,
_KILL_WHO_MAX,
- _KILL_WHO_INVALID = -1
+ _KILL_WHO_INVALID = -EINVAL,
};
typedef enum TTYValidity {
TTY_FROM_UTMP,
TTY_UTMP_INCONSISTENT, /* may happen on ssh sessions with multiplexed TTYs */
_TTY_VALIDITY_MAX,
- _TTY_VALIDITY_INVALID = -1,
+ _TTY_VALIDITY_INVALID = -EINVAL,
} TTYValidity;
struct Session {
USER_ACTIVE, /* User logged in and has a session in the fg */
USER_CLOSING, /* User logged out, but processes still remain and lingering is not enabled */
_USER_STATE_MAX,
- _USER_STATE_INVALID = -1
+ _USER_STATE_INVALID = -EINVAL,
} UserState;
struct User {
MACHINE_RUNNING, /* Machine is running */
MACHINE_CLOSING, /* Machine is terminating */
_MACHINE_STATE_MAX,
- _MACHINE_STATE_INVALID = -1
+ _MACHINE_STATE_INVALID = -EINVAL,
} MachineState;
typedef enum MachineClass {
MACHINE_VM,
MACHINE_HOST,
_MACHINE_CLASS_MAX,
- _MACHINE_CLASS_INVALID = -1
+ _MACHINE_CLASS_INVALID = -EINVAL,
} MachineClass;
enum KillWho {
KILL_LEADER,
KILL_ALL,
_KILL_WHO_MAX,
- _KILL_WHO_INVALID = -1
+ _KILL_WHO_INVALID = -EINVAL,
};
struct Machine {
DHCP_TYPE_EITHER6,
DHCP_TYPE_IBFT,
_DHCP_TYPE_MAX,
- _DHCP_TYPE_INVALID = -1,
+ _DHCP_TYPE_INVALID = -EINVAL,
} DHCPType;
typedef struct Address Address;
BARE_UDP_PROTOCOL_MPLS_UC = ETH_P_MPLS_UC,
BARE_UDP_PROTOCOL_MPLS_MC = ETH_P_MPLS_MC,
_BARE_UDP_PROTOCOL_MAX,
- _BARE_UDP_PROTOCOL_INVALID = -1
+ _BARE_UDP_PROTOCOL_INVALID = -EINVAL,
} BareUDPProtocol;
struct BareUDP {
MULTICAST_ROUTER_PERMANENT = MDB_RTR_TYPE_PERM,
MULTICAST_ROUTER_TEMPORARY = MDB_RTR_TYPE_TEMP,
_MULTICAST_ROUTER_MAX,
- _MULTICAST_ROUTER_INVALID = -1,
+ _MULTICAST_ROUTER_INVALID = -EINVAL,
} MulticastRouter;
DEFINE_NETDEV_CAST(BRIDGE, Bridge);
NETDEV_FOO_OVER_UDP_ENCAP_DIRECT = FOU_ENCAP_DIRECT,
NETDEV_FOO_OVER_UDP_ENCAP_GUE = FOU_ENCAP_GUE,
_NETDEV_FOO_OVER_UDP_ENCAP_MAX,
- _NETDEV_FOO_OVER_UDP_ENCAP_INVALID = -1,
+ _NETDEV_FOO_OVER_UDP_ENCAP_INVALID = -EINVAL,
} FooOverUDPEncapType;
typedef struct FouTunnel {
NETDEV_GENEVE_DF_YES = GENEVE_DF_SET,
NETDEV_GENEVE_DF_INHERIT = GENEVE_DF_INHERIT,
_NETDEV_GENEVE_DF_MAX,
- _NETDEV_GENEVE_DF_INVALID = -1
+ _NETDEV_GENEVE_DF_INVALID = -EINVAL,
} GeneveDF;
struct Geneve {
NETDEV_L2TP_L2SPECTYPE_NONE = L2TP_L2SPECTYPE_NONE,
NETDEV_L2TP_L2SPECTYPE_DEFAULT = L2TP_L2SPECTYPE_DEFAULT,
_NETDEV_L2TP_L2SPECTYPE_MAX,
- _NETDEV_L2TP_L2SPECTYPE_INVALID = -1,
+ _NETDEV_L2TP_L2SPECTYPE_INVALID = -EINVAL,
} L2tpL2specType;
typedef enum L2tpEncapType {
NETDEV_L2TP_ENCAPTYPE_UDP = L2TP_ENCAPTYPE_UDP,
NETDEV_L2TP_ENCAPTYPE_IP = L2TP_ENCAPTYPE_IP,
_NETDEV_L2TP_ENCAPTYPE_MAX,
- _NETDEV_L2TP_ENCAPTYPE_INVALID = -1,
+ _NETDEV_L2TP_ENCAPTYPE_INVALID = -EINVAL,
} L2tpEncapType;
typedef enum L2tpLocalAddressType {
NETDEV_L2TP_LOCAL_ADDRESS_STATIC,
NETDEV_L2TP_LOCAL_ADDRESS_DYNAMIC,
_NETDEV_L2TP_LOCAL_ADDRESS_MAX,
- _NETDEV_L2TP_LOCAL_ADDRESS_INVALID = -1,
+ _NETDEV_L2TP_LOCAL_ADDRESS_INVALID = -EINVAL,
} L2tpLocalAddressType;
typedef struct L2tpTunnel L2tpTunnel;
NETDEV_KIND_BAREUDP,
_NETDEV_KIND_MAX,
_NETDEV_KIND_TUNNEL, /* Used by config_parse_stacked_netdev() */
- _NETDEV_KIND_INVALID = -1
+ _NETDEV_KIND_INVALID = -EINVAL,
} NetDevKind;
typedef enum NetDevState {
NETDEV_STATE_READY,
NETDEV_STATE_LINGER,
_NETDEV_STATE_MAX,
- _NETDEV_STATE_INVALID = -1,
+ _NETDEV_STATE_INVALID = -EINVAL,
} NetDevState;
typedef enum NetDevCreateType {
NETDEV_CREATE_STACKED,
NETDEV_CREATE_AFTER_CONFIGURED,
_NETDEV_CREATE_MAX,
- _NETDEV_CREATE_INVALID = -1,
+ _NETDEV_CREATE_INVALID = -EINVAL,
} NetDevCreateType;
typedef struct Manager Manager;
NETDEV_IP6_TNL_MODE_IPIP6,
NETDEV_IP6_TNL_MODE_ANYIP6,
_NETDEV_IP6_TNL_MODE_MAX,
- _NETDEV_IP6_TNL_MODE_INVALID = -1,
+ _NETDEV_IP6_TNL_MODE_INVALID = -EINVAL,
} Ip6TnlMode;
typedef enum IPv6FlowLabel {
NETDEV_IPV6_FLOWLABEL_INHERIT = 0xFFFFF + 1,
_NETDEV_IPV6_FLOWLABEL_MAX,
- _NETDEV_IPV6_FLOWLABEL_INVALID = -1,
+ _NETDEV_IPV6_FLOWLABEL_INVALID = -EINVAL,
} IPv6FlowLabel;
typedef struct Tunnel {
NETDEV_VXLAN_DF_YES = VXLAN_DF_SET,
NETDEV_VXLAN_DF_INHERIT = VXLAN_DF_INHERIT,
_NETDEV_VXLAN_DF_MAX,
- _NETDEV_VXLAN_DF_INVALID = -1
+ _NETDEV_VXLAN_DF_INVALID = -EINVAL,
} VxLanDF;
struct VxLan {
DHCP_USE_DOMAINS_YES,
DHCP_USE_DOMAINS_ROUTE,
_DHCP_USE_DOMAINS_MAX,
- _DHCP_USE_DOMAINS_INVALID = -1,
+ _DHCP_USE_DOMAINS_INVALID = -EINVAL,
} DHCPUseDomains;
typedef enum DHCPOptionDataType {
* https://github.com/systemd/systemd/issues/7828 */
DHCP_CLIENT_ID_DUID_ONLY,
_DHCP_CLIENT_ID_MAX,
- _DHCP_CLIENT_ID_INVALID = -1,
+ _DHCP_CLIENT_ID_INVALID = -EINVAL,
} DHCPClientIdentifier;
int dhcp4_configure(Link *link);
DHCP6_CLIENT_START_MODE_INFORMATION_REQUEST,
DHCP6_CLIENT_START_MODE_SOLICIT,
_DHCP6_CLIENT_START_MODE_MAX,
- _DHCP6_CLIENT_START_MODE_INVALID = -1,
+ _DHCP6_CLIENT_START_MODE_INVALID = -EINVAL,
} DHCP6ClientStartMode;
typedef struct Link Link;
NEIGHBOR_CACHE_ENTRY_FLAGS_MASTER = NTF_MASTER,
NEIGHBOR_CACHE_ENTRY_FLAGS_ROUTER = NTF_ROUTER,
_NEIGHBOR_CACHE_ENTRY_FLAGS_MAX,
- _NEIGHBOR_CACHE_ENTRY_FLAGS_INVALID = -1,
+ _NEIGHBOR_CACHE_ENTRY_FLAGS_INVALID = -EINVAL,
} NeighborCacheEntryFlags;
typedef struct FdbEntry {
LINK_STATE_FAILED, /* at least one configuration process failed */
LINK_STATE_LINGER, /* RTM_DELLINK for the link has been received */
_LINK_STATE_MAX,
- _LINK_STATE_INVALID = -1
+ _LINK_STATE_INVALID = -EINVAL,
} LinkState;
typedef struct Manager Manager;
LLDP_MODE_YES = 1,
LLDP_MODE_ROUTERS_ONLY = 2,
_LLDP_MODE_MAX,
- _LLDP_MODE_INVALID = -1,
+ _LLDP_MODE_INVALID = -EINVAL,
} LLDPMode;
int link_lldp_rx_configure(Link *link);
IPV6_TOKEN_ADDRESS_GENERATION_STATIC,
IPV6_TOKEN_ADDRESS_GENERATION_PREFIXSTABLE,
_IPV6_TOKEN_ADDRESS_GENERATION_MAX,
- _IPV6_TOKEN_ADDRESS_GENERATION_INVALID = -1,
+ _IPV6_TOKEN_ADDRESS_GENERATION_INVALID = -EINVAL,
} IPv6TokenAddressGeneration;
typedef enum IPv6AcceptRAStartDHCP6Client {
IPV6_ACCEPT_RA_START_DHCP6_CLIENT_ALWAYS,
IPV6_ACCEPT_RA_START_DHCP6_CLIENT_YES,
_IPV6_ACCEPT_RA_START_DHCP6_CLIENT_MAX,
- _IPV6_ACCEPT_RA_START_DHCP6_CLIENT_INVALID = -1,
+ _IPV6_ACCEPT_RA_START_DHCP6_CLIENT_INVALID = -EINVAL,
} IPv6AcceptRAStartDHCP6Client;
typedef struct NDiscAddress {
KEEP_CONFIGURATION_STATIC = 1 << 2,
KEEP_CONFIGURATION_YES = KEEP_CONFIGURATION_DHCP | KEEP_CONFIGURATION_STATIC,
_KEEP_CONFIGURATION_MAX,
- _KEEP_CONFIGURATION_INVALID = -1,
+ _KEEP_CONFIGURATION_INVALID = -EINVAL,
} KeepConfiguration;
typedef enum IPv6LinkLocalAddressGenMode {
IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_STABLE_PRIVACY = IN6_ADDR_GEN_MODE_STABLE_PRIVACY,
IPV6_LINK_LOCAL_ADDRESSS_GEN_MODE_RANDOM = IN6_ADDR_GEN_MODE_RANDOM,
_IPV6_LINK_LOCAL_ADDRESS_GEN_MODE_MAX,
- _IPV6_LINK_LOCAL_ADDRESS_GEN_MODE_INVALID = -1
+ _IPV6_LINK_LOCAL_ADDRESS_GEN_MODE_INVALID = -EINVAL,
} IPv6LinkLocalAddressGenMode;
typedef enum ActivationPolicy {
ACTIVATION_POLICY_DOWN,
ACTIVATION_POLICY_BOUND,
_ACTIVATION_POLICY_MAX,
- _ACTIVATION_POLICY_INVALID = -1
+ _ACTIVATION_POLICY_INVALID = -EINVAL,
} ActivationPolicy;
typedef struct Manager Manager;
RADV_PREFIX_DELEGATION_DHCP6 = 1 << 1,
RADV_PREFIX_DELEGATION_BOTH = RADV_PREFIX_DELEGATION_STATIC | RADV_PREFIX_DELEGATION_DHCP6,
_RADV_PREFIX_DELEGATION_MAX,
- _RADV_PREFIX_DELEGATION_INVALID = -1,
+ _RADV_PREFIX_DELEGATION_INVALID = -EINVAL,
} RADVPrefixDelegation;
typedef struct Prefix {
SR_IOV_LINK_STATE_ENABLE = IFLA_VF_LINK_STATE_ENABLE,
SR_IOV_LINK_STATE_DISABLE = IFLA_VF_LINK_STATE_DISABLE,
_SR_IOV_LINK_STATE_MAX,
- _SR_IOV_LINK_STATE_INVALID = -1,
+ _SR_IOV_LINK_STATE_INVALID = -EINVAL,
} SRIOVLinkState;
typedef struct SRIOV {
IPV6_PRIVACY_EXTENSIONS_PREFER_PUBLIC,
IPV6_PRIVACY_EXTENSIONS_YES, /* aka prefer-temporary */
_IPV6_PRIVACY_EXTENSIONS_MAX,
- _IPV6_PRIVACY_EXTENSIONS_INVALID = -1,
+ _IPV6_PRIVACY_EXTENSIONS_INVALID = -EINVAL,
} IPv6PrivacyExtensions;
int link_set_sysctl(Link *link);
ADDRESS_FAMILY_IPV6 = 1 << 1,
ADDRESS_FAMILY_YES = ADDRESS_FAMILY_IPV4 | ADDRESS_FAMILY_IPV6,
_ADDRESS_FAMILY_MAX,
- _ADDRESS_FAMILY_INVALID = -1,
+ _ADDRESS_FAMILY_INVALID = -EINVAL,
} AddressFamily;
typedef struct NetworkConfigSection {
QDISC_KIND_TBF,
QDISC_KIND_TEQL,
_QDISC_KIND_MAX,
- _QDISC_KIND_INVALID = -1,
+ _QDISC_KIND_INVALID = -EINVAL,
} QDiscKind;
typedef struct QDisc {
TC_KIND_TCLASS,
TC_KIND_FILTER,
_TC_KIND_MAX,
- _TC_KIND_INVALID = -1,
+ _TC_KIND_INVALID = -EINVAL,
} TrafficControlKind;
typedef struct TrafficControl {
TCLASS_KIND_HTB,
TCLASS_KIND_QFQ,
_TCLASS_KIND_MAX,
- _TCLASS_KIND_INVALID = -1,
+ _TCLASS_KIND_INVALID = -EINVAL,
} TClassKind;
typedef struct TClass {
CUSTOM_MOUNT_INACCESSIBLE,
CUSTOM_MOUNT_ARBITRARY,
_CUSTOM_MOUNT_TYPE_MAX,
- _CUSTOM_MOUNT_TYPE_INVALID = -1
+ _CUSTOM_MOUNT_TYPE_INVALID = -EINVAL,
} CustomMountType;
typedef struct CustomMount {
START_PID2, /* Use stub init process as PID 1, run parameters as command line as process 2 */
START_BOOT, /* Search for init system, pass arguments as parameters */
_START_MODE_MAX,
- _START_MODE_INVALID = -1
+ _START_MODE_INVALID = -EINVAL,
} StartMode;
typedef enum UserNamespaceMode {
USER_NAMESPACE_FIXED,
USER_NAMESPACE_PICK,
_USER_NAMESPACE_MODE_MAX,
- _USER_NAMESPACE_MODE_INVALID = -1,
+ _USER_NAMESPACE_MODE_INVALID = -EINVAL,
} UserNamespaceMode;
typedef enum ResolvConfMode {
RESOLV_CONF_DELETE,
RESOLV_CONF_AUTO,
_RESOLV_CONF_MODE_MAX,
- _RESOLV_CONF_MODE_INVALID = -1
+ _RESOLV_CONF_MODE_INVALID = -EINVAL,
} ResolvConfMode;
typedef enum LinkJournal {
LINK_HOST,
LINK_GUEST,
_LINK_JOURNAL_MAX,
- _LINK_JOURNAL_INVALID = -1
+ _LINK_JOURNAL_INVALID = -EINVAL,
} LinkJournal;
typedef enum TimezoneMode {
TIMEZONE_DELETE,
TIMEZONE_AUTO,
_TIMEZONE_MODE_MAX,
- _TIMEZONE_MODE_INVALID = -1
+ _TIMEZONE_MODE_INVALID = -EINVAL,
} TimezoneMode;
typedef enum ConsoleMode {
CONSOLE_PASSIVE,
CONSOLE_PIPE,
_CONSOLE_MODE_MAX,
- _CONSOLE_MODE_INVALID = -1,
+ _CONSOLE_MODE_INVALID = -EINVAL,
} ConsoleMode;
typedef enum SettingsMask {
ENCRYPT_TPM2,
ENCRYPT_KEY_FILE_TPM2,
_ENCRYPT_MODE_MAX,
- _ENCRYPT_MODE_INVALID = -1,
+ _ENCRYPT_MODE_INVALID = -EINVAL,
} EncryptMode;
struct Partition {
PORTABLE_RUNNING,
PORTABLE_RUNNING_RUNTIME,
_PORTABLE_STATE_MAX,
- _PORTABLE_STATE_INVALID = -1
+ _PORTABLE_STATE_INVALID = -EINVAL,
} PortableState;
typedef struct PortableChange {
BUS_IMAGE_AUTHENTICATE_BY_PATH, /* allow by name + polkit by path */
BUS_IMAGE_AUTHENTICATE_ALL, /* polkit by name + polkit by path */
_BUS_IMAGE_ACQUIRE_MODE_MAX,
- _BUS_IMAGE_ACQUIRE_MODE_INVALID = -1
+ _BUS_IMAGE_ACQUIRE_MODE_INVALID = -EINVAL,
} ImageAcquireMode;
int bus_image_acquire(Manager *m, sd_bus_message *message, const char *name_or_path, Image *image, ImageAcquireMode mode, const char *polkit_action, Image **ret, sd_bus_error *error);
PSTORE_STORAGE_EXTERNAL,
PSTORE_STORAGE_JOURNAL,
_PSTORE_STORAGE_MAX,
- _PSTORE_STORAGE_INVALID = -1
+ _PSTORE_STORAGE_INVALID = -EINVAL,
} PStoreStorage;
static const char* const pstore_storage_table[_PSTORE_STORAGE_MAX] = {
DNS_TYPE_DLV,
_DNS_TYPE_MAX,
- _DNS_TYPE_INVALID = -1
+ _DNS_TYPE_INVALID = -EINVAL,
};
assert_cc(DNS_TYPE_SSHFP == 44);
DNS_CLASS_ANY = 0xFF,
_DNS_CLASS_MAX,
- _DNS_CLASS_INVALID = -1
+ _DNS_CLASS_INVALID = -EINVAL,
};
#define _DNS_CLASS_STRING_MAX (sizeof "CLASS" + DECIMAL_STR_MAX(uint16_t))
MODE_STATUS,
MODE_SET_LINK,
MODE_REVERT_LINK,
- _MODE_INVALID = -1,
+ _MODE_INVALID = -EINVAL,
} ExecutionMode;
extern ExecutionMode arg_mode;
DNSSEC_INCOMPATIBLE_SERVER,
_DNSSEC_RESULT_MAX,
- _DNSSEC_RESULT_INVALID = -1
+ _DNSSEC_RESULT_INVALID = -EINVAL,
};
enum DnssecVerdict {
DNSSEC_INDETERMINATE,
_DNSSEC_VERDICT_MAX,
- _DNSSEC_VERDICT_INVALID = -1
+ _DNSSEC_VERDICT_INVALID = -EINVAL,
};
#define DNSSEC_CANONICAL_HOSTNAME_MAX (DNS_HOSTNAME_MAX + 2)
DNS_PROTOCOL_MDNS,
DNS_PROTOCOL_LLMNR,
_DNS_PROTOCOL_MAX,
- _DNS_PROTOCOL_INVALID = -1
+ _DNS_PROTOCOL_INVALID = -EINVAL,
} DnsProtocol;
struct DnsPacketHeader {
DNS_SCOPE_YES_BASE, /* Add the number of matching labels to this */
DNS_SCOPE_YES_END = DNS_SCOPE_YES_BASE + DNS_N_LABELS_MAX,
_DNS_SCOPE_MATCH_MAX,
- _DNS_SCOPE_MATCH_INVALID = -1
+ _DNS_SCOPE_MATCH_INVALID = -EINVAL,
} DnsScopeMatch;
struct DnsScope {
DNS_SERVER_FALLBACK,
DNS_SERVER_LINK,
_DNS_SERVER_TYPE_MAX,
- _DNS_SERVER_TYPE_INVALID = -1
+ _DNS_SERVER_TYPE_INVALID = -EINVAL,
} DnsServerType;
const char* dns_server_type_to_string(DnsServerType i) _const_;
DNS_SERVER_FEATURE_LEVEL_LARGE,
DNS_SERVER_FEATURE_LEVEL_TLS_DO,
_DNS_SERVER_FEATURE_LEVEL_MAX,
- _DNS_SERVER_FEATURE_LEVEL_INVALID = -1
+ _DNS_SERVER_FEATURE_LEVEL_INVALID = -EINVAL,
} DnsServerFeatureLevel;
#define DNS_SERVER_FEATURE_LEVEL_WORST 0
DNS_STREAM_LLMNR_RECV, /* Incoming LLMNR TCP lookup */
DNS_STREAM_STUB, /* Incoming DNS stub connection */
_DNS_STREAM_TYPE_MAX,
- _DNS_STREAM_TYPE_INVALID = -1,
+ _DNS_STREAM_TYPE_INVALID = -EINVAL,
} DnsStreamType;
#define DNS_STREAM_WRITE_TLS_DATA 1
DNS_STUB_LISTENER_TCP = 1 << 1,
DNS_STUB_LISTENER_YES = DNS_STUB_LISTENER_UDP | DNS_STUB_LISTENER_TCP,
_DNS_STUB_LISTENER_MODE_MAX,
- _DNS_STUB_LISTENER_MODE_INVALID = -1
+ _DNS_STUB_LISTENER_MODE_INVALID = -EINVAL,
} DnsStubListenerMode;
#include "resolved-manager.h"
DNS_TRANSACTION_NETWORK_DOWN,
DNS_TRANSACTION_NOT_FOUND, /* like NXDOMAIN, but when LLMNR/TCP connections fail */
_DNS_TRANSACTION_STATE_MAX,
- _DNS_TRANSACTION_STATE_INVALID = -1
+ _DNS_TRANSACTION_STATE_INVALID = -EINVAL,
};
#define DNS_TRANSACTION_IS_LIVE(state) IN_SET((state), DNS_TRANSACTION_NULL, DNS_TRANSACTION_PENDING, DNS_TRANSACTION_VALIDATING)
DNS_TRANSACTION_ZONE,
DNS_TRANSACTION_TRUST_ANCHOR,
_DNS_TRANSACTION_SOURCE_MAX,
- _DNS_TRANSACTION_SOURCE_INVALID = -1
+ _DNS_TRANSACTION_SOURCE_INVALID = -EINVAL,
};
struct DnsTransaction {
RESOLV_CONF_FOREIGN,
RESOLV_CONF_MISSING,
_RESOLV_CONF_MODE_MAX,
- _RESOLV_CONF_MODE_INVALID = -1,
+ _RESOLV_CONF_MODE_INVALID = -EINVAL,
} ResolvConfMode;
int resolv_conf_mode(void);
NETDEV_BOND_MODE_BALANCE_TLB = BOND_MODE_TLB,
NETDEV_BOND_MODE_BALANCE_ALB = BOND_MODE_ALB,
_NETDEV_BOND_MODE_MAX,
- _NETDEV_BOND_MODE_INVALID = -1
+ _NETDEV_BOND_MODE_INVALID = -EINVAL,
} BondMode;
typedef enum BondXmitHashPolicy {
NETDEV_BOND_XMIT_HASH_POLICY_ENCAP23 = BOND_XMIT_POLICY_ENCAP23,
NETDEV_BOND_XMIT_HASH_POLICY_ENCAP34 = BOND_XMIT_POLICY_ENCAP34,
_NETDEV_BOND_XMIT_HASH_POLICY_MAX,
- _NETDEV_BOND_XMIT_HASH_POLICY_INVALID = -1
+ _NETDEV_BOND_XMIT_HASH_POLICY_INVALID = -EINVAL,
} BondXmitHashPolicy;
typedef enum BondLacpRate {
NETDEV_BOND_LACP_RATE_SLOW,
NETDEV_BOND_LACP_RATE_FAST,
_NETDEV_BOND_LACP_RATE_MAX,
- _NETDEV_BOND_LACP_RATE_INVALID = -1,
+ _NETDEV_BOND_LACP_RATE_INVALID = -EINVAL,
} BondLacpRate;
typedef enum BondAdSelect {
NETDEV_BOND_AD_SELECT_BANDWIDTH,
NETDEV_BOND_AD_SELECT_COUNT,
_NETDEV_BOND_AD_SELECT_MAX,
- _NETDEV_BOND_AD_SELECT_INVALID = -1,
+ _NETDEV_BOND_AD_SELECT_INVALID = -EINVAL,
} BondAdSelect;
typedef enum BondFailOverMac {
NETDEV_BOND_FAIL_OVER_MAC_ACTIVE,
NETDEV_BOND_FAIL_OVER_MAC_FOLLOW,
_NETDEV_BOND_FAIL_OVER_MAC_MAX,
- _NETDEV_BOND_FAIL_OVER_MAC_INVALID = -1,
+ _NETDEV_BOND_FAIL_OVER_MAC_INVALID = -EINVAL,
} BondFailOverMac;
typedef enum BondArpValidate {
NETDEV_BOND_ARP_VALIDATE_BACKUP,
NETDEV_BOND_ARP_VALIDATE_ALL,
_NETDEV_BOND_ARP_VALIDATE_MAX,
- _NETDEV_BOND_ARP_VALIDATE_INVALID = -1,
+ _NETDEV_BOND_ARP_VALIDATE_INVALID = -EINVAL,
} BondArpValidate;
typedef enum BondArpAllTargets {
NETDEV_BOND_ARP_ALL_TARGETS_ANY,
NETDEV_BOND_ARP_ALL_TARGETS_ALL,
_NETDEV_BOND_ARP_ALL_TARGETS_MAX,
- _NETDEV_BOND_ARP_ALL_TARGETS_INVALID = -1,
+ _NETDEV_BOND_ARP_ALL_TARGETS_INVALID = -EINVAL,
} BondArpAllTargets;
typedef enum BondPrimaryReselect {
NETDEV_BOND_PRIMARY_RESELECT_BETTER,
NETDEV_BOND_PRIMARY_RESELECT_FAILURE,
_NETDEV_BOND_PRIMARY_RESELECT_MAX,
- _NETDEV_BOND_PRIMARY_RESELECT_INVALID = -1,
+ _NETDEV_BOND_PRIMARY_RESELECT_INVALID = -EINVAL,
} BondPrimaryReselect;
const char *bond_mode_to_string(BondMode d) _const_;
BOOT_ENTRY_UNIFIED, /* Type #2 entries: *.efi files */
BOOT_ENTRY_LOADER, /* Additional entries augmented from LoaderEntries EFI var */
_BOOT_ENTRY_MAX,
- _BOOT_ENTRY_INVALID = -1,
+ _BOOT_ENTRY_INVALID = -EINVAL,
} BootEntryType;
typedef struct BootEntry {
BUS_TRANSPORT_REMOTE,
BUS_TRANSPORT_MACHINE,
_BUS_TRANSPORT_MAX,
- _BUS_TRANSPORT_INVALID = -1
+ _BUS_TRANSPORT_INVALID = -EINVAL,
} BusTransport;
int bus_async_unregister_and_exit(sd_event *e, sd_bus *bus, const char *name);
BUS_WAIT_FAILURE, /* dito, but something failed */
BUS_WAIT_RUNNING, /* Still something to wait for */
_BUS_WAIT_FOR_UNITS_STATE_MAX,
- _BUS_WAIT_FOR_UNITS_STATE_INVALID = -1,
+ _BUS_WAIT_FOR_UNITS_STATE_INVALID = -EINVAL,
} BusWaitForUnitsState;
typedef enum BusWaitForUnitsFlags {
ORDER_EQUAL,
ORDER_UNEQUAL,
_ORDER_MAX,
- _ORDER_INVALID = -1
+ _ORDER_INVALID = -EINVAL,
} OrderOperator;
static OrderOperator parse_order(const char **s) {
CONDITION_CONTROL_GROUP_CONTROLLER,
_CONDITION_TYPE_MAX,
- _CONDITION_TYPE_INVALID = -1
+ _CONDITION_TYPE_INVALID = -EINVAL,
} ConditionType;
typedef enum ConditionResult {
CONDITION_FAILED,
CONDITION_ERROR,
_CONDITION_RESULT_MAX,
- _CONDITION_RESULT_INVALID = -1
+ _CONDITION_RESULT_INVALID = -EINVAL,
} ConditionResult;
typedef struct Condition {
COREDUMP_FILTER_PRIVATE_DAX,
COREDUMP_FILTER_SHARED_DAX,
_COREDUMP_FILTER_MAX,
- _COREDUMP_FILTER_INVALID = -1,
+ _COREDUMP_FILTER_INVALID = -EINVAL,
} CoredumpFilter;
#define COREDUMP_FILTER_MASK_DEFAULT (1u << COREDUMP_FILTER_PRIVATE_ANONYMOUS | \
IMAGE_PORTABLE,
IMAGE_EXTENSION,
_IMAGE_CLASS_MAX,
- _IMAGE_CLASS_INVALID = -1
+ _IMAGE_CLASS_INVALID = -EINVAL,
} ImageClass;
typedef enum ImageType {
IMAGE_RAW,
IMAGE_BLOCK,
_IMAGE_TYPE_MAX,
- _IMAGE_TYPE_INVALID = -1
+ _IMAGE_TYPE_INVALID = -EINVAL,
} ImageType;
typedef struct Image {
PARTITION_TMP,
PARTITION_VAR,
_PARTITION_DESIGNATOR_MAX,
- _PARTITION_DESIGNATOR_INVALID = -1
+ _PARTITION_DESIGNATOR_INVALID = -EINVAL,
} PartitionDesignator;
static inline PartitionDesignator PARTITION_VERITY_OF(PartitionDesignator p) {
DUP_HALF = DUPLEX_HALF,
DUP_FULL = DUPLEX_FULL,
_DUP_MAX,
- _DUP_INVALID = -1
+ _DUP_INVALID = -EINVAL,
} Duplex;
typedef enum WakeOnLan {
WOL_MAGICSECURE,
WOL_OFF,
_WOL_MAX,
- _WOL_INVALID = -1
+ _WOL_INVALID = -EINVAL,
} WakeOnLan;
typedef enum NetDevFeature {
NET_DEV_FEAT_TSO,
NET_DEV_FEAT_TSO6,
_NET_DEV_FEAT_MAX,
- _NET_DEV_FEAT_INVALID = -1
+ _NET_DEV_FEAT_INVALID = -EINVAL,
} NetDevFeature;
typedef enum NetDevPort {
NET_DEV_PORT_NONE = PORT_NONE,
NET_DEV_PORT_OTHER = PORT_OTHER,
_NET_DEV_PORT_MAX,
- _NET_DEV_PORT_INVALID = -1
+ _NET_DEV_PORT_INVALID = -EINVAL,
} NetDevPort;
#define ETHTOOL_LINK_MODE_MASK_MAX_KERNEL_NU32 (SCHAR_MAX)
TABLE_SET_URL,
TABLE_SET_UPPERCASE,
- _TABLE_DATA_TYPE_INVALID = -1,
+ _TABLE_DATA_TYPE_INVALID = -EINVAL,
} TableDataType;
/* PIDs are just 32bit signed integers on Linux */
NETDEV_GENEVE_DF_SET = GENEVE_DF_SET,
NETDEV_GENEVE_DF_INHERIT = GENEVE_DF_INHERIT,
_NETDEV_GENEVE_DF_MAX,
- _NETDEV_GENEVE_DF_INVALID = -1,
+ _NETDEV_GENEVE_DF_INVALID = -EINVAL,
} GeneveDF;
const char *geneve_df_to_string(GeneveDF d) _const_;
HOSTNAME_STATIC, /* from /etc/hostname */
HOSTNAME_TRANSIENT, /* a transient hostname set through systemd, hostnamed, the container manager, or otherwise */
HOSTNAME_FALLBACK, /* the compiled-in fallback was used */
- _HOSTNAME_INVALID = -1,
+ _HOSTNAME_INVALID = -EINVAL,
} HostnameSource;
const char* hostname_source_to_string(HostnameSource source) _const_;
ID128_PRINT_UUID,
ID128_PRINT_PRETTY,
_ID128_PRETTY_PRINT_MODE_MAX,
- _ID128_PRETTY_PRINT_MODE_INVALID = -1
+ _ID128_PRETTY_PRINT_MODE_INVALID = -EINVAL,
} Id128PrettyPrintMode;
int id128_pretty_print_sample(const char *name, sd_id128_t id);
IMPORT_VERIFY_CHECKSUM,
IMPORT_VERIFY_SIGNATURE,
_IMPORT_VERIFY_MAX,
- _IMPORT_VERIFY_INVALID = -1,
+ _IMPORT_VERIFY_INVALID = -EINVAL,
} ImportVerify;
int import_url_last_component(const char *url, char **ret);
UNIT_FILE_PRESET_ENABLE_ONLY,
UNIT_FILE_PRESET_DISABLE_ONLY,
_UNIT_FILE_PRESET_MAX,
- _UNIT_FILE_PRESET_INVALID = -1
+ _UNIT_FILE_PRESET_INVALID = -EINVAL,
};
enum UnitFileChangeType {
UNIT_FILE_TYPE_SYMLINK,
UNIT_FILE_TYPE_MASKED,
_UNIT_FILE_TYPE_MAX,
- _UNIT_FILE_TYPE_INVALID = -1,
+ _UNIT_FILE_TYPE_INVALID = -EINVAL,
};
struct UnitFileInstallInfo {
NETDEV_IPVLAN_MODE_L3 = IPVLAN_MODE_L3,
NETDEV_IPVLAN_MODE_L3S = IPVLAN_MODE_L3S,
_NETDEV_IPVLAN_MODE_MAX,
- _NETDEV_IPVLAN_MODE_INVALID = -1
+ _NETDEV_IPVLAN_MODE_INVALID = -EINVAL,
} IPVlanMode;
typedef enum IPVlanFlags {
NETDEV_IPVLAN_FLAGS_PRIVATE = IPVLAN_F_PRIVATE,
NETDEV_IPVLAN_FLAGS_VEPA = IPVLAN_F_VEPA,
_NETDEV_IPVLAN_FLAGS_MAX,
- _NETDEV_IPVLAN_FLAGS_INVALID = -1
+ _NETDEV_IPVLAN_FLAGS_INVALID = -EINVAL,
} IPVlanFlags;
const char *ipvlan_mode_to_string(IPVlanMode d) _const_;
JSON_TOKEN_BOOLEAN,
JSON_TOKEN_NULL,
_JSON_TOKEN_MAX,
- _JSON_TOKEN_INVALID = -1,
+ _JSON_TOKEN_INVALID = -EINVAL,
};
int json_tokenize(const char **p, char **ret_string, JsonValue *ret_value, unsigned *ret_line, unsigned *ret_column, void **state, unsigned *line, unsigned *column);
JSON_VARIANT_OBJECT,
JSON_VARIANT_NULL,
_JSON_VARIANT_TYPE_MAX,
- _JSON_VARIANT_TYPE_INVALID = -1
+ _JSON_VARIANT_TYPE_INVALID = -EINVAL,
} JsonVariantType;
int json_variant_new_stringn(JsonVariant **ret, const char *s, size_t n);
NETDEV_MACVLAN_MODE_PASSTHRU = MACVLAN_MODE_PASSTHRU,
NETDEV_MACVLAN_MODE_SOURCE = MACVLAN_MODE_SOURCE,
_NETDEV_MACVLAN_MODE_MAX,
- _NETDEV_MACVLAN_MODE_INVALID = -1
+ _NETDEV_MACVLAN_MODE_INVALID = -EINVAL,
} MacVlanMode;
const char *macvlan_mode_to_string(MacVlanMode d) _const_;
NAMING_V245 = NAMING_V243 | NAMING_NSPAWN_LONG_HASH,
NAMING_V247 = NAMING_V245 | NAMING_BRIDGE_NO_SLOT,
- _NAMING_SCHEME_FLAGS_INVALID = -1,
+ _NAMING_SCHEME_FLAGS_INVALID = -EINVAL,
} NamingSchemeFlags;
typedef struct NamingScheme {
OUTPUT_CAT,
OUTPUT_WITH_UNIT,
_OUTPUT_MODE_MAX,
- _OUTPUT_MODE_INVALID = -1
+ _OUTPUT_MODE_INVALID = -EINVAL,
} OutputMode;
static inline bool OUTPUT_MODE_IS_JSON(OutputMode m) {
RESOLVE_SUPPORT_YES,
RESOLVE_SUPPORT_RESOLVE,
_RESOLVE_SUPPORT_MAX,
- _RESOLVE_SUPPORT_INVALID = -1
+ _RESOLVE_SUPPORT_INVALID = -EINVAL,
};
enum DnssecMode {
DNSSEC_YES,
_DNSSEC_MODE_MAX,
- _DNSSEC_MODE_INVALID = -1
+ _DNSSEC_MODE_INVALID = -EINVAL,
};
enum DnsOverTlsMode {
DNS_OVER_TLS_YES,
_DNS_OVER_TLS_MODE_MAX,
- _DNS_OVER_TLS_MODE_INVALID = -1
+ _DNS_OVER_TLS_MODE_INVALID = -EINVAL,
};
CONFIG_PARSER_PROTOTYPE(config_parse_resolve_support);
RESOLVE_NAME_LATE,
RESOLVE_NAME_EARLY,
_RESOLVE_NAME_TIMING_MAX,
- _RESOLVE_NAME_TIMING_INVALID = -1,
+ _RESOLVE_NAME_TIMING_INVALID = -EINVAL,
} ResolveNameTiming;
ResolveNameTiming resolve_name_timing_from_string(const char *s) _pure_;
USER_CONTAINER, /* UID ranges allocated for container uses */
USER_RESERVED, /* Range above 2^31 */
_USER_DISPOSITION_MAX,
- _USER_DISPOSITION_INVALID = -1,
+ _USER_DISPOSITION_INVALID = -EINVAL,
} UserDisposition;
typedef enum UserHomeStorage {
USER_FSCRYPT,
USER_CIFS,
_USER_STORAGE_MAX,
- _USER_STORAGE_INVALID = -1
+ _USER_STORAGE_INVALID = -EINVAL,
} UserStorage;
typedef enum UserRecordMask {
VARLINK_DISCONNECTED,
_VARLINK_STATE_MAX,
- _VARLINK_STATE_INVALID = -1
+ _VARLINK_STATE_INVALID = -EINVAL,
} VarlinkState;
/* Tests whether we are not yet disconnected. Note that this is true during all states where the connection
VOLATILE_STATE,
VOLATILE_OVERLAY,
_VOLATILE_MODE_MAX,
- _VOLATILE_MODE_INVALID = -1
+ _VOLATILE_MODE_INVALID = -EINVAL,
} VolatileMode;
VolatileMode volatile_mode_from_string(const char *s);
SYSTEMCTL_SHOW_STATUS,
SYSTEMCTL_SHOW_HELP,
_SYSTEMCTL_SHOW_MODE_MAX,
- _SYSTEMCTL_SHOW_MODE_INVALID = -1,
+ _SYSTEMCTL_SHOW_MODE_INVALID = -EINVAL,
} SystemctlShowMode;
static const char* const systemctl_show_mode_table[_SYSTEMCTL_SHOW_MODE_MAX] = {
ACTION_RUNLEVEL,
ACTION_CANCEL_SHUTDOWN,
_ACTION_MAX,
- _ACTION_INVALID = -1
+ _ACTION_INVALID = -EINVAL,
};
enum dependency {
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
+#include <errno.h>
#include <inttypes.h>
#include <net/ethernet.h>
#include <netinet/in.h>
SD_DHCP_LEASE_SMTP,
SD_DHCP_LEASE_LPR,
_SD_DHCP_LEASE_SERVER_TYPE_MAX,
- _SD_DHCP_LEASE_SERVER_TYPE_INVALID = -1,
+ _SD_DHCP_LEASE_SERVER_TYPE_INVALID = -EINVAL,
} sd_dhcp_lease_server_type;
int sd_dhcp_lease_get_address(sd_dhcp_lease *lease, struct in_addr *addr);
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
+#include <errno.h>
#include <inttypes.h>
#include <net/ethernet.h>
#include <sys/types.h>
SD_LLDP_EVENT_UPDATED,
SD_LLDP_EVENT_REFRESHED,
_SD_LLDP_EVENT_MAX,
- _SD_LLDP_EVENT_INVALID = -1,
+ _SD_LLDP_EVENT_INVALID = -EINVAL,
} sd_lldp_event;
typedef void (*sd_lldp_callback_t)(sd_lldp *lldp, sd_lldp_event event, sd_lldp_neighbor *n, void *userdata);
along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/
+#include <errno.h>
#include <inttypes.h>
#include <net/ethernet.h>
#include <netinet/in.h>
SD_NDISC_EVENT_TIMEOUT,
SD_NDISC_EVENT_ROUTER,
_SD_NDISC_EVENT_MAX,
- _SD_NDISC_EVENT_INVALID = -1,
+ _SD_NDISC_EVENT_INVALID = -EINVAL,
} sd_ndisc_event;
typedef void (*sd_ndisc_callback_t)(sd_ndisc *nd, sd_ndisc_event event, sd_ndisc_router *rt, void *userdata);
CREATION_EXISTING,
CREATION_FORCE,
_CREATION_MODE_MAX,
- _CREATION_MODE_INVALID = -1
+ _CREATION_MODE_INVALID = -EINVAL,
} CreationMode;
static const char *const creation_mode_verb_table[_CREATION_MODE_MAX] = {
FEATURE_MRW_W,
_FEATURE_MAX,
- _FEATURE_INVALID = -1,
+ _FEATURE_INVALID = -EINVAL,
} Feature;
typedef enum MediaState {
MEDIA_STATE_COMPLETE = 2,
MEDIA_STATE_OTHER = 3,
_MEDIA_STATE_MAX,
- _MEDIA_STATE_INVALID = -1,
+ _MEDIA_STATE_INVALID = -EINVAL,
} MediaState;
typedef struct Context {
MAC_ADDRESS_POLICY_RANDOM,
MAC_ADDRESS_POLICY_NONE,
_MAC_ADDRESS_POLICY_MAX,
- _MAC_ADDRESS_POLICY_INVALID = -1
+ _MAC_ADDRESS_POLICY_INVALID = -EINVAL,
} MACAddressPolicy;
typedef enum NamePolicy {
NAMEPOLICY_PATH,
NAMEPOLICY_MAC,
_NAMEPOLICY_MAX,
- _NAMEPOLICY_INVALID = -1
+ _NAMEPOLICY_INVALID = -EINVAL,
} NamePolicy;
struct link_config {
UDEV_BUILTIN_UACCESS,
#endif
_UDEV_BUILTIN_MAX,
- _UDEV_BUILTIN_INVALID = -1,
+ _UDEV_BUILTIN_INVALID = -EINVAL,
} UdevBuiltinCommand;
typedef struct UdevBuiltin {
FORMAT_SUBST_ROOT,
FORMAT_SUBST_SYS,
_FORMAT_SUBST_TYPE_MAX,
- _FORMAT_SUBST_TYPE_INVALID = -1
+ _FORMAT_SUBST_TYPE_INVALID = -EINVAL,
} FormatSubstitutionType;
struct subst_map_entry {
OP_ASSIGN, /* = */
OP_ASSIGN_FINAL, /* := */
_OP_TYPE_MAX,
- _OP_TYPE_INVALID = -1
+ _OP_TYPE_INVALID = -EINVAL,
} UdevRuleOperatorType;
typedef enum {
MATCH_TYPE_GLOB_WITH_EMPTY, /* shell globs ?,*,[] with empty string, e.g., "|foo*" */
MATCH_TYPE_SUBSYSTEM, /* "subsystem", "bus", or "class" */
_MATCH_TYPE_MAX,
- _MATCH_TYPE_INVALID = -1
+ _MATCH_TYPE_INVALID = -EINVAL,
} UdevRuleMatchType;
typedef enum {
SUBST_TYPE_FORMAT, /* % or $ */
SUBST_TYPE_SUBSYS, /* "[<SUBSYSTEM>/<KERNEL>]<attribute>" format */
_SUBST_TYPE_MAX,
- _SUBST_TYPE_INVALID = -1
+ _SUBST_TYPE_INVALID = -EINVAL,
} UdevRuleSubstituteType;
typedef enum {
TK_A_RUN_PROGRAM, /* string */
_TK_TYPE_MAX,
- _TK_TYPE_INVALID = -1,
+ _TK_TYPE_INVALID = -EINVAL,
} UdevRuleTokenType;
typedef enum {
ESCAPE_NONE, /* OPTIONS="string_escape=none" */
ESCAPE_REPLACE, /* OPTIONS="string_escape=replace" */
_ESCAPE_TYPE_MAX,
- _ESCAPE_TYPE_INVALID = -1
+ _ESCAPE_TYPE_INVALID = -EINVAL,
} UdevRuleEscapeType;
int udev_rules_parse_file(UdevRules *rules, const char *filename);
OUTPUT_TABLE,
OUTPUT_FRIENDLY,
OUTPUT_JSON,
- _OUTPUT_INVALID = -1
+ _OUTPUT_INVALID = -EINVAL,
} arg_output = _OUTPUT_INVALID;
static PagerFlags arg_pager_flags = 0;
projects / thirdparty / systemd.git / commitdiff
