Enum UnitProperty 

pub enum UnitProperty {
    AddRef(bool),
    After(Vec<String>),
    AllowIsolate(bool),
    AllowedCPUs(Vec<u8>),
    AllowedMemoryNodes(Vec<u8>),
    AmbientCapabilities(u64),
    AppArmorProfile(SecurityLabel),
    Asserts(Vec<Condition>),
    BPFDelegateAttachments(String),
    BPFDelegateCommands(String),
    BPFDelegateMaps(String),
    BPFDelegatePrograms(String),
    BPFProgram(Vec<BpfProgram>),
    Before(Vec<String>),
    BindLogSockets(bool),
    BindNetworkInterface(String),
    BindPaths(Vec<BindPath>),
    BindReadOnlyPaths(Vec<BindPath>),
    BindsTo(Vec<String>),
    BusName(String),
    CPUAffinity(Vec<u8>),
    CPUAffinityFromNUMA(bool),
    CPUPressureThresholdUSec(Usec),
    CPUPressureWatch(CgroupPressureWatch),
    CPUQuotaPerSecUSec(Usec),
    CPUQuotaPeriodUSec(Usec),
    CPUSchedulingPolicy(i32),
    CPUSchedulingPriority(i32),
    CPUSchedulingResetOnFork(bool),
    CPUSetPartition(CpusetPartition),
    CPUWeight(u64),
    CacheDirectory(Vec<String>),
    CacheDirectoryAccounting(bool),
    CacheDirectoryMode(u32),
    CacheDirectoryQuota(DirectoryQuota),
    CacheDirectorySymlink(Vec<DirectorySymlink>),
    CapabilityBoundingSet(u64),
    CollectMode(CollectMode),
    Conditions(Vec<Condition>),
    ConfigurationDirectory(Vec<String>),
    ConfigurationDirectoryMode(u32),
    Conflicts(Vec<String>),
    CoredumpFilter(u64),
    CoredumpReceive(bool),
    DefaultDependencies(bool),
    Delegate(bool),
    DelegateControllers(Vec<String>),
    DelegateNamespaces(u64),
    DelegateSubgroup(String),
    Description(String),
    DeviceAllow(Vec<DeviceAllow>),
    DevicePolicy(CgroupDevicePolicy),
    DisableControllers(Vec<String>),
    Documentation(Vec<String>),
    DynamicUser(bool),
    Environment(Vec<String>),
    EnvironmentFiles(Vec<EnvironmentFile>),
    ExecCondition(Vec<ExecCommand>),
    ExecConditionEx(Vec<ExecCommandEx>),
    ExecPaths(Vec<String>),
    ExecReload(Vec<ExecCommand>),
    ExecReloadEx(Vec<ExecCommandEx>),
    ExecReloadPost(Vec<ExecCommand>),
    ExecReloadPostEx(Vec<ExecCommandEx>),
    ExecSearchPath(Vec<String>),
    ExecStart(Vec<ExecCommand>),
    ExecStartEx(Vec<ExecCommandEx>),
    ExecStartPost(Vec<ExecCommand>),
    ExecStartPostEx(Vec<ExecCommandEx>),
    ExecStartPre(Vec<ExecCommand>),
    ExecStartPreEx(Vec<ExecCommandEx>),
    ExecStop(Vec<ExecCommand>),
    ExecStopEx(Vec<ExecCommandEx>),
    ExecStopPost(Vec<ExecCommand>),
    ExecStopPostEx(Vec<ExecCommandEx>),
    ExitType(ServiceExitType),
    ExtensionDirectories(Vec<String>),
    ExtensionImagePolicy(String),
    ExtensionImages(Vec<ExtensionImage>),
    FailureAction(EmergencyAction),
    FailureActionExitStatus(i32),
    FileDescriptorStoreMax(u32),
    FileDescriptorStorePreserve(ExecPreserveMode),
    FinalKillSignal(i32),
    Group(String),
    GuessMainPID(bool),
    IOAccounting(bool),
    IODeviceLatencyTargetUSec(Vec<DeviceValue>),
    IODeviceWeight(Vec<DeviceValue>),
    IOPressureThresholdUSec(Usec),
    IOPressureWatch(CgroupPressureWatch),
    IOReadBandwidthMax(Vec<DeviceValue>),
    IOReadIOPSMax(Vec<DeviceValue>),
    IOSchedulingClass(i32),
    IOSchedulingPriority(i32),
    IOWeight(u64),
    IOWriteBandwidthMax(Vec<DeviceValue>),
    IOWriteIOPSMax(Vec<DeviceValue>),
    IPAccounting(bool),
    IPAddressAllow(Vec<IpPrefix>),
    IPAddressDeny(Vec<IpPrefix>),
    IPCNamespacePath(String),
    IPEgressFilterPath(Vec<String>),
    IPIngressFilterPath(Vec<String>),
    IgnoreOnIsolate(bool),
    IgnoreSIGPIPE(bool),
    ImportCredential(Vec<String>),
    ImportCredentialEx(Vec<ImportCredential>),
    InaccessibleDirectories(Vec<String>),
    InaccessiblePaths(Vec<String>),
    JobRunningTimeoutUSec(Usec),
    JobTimeoutAction(EmergencyAction),
    JobTimeoutRebootArgument(String),
    JobTimeoutUSec(Usec),
    JoinsNamespaceOf(Vec<String>),
    KeyringMode(ExecKeyringMode),
    KillMode(KillMode),
    KillSignal(i32),
    LimitAS(u64),
    LimitASSoft(u64),
    LimitCORE(u64),
    LimitCORESoft(u64),
    LimitCPU(u64),
    LimitCPUSoft(u64),
    LimitDATA(u64),
    LimitDATASoft(u64),
    LimitFSIZE(u64),
    LimitFSIZESoft(u64),
    LimitLOCKS(u64),
    LimitLOCKSSoft(u64),
    LimitMEMLOCK(u64),
    LimitMEMLOCKSoft(u64),
    LimitMSGQUEUE(u64),
    LimitMSGQUEUESoft(u64),
    LimitNICE(u64),
    LimitNICESoft(u64),
    LimitNOFILE(u64),
    LimitNOFILESoft(u64),
    LimitNPROC(u64),
    LimitNPROCSoft(u64),
    LimitRSS(u64),
    LimitRSSSoft(u64),
    LimitRTPRIO(u64),
    LimitRTPRIOSoft(u64),
    LimitRTTIME(u64),
    LimitRTTIMESoft(u64),
    LimitSIGPENDING(u64),
    LimitSIGPENDINGSoft(u64),
    LimitSTACK(u64),
    LimitSTACKSoft(u64),
    LoadCredential(Vec<LoadCredential>),
    LoadCredentialEncrypted(Vec<LoadCredential>),
    LockPersonality(bool),
    LogExtraFields(Vec<Vec<u8>>),
    LogFilterPatterns(Vec<LogFilterPattern>),
    LogLevelMax(i32),
    LogNamespace(String),
    LogRateLimitBurst(u32),
    LogRateLimitIntervalUSec(Usec),
    LogsDirectory(Vec<String>),
    LogsDirectoryAccounting(bool),
    LogsDirectoryMode(u32),
    LogsDirectoryQuota(DirectoryQuota),
    LogsDirectorySymlink(Vec<DirectorySymlink>),
    ManagedOOMMemoryPressure(ManagedOomMode),
    ManagedOOMMemoryPressureDurationUSec(Usec),
    ManagedOOMMemoryPressureLimit(u32),
    ManagedOOMPreference(ManagedOomPreference),
    ManagedOOMSwap(ManagedOomMode),
    Markers(Vec<String>),
    MemoryAccounting(bool),
    MemoryDenyWriteExecute(bool),
    MemoryHigh(u64),
    MemoryHighScale(u32),
    MemoryKSM(bool),
    MemoryLow(u64),
    MemoryLowScale(u32),
    MemoryMax(u64),
    MemoryMaxScale(u32),
    MemoryMin(u64),
    MemoryMinScale(u32),
    MemoryPressureThresholdUSec(Usec),
    MemoryPressureWatch(CgroupPressureWatch),
    MemorySwapMax(u64),
    MemorySwapMaxScale(u32),
    MemoryTHP(ExecMemoryThp),
    MemoryZSwapMax(u64),
    MemoryZSwapMaxScale(u32),
    MemoryZSwapWriteback(bool),
    MountAPIVFS(bool),
    MountFlags(u64),
    MountImagePolicy(String),
    MountImages(Vec<MountImage>),
    NFTSet(Vec<NftSet>),
    NUMAMask(Vec<u8>),
    NUMAPolicy(i32),
    NetworkNamespacePath(String),
    Nice(i32),
    NoExecPaths(Vec<String>),
    NoNewPrivileges(bool),
    NonBlocking(bool),
    NotifyAccess(NotifyAccess),
    OOMPolicy(OomPolicy),
    OOMRules(Vec<String>),
    OOMScoreAdjust(i32),
    OnFailure(Vec<String>),
    OnFailureJobMode(JobMode),
    OnSuccess(Vec<String>),
    OnSuccessJobMode(JobMode),
    OpenFile(Vec<OpenFile>),
    PAMName(String),
    PIDFile(String),
    PartOf(Vec<String>),
    PassEnvironment(Vec<String>),
    PermissionsStartOnly(bool),
    Personality(String),
    PrivateBPF(PrivateBpf),
    PrivateDevices(bool),
    PrivateIPC(bool),
    PrivateMounts(bool),
    PrivateNetwork(bool),
    PrivatePIDs(PrivatePids),
    PrivateTmp(bool),
    PrivateTmpEx(PrivateTmp),
    PrivateUsers(bool),
    PrivateUsersEx(PrivateUsers),
    ProcSubset(ProcSubset),
    PropagatesReloadTo(Vec<String>),
    PropagatesStopTo(Vec<String>),
    ProtectClock(bool),
    ProtectControlGroups(bool),
    ProtectControlGroupsEx(ProtectControlGroups),
    ProtectHome(ProtectHome),
    ProtectHostname(bool),
    ProtectHostnameEx(ProtectHostnameEx),
    ProtectKernelLogs(bool),
    ProtectKernelModules(bool),
    ProtectKernelTunables(bool),
    ProtectProc(ProtectProc),
    ProtectSystem(ProtectSystem),
    ReadOnlyDirectories(Vec<String>),
    ReadOnlyPaths(Vec<String>),
    ReadWriteDirectories(Vec<String>),
    ReadWritePaths(Vec<String>),
    RebootArgument(String),
    RefreshOnReload(Vec<RefreshOnReload>),
    RefuseManualStart(bool),
    RefuseManualStop(bool),
    ReloadPropagatedFrom(Vec<String>),
    ReloadSignal(i32),
    RemainAfterExit(bool),
    RemoveIPC(bool),
    Requires(Vec<String>),
    RequiresMountsFor(Vec<String>),
    Requisite(Vec<String>),
    RequisiteOverridable(Vec<String>),
    Restart(ServiceRestart),
    RestartForceExitStatus(ExitStatusSet),
    RestartKillSignal(i32),
    RestartMaxDelayUSec(Usec),
    RestartMode(ServiceRestartMode),
    RestartPreventExitStatus(ExitStatusSet),
    RestartSteps(u32),
    RestartUSec(Usec),
    RestrictAddressFamilies(FilterList),
    RestrictFileSystems(FilterList),
    RestrictNamespaces(u64),
    RestrictNetworkInterfaces(FilterList),
    RestrictRealtime(bool),
    RestrictSUIDSGID(bool),
    RootDirectory(String),
    RootDirectoryStartOnly(bool),
    RootEphemeral(bool),
    RootHash(Vec<u8>),
    RootHashPath(String),
    RootHashSignature(Vec<u8>),
    RootHashSignaturePath(String),
    RootImage(String),
    RootImageOptions(Vec<MountOption>),
    RootImagePolicy(String),
    RootMStack(String),
    RootVerity(String),
    RuntimeDirectory(Vec<String>),
    RuntimeDirectoryMode(u32),
    RuntimeDirectoryPreserve(ExecPreserveMode),
    RuntimeDirectorySymlink(Vec<DirectorySymlink>),
    RuntimeMaxUSec(Usec),
    RuntimeRandomizedExtraUSec(Usec),
    SELinuxContext(String),
    SecureBits(i32),
    SendSIGHUP(bool),
    SendSIGKILL(bool),
    SetCredential(Vec<SetCredential>),
    SetCredentialEncrypted(Vec<SetCredential>),
    SetLoginEnvironment(bool),
    Slice(String),
    SmackProcessLabel(SecurityLabel),
    SocketBindAllow(Vec<SocketBind>),
    SocketBindDeny(Vec<SocketBind>),
    SourcePath(String),
    StandardErrorFile(String),
    StandardErrorFileDescriptorName(String),
    StandardErrorFileToAppend(String),
    StandardErrorFileToTruncate(String),
    StandardInputData(Vec<u8>),
    StandardInputFile(String),
    StandardInputFileDescriptorName(String),
    StandardOutputFile(String),
    StandardOutputFileDescriptorName(String),
    StandardOutputFileToAppend(String),
    StandardOutputFileToTruncate(String),
    StartLimitAction(EmergencyAction),
    StartLimitBurst(u32),
    StartLimitIntervalUSec(Usec),
    StartupAllowedCPUs(Vec<u8>),
    StartupAllowedMemoryNodes(Vec<u8>),
    StartupCPUWeight(u64),
    StartupIOWeight(u64),
    StartupMemoryHigh(u64),
    StartupMemoryLow(u64),
    StartupMemoryMax(u64),
    StartupMemorySwapMax(u64),
    StartupMemoryZSwapMax(u64),
    StateDirectory(Vec<String>),
    StateDirectoryAccounting(bool),
    StateDirectoryMode(u32),
    StateDirectoryQuota(DirectoryQuota),
    StateDirectorySymlink(Vec<DirectorySymlink>),
    StopPropagatedFrom(Vec<String>),
    StopWhenUnneeded(bool),
    SuccessAction(EmergencyAction),
    SuccessActionExitStatus(i32),
    SuccessExitStatus(ExitStatusSet),
    SupplementaryGroups(Vec<String>),
    SurviveFinalKillSignal(bool),
    SyslogFacility(i32),
    SyslogIdentifier(String),
    SyslogLevel(i32),
    SyslogLevelPrefix(bool),
    SystemCallArchitectures(Vec<String>),
    SystemCallErrorNumber(i32),
    SystemCallFilter(FilterList),
    SystemCallLog(FilterList),
    TTYColumns(u32),
    TTYPath(String),
    TTYReset(bool),
    TTYRows(u32),
    TTYVHangup(bool),
    TTYVTDisallocate(bool),
    TasksAccounting(bool),
    TasksMax(u64),
    TasksMaxScale(u32),
    TemporaryFileSystem(Vec<TmpFs>),
    TimeoutAbortUSec(Usec),
    TimeoutStartFailureMode(ServiceTimeoutFailureMode),
    TimeoutStartUSec(Usec),
    TimeoutStopFailureMode(ServiceTimeoutFailureMode),
    TimeoutStopUSec(Usec),
    TimerSlackNSec(u64),
    Type(ServiceType),
    UMask(u32),
    USBFunctionDescriptors(String),
    USBFunctionStrings(String),
    UnsetEnvironment(Vec<String>),
    Upholds(Vec<String>),
    User(String),
    UserNamespacePath(String),
    UtmpIdentifier(String),
    UtmpMode(ExecUtmpMode),
    Wants(Vec<String>),
    WantsMountsFor(Vec<String>),
    WatchdogSignal(i32),
    WatchdogUSec(Usec),
    WorkingDirectory(String),
    Custom(Cow<'static, str>, Value<'static>),
}

Every key StartTransientUnit accepts for a .service unit.

Variants

AddRef(bool)

b

After(Vec<String>)

as

AllowIsolate(bool)

b

AllowedCPUs(Vec<u8>)

ay

AllowedMemoryNodes(Vec<u8>)

ay

AmbientCapabilities(u64)

t

AppArmorProfile(SecurityLabel)

(bs)

Asserts(Vec<Condition>)

a(sbbs)

BPFDelegateAttachments(String)

s

BPFDelegateCommands(String)

s

BPFDelegateMaps(String)

s

BPFDelegatePrograms(String)

s

BPFProgram(Vec<BpfProgram>)

a(ss)

Before(Vec<String>)

as

BindLogSockets(bool)

b

BindNetworkInterface(String)

s

BindPaths(Vec<BindPath>)

a(ssbt)

BindReadOnlyPaths(Vec<BindPath>)

a(ssbt)

BindsTo(Vec<String>)

as

BusName(String)

s

CPUAffinity(Vec<u8>)

ay

CPUAffinityFromNUMA(bool)

b

CPUPressureThresholdUSec(Usec)

t

CPUPressureWatch(CgroupPressureWatch)

s

CPUQuotaPerSecUSec(Usec)

t

CPUQuotaPeriodUSec(Usec)

t

CPUSchedulingPolicy(i32)

i

CPUSchedulingPriority(i32)

i

CPUSchedulingResetOnFork(bool)

b

CPUSetPartition(CpusetPartition)

s

CPUWeight(u64)

t

CacheDirectory(Vec<String>)

as

CacheDirectoryAccounting(bool)

b

CacheDirectoryMode(u32)

u

CacheDirectoryQuota(DirectoryQuota)

(tus)

CacheDirectorySymlink(Vec<DirectorySymlink>)

a(sst)

CapabilityBoundingSet(u64)

t

CollectMode(CollectMode)

s

Conditions(Vec<Condition>)

a(sbbs)

ConfigurationDirectory(Vec<String>)

as

ConfigurationDirectoryMode(u32)

u

Conflicts(Vec<String>)

as

CoredumpFilter(u64)

t

CoredumpReceive(bool)

b

DefaultDependencies(bool)

b

Delegate(bool)

b

DelegateControllers(Vec<String>)

as

DelegateNamespaces(u64)

t

DelegateSubgroup(String)

s

Description(String)

s

DeviceAllow(Vec<DeviceAllow>)

a(ss)

DevicePolicy(CgroupDevicePolicy)

s

DisableControllers(Vec<String>)

as

Documentation(Vec<String>)

as

DynamicUser(bool)

b

Environment(Vec<String>)

as

EnvironmentFiles(Vec<EnvironmentFile>)

a(sb)

ExecCondition(Vec<ExecCommand>)

a(sasb)

ExecConditionEx(Vec<ExecCommandEx>)

a(sasas)

ExecPaths(Vec<String>)

as

ExecReload(Vec<ExecCommand>)

a(sasb)

ExecReloadEx(Vec<ExecCommandEx>)

a(sasas)

ExecReloadPost(Vec<ExecCommand>)

a(sasb)

ExecReloadPostEx(Vec<ExecCommandEx>)

a(sasas)

ExecSearchPath(Vec<String>)

as

ExecStart(Vec<ExecCommand>)

a(sasb)

ExecStartEx(Vec<ExecCommandEx>)

a(sasas)

ExecStartPost(Vec<ExecCommand>)

a(sasb)

ExecStartPostEx(Vec<ExecCommandEx>)

a(sasas)

ExecStartPre(Vec<ExecCommand>)

a(sasb)

ExecStartPreEx(Vec<ExecCommandEx>)

a(sasas)

ExecStop(Vec<ExecCommand>)

a(sasb)

ExecStopEx(Vec<ExecCommandEx>)

a(sasas)

ExecStopPost(Vec<ExecCommand>)

a(sasb)

ExecStopPostEx(Vec<ExecCommandEx>)

a(sasas)

ExitType(ServiceExitType)

s

ExtensionDirectories(Vec<String>)

as

ExtensionImagePolicy(String)

s

ExtensionImages(Vec<ExtensionImage>)

a(sba(ss))

FailureAction(EmergencyAction)

s

FailureActionExitStatus(i32)

i

FileDescriptorStoreMax(u32)

u

FileDescriptorStorePreserve(ExecPreserveMode)

s

FinalKillSignal(i32)

i

Group(String)

s

GuessMainPID(bool)

b

IOAccounting(bool)

b

IODeviceLatencyTargetUSec(Vec<DeviceValue>)

a(st)

IODeviceWeight(Vec<DeviceValue>)

a(st)

IOPressureThresholdUSec(Usec)

t

IOPressureWatch(CgroupPressureWatch)

s

IOReadBandwidthMax(Vec<DeviceValue>)

a(st)

IOReadIOPSMax(Vec<DeviceValue>)

a(st)

IOSchedulingClass(i32)

i

IOSchedulingPriority(i32)

i

IOWeight(u64)

t

IOWriteBandwidthMax(Vec<DeviceValue>)

a(st)

IOWriteIOPSMax(Vec<DeviceValue>)

a(st)

IPAccounting(bool)

b

IPAddressAllow(Vec<IpPrefix>)

a(iayu)

IPAddressDeny(Vec<IpPrefix>)

a(iayu)

IPCNamespacePath(String)

s

IPEgressFilterPath(Vec<String>)

as

IPIngressFilterPath(Vec<String>)

as

IgnoreOnIsolate(bool)

b

IgnoreSIGPIPE(bool)

b

ImportCredential(Vec<String>)

as

ImportCredentialEx(Vec<ImportCredential>)

a(ss)

InaccessibleDirectories(Vec<String>)

as

InaccessiblePaths(Vec<String>)

as

JobRunningTimeoutUSec(Usec)

t

JobTimeoutAction(EmergencyAction)

s

JobTimeoutRebootArgument(String)

s

JobTimeoutUSec(Usec)

t

JoinsNamespaceOf(Vec<String>)

as

KeyringMode(ExecKeyringMode)

s

KillMode(KillMode)

s

KillSignal(i32)

i

LimitAS(u64)

t

LimitASSoft(u64)

t

LimitCORE(u64)

t

LimitCORESoft(u64)

t

LimitCPU(u64)

t

LimitCPUSoft(u64)

t

LimitDATA(u64)

t

LimitDATASoft(u64)

t

LimitFSIZE(u64)

t

LimitFSIZESoft(u64)

t

LimitLOCKS(u64)

t

LimitLOCKSSoft(u64)

t

LimitMEMLOCK(u64)

t

LimitMEMLOCKSoft(u64)

t

LimitMSGQUEUE(u64)

t

LimitMSGQUEUESoft(u64)

t

LimitNICE(u64)

t

LimitNICESoft(u64)

t

LimitNOFILE(u64)

t

LimitNOFILESoft(u64)

t

LimitNPROC(u64)

t

LimitNPROCSoft(u64)

t

LimitRSS(u64)

t

LimitRSSSoft(u64)

t

LimitRTPRIO(u64)

t

LimitRTPRIOSoft(u64)

t

LimitRTTIME(u64)

t

LimitRTTIMESoft(u64)

t

LimitSIGPENDING(u64)

t

LimitSIGPENDINGSoft(u64)

t

LimitSTACK(u64)

t

LimitSTACKSoft(u64)

t

LoadCredential(Vec<LoadCredential>)

a(ss)

LoadCredentialEncrypted(Vec<LoadCredential>)

a(ss)

LockPersonality(bool)

b

LogExtraFields(Vec<Vec<u8>>)

aay

LogFilterPatterns(Vec<LogFilterPattern>)

a(bs)

LogLevelMax(i32)

i

LogNamespace(String)

s

LogRateLimitBurst(u32)

u

LogRateLimitIntervalUSec(Usec)

t

LogsDirectory(Vec<String>)

as

LogsDirectoryAccounting(bool)

b

LogsDirectoryMode(u32)

u

LogsDirectoryQuota(DirectoryQuota)

(tus)

LogsDirectorySymlink(Vec<DirectorySymlink>)

a(sst)

ManagedOOMMemoryPressure(ManagedOomMode)

s

ManagedOOMMemoryPressureDurationUSec(Usec)

t

ManagedOOMMemoryPressureLimit(u32)

u

ManagedOOMPreference(ManagedOomPreference)

s

ManagedOOMSwap(ManagedOomMode)

s

Markers(Vec<String>)

as

MemoryAccounting(bool)

b

MemoryDenyWriteExecute(bool)

b

MemoryHigh(u64)

t

MemoryHighScale(u32)

u

MemoryKSM(bool)

b

MemoryLow(u64)

t

MemoryLowScale(u32)

u

MemoryMax(u64)

t

MemoryMaxScale(u32)

u

MemoryMin(u64)

t

MemoryMinScale(u32)

u

MemoryPressureThresholdUSec(Usec)

t

MemoryPressureWatch(CgroupPressureWatch)

s

MemorySwapMax(u64)

t

MemorySwapMaxScale(u32)

u

MemoryTHP(ExecMemoryThp)

s

MemoryZSwapMax(u64)

t

MemoryZSwapMaxScale(u32)

u

MemoryZSwapWriteback(bool)

b

MountAPIVFS(bool)

b

MountFlags(u64)

t

MountImagePolicy(String)

s

MountImages(Vec<MountImage>)

a(ssba(ss))

NFTSet(Vec<NftSet>)

a(iiss)

NUMAMask(Vec<u8>)

ay

NUMAPolicy(i32)

i

NetworkNamespacePath(String)

s

Nice(i32)

i

NoExecPaths(Vec<String>)

as

NoNewPrivileges(bool)

b

NonBlocking(bool)

b

NotifyAccess(NotifyAccess)

s

OOMPolicy(OomPolicy)

s

OOMRules(Vec<String>)

as

OOMScoreAdjust(i32)

i

OnFailure(Vec<String>)

as

OnFailureJobMode(JobMode)

s

OnSuccess(Vec<String>)

as

OnSuccessJobMode(JobMode)

s

OpenFile(Vec<OpenFile>)

a(sst)

PAMName(String)

s

PIDFile(String)

s

PartOf(Vec<String>)

as

PassEnvironment(Vec<String>)

as

PermissionsStartOnly(bool)

b

Personality(String)

s

PrivateBPF(PrivateBpf)

s

PrivateDevices(bool)

b

PrivateIPC(bool)

b

PrivateMounts(bool)

b

PrivateNetwork(bool)

b

PrivatePIDs(PrivatePids)

s

PrivateTmp(bool)

b

PrivateTmpEx(PrivateTmp)

s

PrivateUsers(bool)

b

PrivateUsersEx(PrivateUsers)

s

ProcSubset(ProcSubset)

s

PropagatesReloadTo(Vec<String>)

as

PropagatesStopTo(Vec<String>)

as

ProtectClock(bool)

b

ProtectControlGroups(bool)

b

ProtectControlGroupsEx(ProtectControlGroups)

s

ProtectHome(ProtectHome)

s

ProtectHostname(bool)

b

ProtectHostnameEx(ProtectHostnameEx)

(ss)

ProtectKernelLogs(bool)

b

ProtectKernelModules(bool)

b

ProtectKernelTunables(bool)

b

ProtectProc(ProtectProc)

s

ProtectSystem(ProtectSystem)

s

ReadOnlyDirectories(Vec<String>)

as

ReadOnlyPaths(Vec<String>)

as

ReadWriteDirectories(Vec<String>)

as

ReadWritePaths(Vec<String>)

as

RebootArgument(String)

s

RefreshOnReload(Vec<RefreshOnReload>)

a(bs)

RefuseManualStart(bool)

b

RefuseManualStop(bool)

b

ReloadPropagatedFrom(Vec<String>)

as

ReloadSignal(i32)

i

RemainAfterExit(bool)

b

RemoveIPC(bool)

b

Requires(Vec<String>)

as

RequiresMountsFor(Vec<String>)

as

Requisite(Vec<String>)

as

RequisiteOverridable(Vec<String>)

as

Restart(ServiceRestart)

s

RestartForceExitStatus(ExitStatusSet)

(aiai)

RestartKillSignal(i32)

i

RestartMaxDelayUSec(Usec)

t

RestartMode(ServiceRestartMode)

s

RestartPreventExitStatus(ExitStatusSet)

(aiai)

RestartSteps(u32)

u

RestartUSec(Usec)

t

RestrictAddressFamilies(FilterList)

(bas)

RestrictFileSystems(FilterList)

(bas)

RestrictNamespaces(u64)

t

RestrictNetworkInterfaces(FilterList)

(bas)

RestrictRealtime(bool)

b

RestrictSUIDSGID(bool)

b

RootDirectory(String)

s

RootDirectoryStartOnly(bool)

b

RootEphemeral(bool)

b

RootHash(Vec<u8>)

ay

RootHashPath(String)

s

RootHashSignature(Vec<u8>)

ay

RootHashSignaturePath(String)

s

RootImage(String)

s

RootImageOptions(Vec<MountOption>)

a(ss)

RootImagePolicy(String)

s

RootMStack(String)

s

RootVerity(String)

s

RuntimeDirectory(Vec<String>)

as

RuntimeDirectoryMode(u32)

u

RuntimeDirectoryPreserve(ExecPreserveMode)

s

RuntimeDirectorySymlink(Vec<DirectorySymlink>)

a(sst)

RuntimeMaxUSec(Usec)

t

RuntimeRandomizedExtraUSec(Usec)

t

SELinuxContext(String)

s

SecureBits(i32)

i

SendSIGHUP(bool)

b

SendSIGKILL(bool)

b

SetCredential(Vec<SetCredential>)

a(say)

SetCredentialEncrypted(Vec<SetCredential>)

a(say)

SetLoginEnvironment(bool)

b

Slice(String)

s

SmackProcessLabel(SecurityLabel)

(bs)

SocketBindAllow(Vec<SocketBind>)

a(iiqq)

SocketBindDeny(Vec<SocketBind>)

a(iiqq)

SourcePath(String)

s

StandardErrorFile(String)

s

StandardErrorFileDescriptorName(String)

s

StandardErrorFileToAppend(String)

s

StandardErrorFileToTruncate(String)

s

StandardInputData(Vec<u8>)

ay

StandardInputFile(String)

s

StandardInputFileDescriptorName(String)

s

StandardOutputFile(String)

s

StandardOutputFileDescriptorName(String)

s

StandardOutputFileToAppend(String)

s

StandardOutputFileToTruncate(String)

s

StartLimitAction(EmergencyAction)

s

StartLimitBurst(u32)

u

StartLimitIntervalUSec(Usec)

t

StartupAllowedCPUs(Vec<u8>)

ay

StartupAllowedMemoryNodes(Vec<u8>)

ay

StartupCPUWeight(u64)

t

StartupIOWeight(u64)

t

StartupMemoryHigh(u64)

t

StartupMemoryLow(u64)

t

StartupMemoryMax(u64)

t

StartupMemorySwapMax(u64)

t

StartupMemoryZSwapMax(u64)

t

StateDirectory(Vec<String>)

as

StateDirectoryAccounting(bool)

b

StateDirectoryMode(u32)

u

StateDirectoryQuota(DirectoryQuota)

(tus)

StateDirectorySymlink(Vec<DirectorySymlink>)

a(sst)

StopPropagatedFrom(Vec<String>)

as

StopWhenUnneeded(bool)

b

SuccessAction(EmergencyAction)

s

SuccessActionExitStatus(i32)

i

SuccessExitStatus(ExitStatusSet)

(aiai)

SupplementaryGroups(Vec<String>)

as

SurviveFinalKillSignal(bool)

b

SyslogFacility(i32)

i

SyslogIdentifier(String)

s

SyslogLevel(i32)

i

SyslogLevelPrefix(bool)

b

SystemCallArchitectures(Vec<String>)

as

SystemCallErrorNumber(i32)

i

SystemCallFilter(FilterList)

(bas)

SystemCallLog(FilterList)

(bas)

TTYColumns(u32)

u

TTYPath(String)

s

TTYReset(bool)

b

TTYRows(u32)

u

TTYVHangup(bool)

b

TTYVTDisallocate(bool)

b

TasksAccounting(bool)

b

TasksMax(u64)

t

TasksMaxScale(u32)

u

TemporaryFileSystem(Vec<TmpFs>)

a(ss)

TimeoutAbortUSec(Usec)

t

TimeoutStartFailureMode(ServiceTimeoutFailureMode)

s

TimeoutStartUSec(Usec)

t

TimeoutStopFailureMode(ServiceTimeoutFailureMode)

s

TimeoutStopUSec(Usec)

t

TimerSlackNSec(u64)

t

Type(ServiceType)

s

UMask(u32)

u

USBFunctionDescriptors(String)

s

USBFunctionStrings(String)

s

UnsetEnvironment(Vec<String>)

as

Upholds(Vec<String>)

as

User(String)

s

UserNamespacePath(String)

s

UtmpIdentifier(String)

s

UtmpMode(ExecUtmpMode)

s

Wants(Vec<String>)

as

WantsMountsFor(Vec<String>)

as

WatchdogSignal(i32)

i

WatchdogUSec(Usec)

t

WorkingDirectory(String)

s

Custom(Cow<'static, str>, Value<'static>)

Escape hatch for keys this table does not know.

Implementations

impl UnitProperty

pub fn into_pair(self) -> (Cow<'static, str>, Value<'static>)

Trait Implementations

impl Clone for UnitProperty

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UnitProperty

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.