picnoir/Systemd
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
Systemd/src/core/load-fragment-gperf.gperf.m4

492 lines
56 KiB
Plaintext
Raw Normal View History

load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
%{
tree-wide: adjust fall through comments so that gcc is happy Distcc removes comments, making the comment silencing not work. I know there was a decision against a macro in commit ec251fe7d5bc24b5d38b0853bc5969f3a0ba06e2
2017-11-19 19:06:10 +01:00
#if __GNUC__ >= 7
_Pragma("GCC diagnostic ignored \"-Wimplicit-fallthrough\"")
#endif
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
#include <stddef.h>
tree-wide: drop missing.h
2019-10-31 03:07:23 +01:00
#include "all-units.h"
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
#include "conf-parser.h"
#include "load-fragment.h"
%}
struct ConfigPerfItem;
%null_strings
%language=ANSI-C
%define slot-name section_and_lvalue
%define hash-function-name load_fragment_gperf_hash
%define lookup-function-name load_fragment_gperf_lookup
%readonly-tables
%omit-struct-type
%struct-type
%includes
%%
m4_dnl Define the context options only once
m4_define(`EXEC_CONTEXT_CONFIG_ITEMS',
core: allow setting WorkingDirectory= to the special value ~ If set to ~ the working directory is set to the home directory of the user configured in User=. This change also exposes the existing switch for the working directory that allowed making missing working directories non-fatal. This also changes "machinectl shell" to make use of this to ensure that the invoked shell is by default in the user's home directory. Fixes #1268.
2015-09-23 19:46:23 +02:00
`$1.WorkingDirectory, config_parse_working_directory, 0, offsetof($1, exec_context)
core/load-fragment: refuse units with errors in RootDirectory/RootImage/DynamicUser Behaviour of the service is completely different with the option off, so the service would probably mess up state on disk and do unexpected things.
2017-07-06 19:54:42 +02:00
$1.RootDirectory, config_parse_unit_path_printf, true, offsetof($1, exec_context.root_directory)
$1.RootImage, config_parse_unit_path_printf, true, offsetof($1, exec_context.root_image)
service: add new RootImageOptions feature Allows to specify mount options for RootImage. In case of multi-partition images, the partition number can be prefixed followed by colon. Eg: RootImageOptions=1:ro,dev 2:nosuid nodev In absence of a partition number, 0 is assumed.
2020-06-29 14:19:31 +02:00
$1.RootImageOptions, config_parse_root_image_options, 0, offsetof($1, exec_context)
core: add RootHash and RootVerity service parameters Allow to explicitly pass root hash (explicitly or as a file) and verity device/file as unit options. Take precedence over implicit checks.
2020-06-03 10:50:45 +02:00
$1.RootHash, config_parse_exec_root_hash, 0, offsetof($1, exec_context)
core: add RootHashSignature service parameter Allow to explicitly pass root hash signature as a unit option. Takes precedence over implicit checks.
2020-06-08 15:02:55 +02:00
$1.RootHashSignature, config_parse_exec_root_hash_sig, 0, offsetof($1, exec_context)
core: add RootHash and RootVerity service parameters Allow to explicitly pass root hash (explicitly or as a file) and verity device/file as unit options. Take precedence over implicit checks.
2020-06-03 10:50:45 +02:00
$1.RootVerity, config_parse_unit_path_printf, true, offsetof($1, exec_context.root_verity)
shared/user-util: allow usernames with dots in specific fields People do have usernames with dots, and it makes them very unhappy that systemd doesn't like their that. It seems that there is no actual problem with allowing dots in the username. In particular chown declares ":" as the official separator, and internally in systemd we never rely on "." as the seperator between user and group (nor do we call chown directly). Using dots in the name is probably not a very good idea, but we don't need to care. Debian tools (adduser) do not allow users with dots to be created. This patch allows *existing* names with dots to be used in User, Group, SupplementaryGroups, SocketUser, SocketGroup fields, both in unit files and on the command line. DynamicUsers and sysusers still follow the strict policy. user@.service and tmpfiles already allowed arbitrary user names, and this remains unchanged. Fixes #12754.
2019-08-01 09:58:27 +02:00
$1.User, config_parse_user_group_compat, 0, offsetof($1, exec_context.user)
$1.Group, config_parse_user_group_compat, 0, offsetof($1, exec_context.group)
$1.SupplementaryGroups, config_parse_user_group_strv_compat, 0, offsetof($1, exec_context.supplementary_groups)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
$1.Nice, config_parse_exec_nice, 0, offsetof($1, exec_context)
$1.OOMScoreAdjust, config_parse_exec_oom_score_adjust, 0, offsetof($1, exec_context)
manager: add CoredumpFilter= setting Fixes #6685.
2020-04-04 16:43:25 +02:00
$1.CoredumpFilter, config_parse_exec_coredump_filter, 0, offsetof($1, exec_context)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
$1.IOSchedulingClass, config_parse_exec_io_class, 0, offsetof($1, exec_context)
$1.IOSchedulingPriority, config_parse_exec_io_priority, 0, offsetof($1, exec_context)
$1.CPUSchedulingPolicy, config_parse_exec_cpu_sched_policy, 0, offsetof($1, exec_context)
$1.CPUSchedulingPriority, config_parse_exec_cpu_sched_prio, 0, offsetof($1, exec_context)
$1.CPUSchedulingResetOnFork, config_parse_bool, 0, offsetof($1, exec_context.cpu_sched_reset_on_fork)
$1.CPUAffinity, config_parse_exec_cpu_affinity, 0, offsetof($1, exec_context)
core: introduce NUMAPolicy and NUMAMask options Make possible to set NUMA allocation policy for manager. Manager's policy is by default inherited to all forked off processes. However, it is possible to override the policy on per-service basis. Currently we support, these policies: default, prefer, bind, interleave, local. See man 2 set_mempolicy for details on each policy. Overall NUMA policy actually consists of two parts. Policy itself and bitmask representing NUMA nodes where is policy effective. Node mask can be specified using related option, NUMAMask. Default mask can be overwritten on per-service level.
2019-03-12 18:58:26 +01:00
$1.NUMAPolicy, config_parse_numa_policy, 0, offsetof($1, exec_context.numa_policy.type)
$1.NUMAMask, config_parse_numa_mask, 0, offsetof($1, exec_context.numa_policy)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
$1.UMask, config_parse_mode, 0, offsetof($1, exec_context.umask)
core: properly validate environment data from Environment= lines in unit files
2013-02-11 23:45:59 +01:00
$1.Environment, config_parse_environ, 0, offsetof($1, exec_context.environment)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
$1.EnvironmentFile, config_parse_unit_env_file, 0, offsetof($1, exec_context.environment_files)
execute: Add new PassEnvironment= directive This directive allows passing environment variables from the system manager to spawned services. Variables in the system manager can be set inside a container by passing `--set-env=...` options to systemd-spawn. Tested with an on-disk test.service unit. Tested using multiple variable names on a single line, with an empty setting to clear the current list of variables, with non-existing variables. Tested using `systemd-run -p PassEnvironment=VARNAME` to confirm it works with transient units. Confirmed that `systemctl show` will display the PassEnvironment settings. Checked that man pages are generated correctly. No regressions in `make check`.
2015-09-07 08:06:53 +02:00
$1.PassEnvironment, config_parse_pass_environ, 0, offsetof($1, exec_context.pass_environment)
core: add new UnsetEnvironment= setting for unit files With this setting we can explicitly unset specific variables for processes of a unit, as last step of assembling the environment block for them. This is useful to fix #6407. While we are at it, greatly expand the documentation on how the environment block for forked off processes is assembled.
2017-09-10 12:16:44 +02:00
$1.UnsetEnvironment, config_parse_unset_environ, 0, offsetof($1, exec_context.unset_environment)
core/load-fragment: refuse units with errors in RootDirectory/RootImage/DynamicUser Behaviour of the service is completely different with the option off, so the service would probably mess up state on disk and do unexpected things.
2017-07-06 19:54:42 +02:00
$1.DynamicUser, config_parse_bool, true, offsetof($1, exec_context.dynamic_user)
core/load-fragment: add RemoveIPC= (#7288) PR #3865 introduced RemoveIPC= but the option is not listed in load-fragment-gperf.gperf. So, the option could be used only via d-bus. This adds RemoveIPC= in load-fragment-gperf.gperf. Then, now we can set the option in unit files. Fixes #7281.
2017-11-10 10:15:55 +01:00
$1.RemoveIPC, config_parse_bool, 0, offsetof($1, exec_context.remove_ipc)
core/exec: add a named-descriptor option ("fd") for streams (#4179) This commit adds a `fd` option to `StandardInput=`, `StandardOutput=` and `StandardError=` properties in order to connect standard streams to externally named descriptors provided by some socket units. This option looks for a file descriptor named as the corresponding stream. Custom names can be specified, separated by a colon. If multiple name-matches exist, the first matching fd will be used.
2016-10-18 02:05:49 +02:00
$1.StandardInput, config_parse_exec_input, 0, offsetof($1, exec_context)
$1.StandardOutput, config_parse_exec_output, 0, offsetof($1, exec_context)
$1.StandardError, config_parse_exec_output, 0, offsetof($1, exec_context)
core: add two new unit file settings: StandardInputData= + StandardInputText= Both permit configuring data to pass through STDIN to an invoked process. StandardInputText= accepts a line of text (possibly with embedded C-style escapes as well as unit specifiers), which is appended to the buffer to pass as stdin, followed by a single newline. StandardInputData= is similar, but accepts arbitrary base64 encoded data, and will not resolve specifiers or C-style escapes, nor append newlines. This may be used to pass input/configuration data to services, directly in-line from unit files, either in a cooked or in a more raw format.
2017-10-27 11:33:05 +02:00
$1.StandardInputText, config_parse_exec_input_text, 0, offsetof($1, exec_context)
$1.StandardInputData, config_parse_exec_input_data, 0, offsetof($1, exec_context)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
$1.TTYPath, config_parse_unit_path_printf, 0, offsetof($1, exec_context.tty_path)
$1.TTYReset, config_parse_bool, 0, offsetof($1, exec_context.tty_reset)
$1.TTYVHangup, config_parse_bool, 0, offsetof($1, exec_context.tty_vhangup)
$1.TTYVTDisallocate, config_parse_bool, 0, offsetof($1, exec_context.tty_vt_disallocate)
$1.SyslogIdentifier, config_parse_unit_string_printf, 0, offsetof($1, exec_context.syslog_identifier)
conf-parse: rename config_parse_level() to config_parse_log_level() "level" is a bit too generic, let's clarify what kind of level we are referring to here.
2014-03-03 21:14:07 +01:00
$1.SyslogFacility, config_parse_log_facility, 0, offsetof($1, exec_context.syslog_priority)
$1.SyslogLevel, config_parse_log_level, 0, offsetof($1, exec_context.syslog_priority)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
$1.SyslogLevelPrefix, config_parse_bool, 0, offsetof($1, exec_context.syslog_level_prefix)
core: implement /run/systemd/units/-based path for passing unit info from PID 1 to journald And let's make use of it to implement two new unit settings with it: 1. LogLevelMax= is a new per-unit setting that may be used to configure log priority filtering: set it to LogLevelMax=notice and only messages of level "notice" and lower (i.e. more important) will be processed, all others are dropped. 2. LogExtraFields= is a new per-unit setting for configuring per-unit journal fields, that are implicitly included in every log record generated by the unit's processes. It takes field/value pairs in the form of FOO=BAR. Also, related to this, one exisiting unit setting is ported to this new facility: 3. The invocation ID is now pulled from /run/systemd/units/ instead of cgroupfs xattrs. This substantially relaxes requirements of systemd on the kernel version and the privileges it runs with (specifically, cgroupfs xattrs are not available in containers, since they are stored in kernel memory, and hence are unsafe to permit to lesser privileged code). /run/systemd/units/ is a new directory, which contains a number of files and symlinks encoding the above information. PID 1 creates and manages these files, and journald reads them from there. Note that this is supposed to be a direct path between PID 1 and the journal only, due to the special runtime environment the journal runs in. Normally, today we shouldn't introduce new interfaces that (mis-)use a file system as IPC framework, and instead just an IPC system, but this is very hard to do between the journal and PID 1, as long as the IPC system is a subject PID 1 manages, and itself a client to the journal. This patch cleans up a couple of types used in journal code: specifically we switch to size_t for a couple of memory-sizing values, as size_t is the right choice for everything that is memory. Fixes: #4089 Fixes: #3041 Fixes: #4441
2017-11-02 19:43:32 +01:00
$1.LogLevelMax, config_parse_log_level, 0, offsetof($1, exec_context.log_level_max)
tree-wide: say "ratelimit" not "rate_limit" "ratelimit" is a real word, so we don't need to use the other form anywhere. We had both forms in various places, let's standarize on the shorter and more correct one.
2019-09-19 17:49:14 +02:00
$1.LogRateLimitIntervalSec, config_parse_sec, 0, offsetof($1, exec_context.log_ratelimit_interval_usec)
$1.LogRateLimitBurst, config_parse_unsigned, 0, offsetof($1, exec_context.log_ratelimit_burst)
core: implement /run/systemd/units/-based path for passing unit info from PID 1 to journald And let's make use of it to implement two new unit settings with it: 1. LogLevelMax= is a new per-unit setting that may be used to configure log priority filtering: set it to LogLevelMax=notice and only messages of level "notice" and lower (i.e. more important) will be processed, all others are dropped. 2. LogExtraFields= is a new per-unit setting for configuring per-unit journal fields, that are implicitly included in every log record generated by the unit's processes. It takes field/value pairs in the form of FOO=BAR. Also, related to this, one exisiting unit setting is ported to this new facility: 3. The invocation ID is now pulled from /run/systemd/units/ instead of cgroupfs xattrs. This substantially relaxes requirements of systemd on the kernel version and the privileges it runs with (specifically, cgroupfs xattrs are not available in containers, since they are stored in kernel memory, and hence are unsafe to permit to lesser privileged code). /run/systemd/units/ is a new directory, which contains a number of files and symlinks encoding the above information. PID 1 creates and manages these files, and journald reads them from there. Note that this is supposed to be a direct path between PID 1 and the journal only, due to the special runtime environment the journal runs in. Normally, today we shouldn't introduce new interfaces that (mis-)use a file system as IPC framework, and instead just an IPC system, but this is very hard to do between the journal and PID 1, as long as the IPC system is a subject PID 1 manages, and itself a client to the journal. This patch cleans up a couple of types used in journal code: specifically we switch to size_t for a couple of memory-sizing values, as size_t is the right choice for everything that is memory. Fixes: #4089 Fixes: #3041 Fixes: #4441
2017-11-02 19:43:32 +01:00
$1.LogExtraFields, config_parse_log_extra_fields, 0, offsetof($1, exec_context)
core: drop Capabilities= setting The setting is hardly useful (since its effect is generally reduced to zero due to file system caps), and with the advent of ambient caps an actually useful replacement exists, hence let's get rid of this. I am pretty sure this was unused and our man page already recommended against its use, hence this should be a safe thing to remove.
2016-02-12 23:29:57 +01:00
$1.Capabilities, config_parse_warn_compat, DISABLED_LEGACY, offsetof($1, exec_context)
load-fragment: use DEFINE_CONFIG_PARSE_*() macros
2018-05-29 05:57:06 +02:00
$1.SecureBits, config_parse_exec_secure_bits, 0, offsetof($1, exec_context.secure_bits)
capabilities: keep bounding set in non-inverted format. Change the capability bounding set parser and logic so that the bounding set is kept as a positive set internally. This means that the set reflects those capabilities that we want to keep instead of drop.
2016-01-07 23:00:04 +01:00
$1.CapabilityBoundingSet, config_parse_capability_set, 0, offsetof($1, exec_context.capability_bounding_set)
capabilities: added support for ambient capabilities. This patch adds support for ambient capabilities in service files. The idea with ambient capabilities is that the execed processes can run with non-root user and get some inherited capabilities, without having any need to add the capabilities to the executable file. You need at least Linux 4.3 to use ambient capabilities. SecureBit keep-caps is automatically added when you use ambient capabilities and wish to change the user. An example system service file might look like this: [Unit] Description=Service for testing caps [Service] ExecStart=/usr/bin/sleep 10000 User=nobody AmbientCapabilities=CAP_NET_ADMIN CAP_NET_RAW After starting the service it has these capabilities: CapInh: 0000000000003000 CapPrm: 0000000000003000 CapEff: 0000000000003000 CapBnd: 0000003fffffffff CapAmb: 0000000000003000
2015-12-31 13:54:44 +01:00
$1.AmbientCapabilities, config_parse_capability_set, 0, offsetof($1, exec_context.capability_ambient_set)
util: introduce a proper nsec_t and make use of it where appropriate
2012-05-31 04:27:03 +02:00
$1.TimerSlackNSec, config_parse_nsec, 0, offsetof($1, exec_context.timer_slack_nsec)
load-fragment: drop config_parse_no_new_privileges() and use config_parse_bool() instead
2018-05-25 05:52:12 +02:00
$1.NoNewPrivileges, config_parse_bool, 0, offsetof($1, exec_context.no_new_privileges)
core: add new per-unit setting KeyringMode= for controlling kernel keyring setup Usually, it's a good thing that we isolate the kernel session keyring for the various services and disconnect them from the user keyring. However, in case of the cryptsetup key caching we actually want that multiple instances of the cryptsetup service can share the keys in the root user's user keyring, hence we need to be able to disable this logic for them. This adds KeyringMode=inherit|private|shared: inherit: don't do any keyring magic (this is the default in systemd --user) private: a private keyring as before (default in systemd --system) shared: the new setting
2017-09-14 21:19:05 +02:00
$1.KeyringMode, config_parse_exec_keyring_mode, 0, offsetof($1, exec_context.keyring_mode)
core: rework syscall filter - Allow configuration of an errno error to return from blacklisted syscalls, instead of immediately terminating a process. - Fix parsing logic when libseccomp support is turned off - Only keep the actual syscall set in the ExecContext, and generate the string version only on demand.
2014-02-12 18:28:21 +01:00
m4_ifdef(`HAVE_SECCOMP',
`$1.SystemCallFilter, config_parse_syscall_filter, 0, offsetof($1, exec_context)
core: add a system-wide SystemCallArchitectures= setting This is useful to prohibit execution of non-native processes on systems, for example 32bit binaries on 64bit systems, this lowering the attack service on incorrect syscall and ioctl 32→64bit mappings.
2014-02-13 01:35:27 +01:00
$1.SystemCallArchitectures, config_parse_syscall_archs, 0, offsetof($1, exec_context.syscall_archs)
core: add new RestrictAddressFamilies= switch This new unit settings allows restricting which address families are available to processes. This is an effective way to minimize the attack surface of services, by turning off entire network stacks for them. This is based on seccomp, and does not work on x86-32, since seccomp cannot filter socketcall() syscalls on that platform.
2014-02-25 20:37:03 +01:00
$1.SystemCallErrorNumber, config_parse_syscall_errno, 0, offsetof($1, exec_context)
core: Restrict mmap and mprotect with PAGE_WRITE|PAGE_EXEC (#3319) (#3379) New exec boolean MemoryDenyWriteExecute, when set, installs a seccomp filter to reject mmap(2) with PAGE_WRITE|PAGE_EXEC and mprotect(2) with PAGE_EXEC.
2016-06-03 17:58:18 +02:00
$1.MemoryDenyWriteExecute, config_parse_bool, 0, offsetof($1, exec_context.memory_deny_write_execute)
core:gperf: pass the exec_context struct directly to parse restrict namespaces The RestrictNamespaces= takes yes, no or a list of namespaces types, therefor config_parse_restrict_namespaces() is a bit complex and it operates on the ExecContext, fix this by passing the offset of ExecContext directly otherwise restricting namespaces won't work.
2016-11-14 09:12:21 +01:00
$1.RestrictNamespaces, config_parse_restrict_namespaces, 0, offsetof($1, exec_context)
execute: add a new easy-to-use RestrictRealtime= option to units It takes a boolean value. If true, access to SCHED_RR, SCHED_FIFO and SCHED_DEADLINE is blocked, which my be used to lock up the system.
2016-06-23 01:45:45 +02:00
$1.RestrictRealtime, config_parse_bool, 0, offsetof($1, exec_context.restrict_realtime)
core: expose SUID/SGID restriction as new unit setting RestrictSUIDSGID=
2019-03-20 19:09:09 +01:00
$1.RestrictSUIDSGID, config_parse_bool, 0, offsetof($1, exec_context.restrict_suid_sgid)
seccomp: LockPersonality boolean (#6193) Add LockPersonality boolean to allow locking down personality(2) system call so that the execution domain can't be changed. This may be useful to improve security because odd emulations may be poorly tested and source of vulnerabilities, while system services shouldn't need any weird personalities.
2017-07-04 14:48:18 +02:00
$1.RestrictAddressFamilies, config_parse_address_families, 0, offsetof($1, exec_context)
$1.LockPersonality, config_parse_bool, 0, offsetof($1, exec_context.lock_personality)',
When warning about unsupported options, be more detailed
2014-11-30 16:21:49 +01:00
`$1.SystemCallFilter, config_parse_warn_compat, DISABLED_CONFIGURATION, 0
$1.SystemCallArchitectures, config_parse_warn_compat, DISABLED_CONFIGURATION, 0
$1.SystemCallErrorNumber, config_parse_warn_compat, DISABLED_CONFIGURATION, 0
core: Restrict mmap and mprotect with PAGE_WRITE|PAGE_EXEC (#3319) (#3379) New exec boolean MemoryDenyWriteExecute, when set, installs a seccomp filter to reject mmap(2) with PAGE_WRITE|PAGE_EXEC and mprotect(2) with PAGE_EXEC.
2016-06-03 17:58:18 +02:00
$1.MemoryDenyWriteExecute, config_parse_warn_compat, DISABLED_CONFIGURATION, 0
core: add new RestrictNamespaces= unit file setting This new setting permits restricting whether namespaces may be created and managed by processes started by a unit. It installs a seccomp filter blocking certain invocations of unshare(), clone() and setns(). RestrictNamespaces=no is the default, and does not restrict namespaces in any way. RestrictNamespaces=yes takes away the ability to create or manage any kind of namspace. "RestrictNamespaces=mnt ipc" restricts the creation of namespaces so that only mount and IPC namespaces may be created/managed, but no other kind of namespaces. This setting should be improve security quite a bit as in particular user namespacing was a major source of CVEs in the kernel in the past, and is accessible to unprivileged processes. With this setting the entire attack surface may be removed for system services that do not make use of namespaces.
2016-11-02 03:25:19 +01:00
$1.RestrictNamespaces, config_parse_warn_compat, DISABLED_CONFIGURATION, 0
execute: add a new easy-to-use RestrictRealtime= option to units It takes a boolean value. If true, access to SCHED_RR, SCHED_FIFO and SCHED_DEADLINE is blocked, which my be used to lock up the system.
2016-06-23 01:45:45 +02:00
$1.RestrictRealtime, config_parse_warn_compat, DISABLED_CONFIGURATION, 0
core: fix build failure if seccomp is disabled
2019-04-03 02:23:43 +02:00
$1.RestrictSUIDSGID, config_parse_warn_compat, DISABLED_CONFIGURATION, 0
seccomp: LockPersonality boolean (#6193) Add LockPersonality boolean to allow locking down personality(2) system call so that the execution domain can't be changed. This may be useful to improve security because odd emulations may be poorly tested and source of vulnerabilities, while system services shouldn't need any weird personalities.
2017-07-04 14:48:18 +02:00
$1.RestrictAddressFamilies, config_parse_warn_compat, DISABLED_CONFIGURATION, 0
$1.LockPersonality, config_parse_warn_compat, DISABLED_CONFIGURATION, 0')
core: move config_parse_limit() to the generic conf-parser.[ch] That way we can use it in nspawn. Also, while we are at it, let's rename the call config_parse_rlimit(), i.e. insert the "r", to clarify what kind of limit this is about.
2018-05-03 19:01:21 +02:00
$1.LimitCPU, config_parse_rlimit, RLIMIT_CPU, offsetof($1, exec_context.rlimit)
$1.LimitFSIZE, config_parse_rlimit, RLIMIT_FSIZE, offsetof($1, exec_context.rlimit)
$1.LimitDATA, config_parse_rlimit, RLIMIT_DATA, offsetof($1, exec_context.rlimit)
$1.LimitSTACK, config_parse_rlimit, RLIMIT_STACK, offsetof($1, exec_context.rlimit)
$1.LimitCORE, config_parse_rlimit, RLIMIT_CORE, offsetof($1, exec_context.rlimit)
$1.LimitRSS, config_parse_rlimit, RLIMIT_RSS, offsetof($1, exec_context.rlimit)
$1.LimitNOFILE, config_parse_rlimit, RLIMIT_NOFILE, offsetof($1, exec_context.rlimit)
$1.LimitAS, config_parse_rlimit, RLIMIT_AS, offsetof($1, exec_context.rlimit)
$1.LimitNPROC, config_parse_rlimit, RLIMIT_NPROC, offsetof($1, exec_context.rlimit)
$1.LimitMEMLOCK, config_parse_rlimit, RLIMIT_MEMLOCK, offsetof($1, exec_context.rlimit)
$1.LimitLOCKS, config_parse_rlimit, RLIMIT_LOCKS, offsetof($1, exec_context.rlimit)
$1.LimitSIGPENDING, config_parse_rlimit, RLIMIT_SIGPENDING, offsetof($1, exec_context.rlimit)
$1.LimitMSGQUEUE, config_parse_rlimit, RLIMIT_MSGQUEUE, offsetof($1, exec_context.rlimit)
$1.LimitNICE, config_parse_rlimit, RLIMIT_NICE, offsetof($1, exec_context.rlimit)
$1.LimitRTPRIO, config_parse_rlimit, RLIMIT_RTPRIO, offsetof($1, exec_context.rlimit)
$1.LimitRTTIME, config_parse_rlimit, RLIMIT_RTTIME, offsetof($1, exec_context.rlimit)
doc,core: Read{Write,Only}Paths= and InaccessiblePaths= This patch renames Read{Write,Only}Directories= and InaccessibleDirectories= to Read{Write,Only}Paths= and InaccessiblePaths=, previous names are kept as aliases but they are not advertised in the documentation. Renamed variables: `read_write_dirs` --> `read_write_paths` `read_only_dirs` --> `read_only_paths` `inaccessible_dirs` --> `inaccessible_paths`
2016-07-07 11:17:00 +02:00
$1.ReadWriteDirectories, config_parse_namespace_path_strv, 0, offsetof($1, exec_context.read_write_paths)
$1.ReadOnlyDirectories, config_parse_namespace_path_strv, 0, offsetof($1, exec_context.read_only_paths)
$1.InaccessibleDirectories, config_parse_namespace_path_strv, 0, offsetof($1, exec_context.inaccessible_paths)
$1.ReadWritePaths, config_parse_namespace_path_strv, 0, offsetof($1, exec_context.read_write_paths)
$1.ReadOnlyPaths, config_parse_namespace_path_strv, 0, offsetof($1, exec_context.read_only_paths)
$1.InaccessiblePaths, config_parse_namespace_path_strv, 0, offsetof($1, exec_context.inaccessible_paths)
core: add ability to define arbitrary bind mounts for services This adds two new settings BindPaths= and BindReadOnlyPaths=. They allow defining arbitrary bind mounts specific to particular services. This is particularly useful for services with RootDirectory= set as this permits making specific bits of the host directory available to chrooted services. The two new settings follow the concepts nspawn already possess in --bind= and --bind-ro=, as well as the .nspawn settings Bind= and BindReadOnly= (and these latter options should probably be renamed to BindPaths= and BindReadOnlyPaths= too). Fixes: #3439
2016-11-23 22:21:40 +01:00
$1.BindPaths, config_parse_bind_paths, 0, offsetof($1, exec_context)
$1.BindReadOnlyPaths, config_parse_bind_paths, 0, offsetof($1, exec_context)
core: add new setting TemporaryFileSystem= This introduces a new setting TemporaryFileSystem=. This is useful to hide files not relevant to the processes invoked by unit, while necessary files or directories can be still accessed by combining with Bind{,ReadOnly}Paths=.
2018-02-21 01:17:52 +01:00
$1.TemporaryFileSystem, config_parse_temporary_filesystems, 0, offsetof($1, exec_context)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
$1.PrivateTmp, config_parse_bool, 0, offsetof($1, exec_context.private_tmp)
exec: introduce PrivateDevices= switch to provide services with a private /dev Similar to PrivateNetwork=, PrivateTmp= introduce PrivateDevices= that sets up a private /dev with only the API pseudo-devices like /dev/null, /dev/zero, /dev/random, but not any physical devices in them.
2014-01-20 19:54:51 +01:00
$1.PrivateDevices, config_parse_bool, 0, offsetof($1, exec_context.private_devices)
core: add two new service settings ProtectKernelTunables= and ProtectControlGroups= If enabled, these will block write access to /sys, /proc/sys and /proc/sys/fs/cgroup.
2016-08-22 18:43:59 +02:00
$1.ProtectKernelTunables, config_parse_bool, 0, offsetof($1, exec_context.protect_kernel_tunables)
core:sandbox: Add ProtectKernelModules= option This is useful to turn off explicit module load and unload operations on modular kernels. This option removes CAP_SYS_MODULE from the capability bounding set for the unit, and installs a system call filter to block module system calls. This option will not prevent the kernel from loading modules using the module auto-load feature which is a system wide operation.
2016-10-12 13:31:21 +02:00
$1.ProtectKernelModules, config_parse_bool, 0, offsetof($1, exec_context.protect_kernel_modules)
core: Add ProtectKernelLogs If seccomp is enabled, load the SYSCALL_FILTER_SET_SYSLOG into the seccomp filter set. Drop the CAP_SYSLOG capability.
2019-11-05 02:18:42 +01:00
$1.ProtectKernelLogs, config_parse_bool, 0, offsetof($1, exec_context.protect_kernel_logs)
core: shared: Add ProtectClock= to systemd.exec
2020-01-26 21:23:33 +01:00
$1.ProtectClock, config_parse_bool, 0, offsetof($1, exec_context.protect_clock)
core: add two new service settings ProtectKernelTunables= and ProtectControlGroups= If enabled, these will block write access to /sys, /proc/sys and /proc/sys/fs/cgroup.
2016-08-22 18:43:59 +02:00
$1.ProtectControlGroups, config_parse_bool, 0, offsetof($1, exec_context.protect_control_groups)
core: add new setting NetworkNamespacePath= for configuring a netns by path for a service Fixes: #2741
2019-03-07 16:39:01 +01:00
$1.NetworkNamespacePath, config_parse_unit_path_printf, 0, offsetof($1, exec_context.network_namespace_path)
core: add new LogNamespace= execution setting
2019-11-25 16:22:45 +01:00
$1.LogNamespace, config_parse_log_namespace, 0, offsetof($1, exec_context)
core: add new PrivateUsers= option to service execution This setting adds minimal user namespacing support to a service. When set the invoked processes will run in their own user namespace. Only a trivial mapping will be set up: the root user/group is mapped to root, and the user/group of the service will be mapped to itself, everything else is mapped to nobody. If this setting is used the service runs with no capabilities on the host, but configurable capabilities within the service. This setting is particularly useful in conjunction with RootDirectory= as the need to synchronize /etc/passwd and /etc/group between the host and the service OS tree is reduced, as only three UID/GIDs need to match: root, nobody and the user of the service itself. But even outside the RootDirectory= case this setting is useful to substantially reduce the attack surface of a service. Example command to test this: systemd-run -p PrivateUsers=1 -p User=foobar -t /bin/sh This runs a shell as user "foobar". When typing "ps" only processes owned by "root", by "foobar", and by "nobody" should be visible.
2016-08-03 18:44:51 +02:00
$1.PrivateNetwork, config_parse_bool, 0, offsetof($1, exec_context.private_network)
$1.PrivateUsers, config_parse_bool, 0, offsetof($1, exec_context.private_users)
core: add new PrivateMounts= unit setting This new setting is supposed to be useful in most cases where "MountFlags=slave" is currently used, i.e. as an explicit way to run a service in its own mount namespace and decouple propagation from all mounts of the new mount namespace towards the host. The effect of MountFlags=slave and PrivateMounts=yes is mostly the same, as both cause a CLONE_NEWNS namespace to be opened, and both will result in all mounts within it to be mounted MS_SLAVE. The difference is mostly on the conceptual/philosophical level: configuring the propagation mode is nothing people should have to think about, in particular as the matter is not precisely easyto grok. Moreover, MountFlags= allows configuration of "private" and "slave" modes which don't really make much sense to use in real-life and are quite confusing. In particular PrivateMounts=private means mounts made on the host stay pinned for good by the service which is particularly nasty for removable media mount. And PrivateMounts=shared is in most ways a NOP when used a alone... The main technical difference between setting only MountFlags=slave or only PrivateMounts=yes in a unit file is that the former remounts all mounts to MS_SLAVE and leaves them there, while that latter remounts them to MS_SHARED again right after. The latter is generally a nicer approach, since it disables propagation, while MS_SHARED is afterwards in effect, which is really nice as that means further namespacing down the tree will get MS_SHARED logic by default and we unify how applications see our mounts as we always pass them as MS_SHARED regardless whether any mount namespacing is used or not. The effect of PrivateMounts=yes was implied already by all the other mount namespacing options. With this new option we add an explicit knob for it, to request it without any other option used as well. See: #4393
2018-06-01 11:10:49 +02:00
$1.PrivateMounts, config_parse_bool, 0, offsetof($1, exec_context.private_mounts)
namespace: rename parse_protect_{home,system}_or_bool() to protect_{home,system}_or_bool_to_string() Hence, we can define config_parse_protect_{home,system}() by using DEFINE_CONFIG_PARSE_ENUM() macro.
2018-05-29 05:44:57 +02:00
$1.ProtectSystem, config_parse_protect_system, 0, offsetof($1, exec_context.protect_system)
$1.ProtectHome, config_parse_protect_home, 0, offsetof($1, exec_context.protect_home)
load-fragment: use DEFINE_CONFIG_PARSE_*() macros
2018-05-29 05:57:06 +02:00
$1.MountFlags, config_parse_exec_mount_flags, 0, offsetof($1, exec_context.mount_flags)
core: add a per-unit setting MountAPIVFS= for mounting /dev, /proc, /sys in conjunction with RootDirectory= This adds a boolean unit file setting MountAPIVFS=. If set, the three main API VFS mounts will be mounted for the service. This only has an effect on RootDirectory=, which it makes a ton times more useful. (This is basically the /dev + /proc + /sys mounting code posted in the original #4727, but rebased on current git, and with the automatic logic replaced by explicit logic controlled by a unit file setting)
2016-12-22 23:34:35 +01:00
$1.MountAPIVFS, config_parse_bool, 0, offsetof($1, exec_context.mount_apivfs)
core: add Personality= option for units to set the personality for spawned processes
2014-02-19 02:15:24 +01:00
$1.Personality, config_parse_personality, 0, offsetof($1, exec_context.personality)
core: allow preserving contents of RuntimeDirectory= over process restart This introduces RuntimeDirectoryPreserve= option which takes a boolean argument or 'restart'. Closes #6087.
2017-07-17 09:22:25 +02:00
$1.RuntimeDirectoryPreserve, config_parse_runtime_preserve_mode, 0, offsetof($1, exec_context.runtime_directory_preserve_mode)
core: add {State,Cache,Log,Configuration}Directory= (#6384) This introduces {State,Cache,Log,Configuration}Directory= those are similar to RuntimeDirectory=. They create the directories under /var/lib, /var/cache/, /var/log, or /etc, respectively, with the mode specified in {State,Cache,Log,Configuration}DirectoryMode=. This also fixes #6391.
2017-07-18 14:34:52 +02:00
$1.RuntimeDirectoryMode, config_parse_mode, 0, offsetof($1, exec_context.directories[EXEC_DIRECTORY_RUNTIME].mode)
$1.RuntimeDirectory, config_parse_exec_directories, 0, offsetof($1, exec_context.directories[EXEC_DIRECTORY_RUNTIME].paths)
core: fix typo (#6417)
2017-07-21 10:36:39 +02:00
$1.StateDirectoryMode, config_parse_mode, 0, offsetof($1, exec_context.directories[EXEC_DIRECTORY_STATE].mode)
$1.StateDirectory, config_parse_exec_directories, 0, offsetof($1, exec_context.directories[EXEC_DIRECTORY_STATE].paths)
core: add {State,Cache,Log,Configuration}Directory= (#6384) This introduces {State,Cache,Log,Configuration}Directory= those are similar to RuntimeDirectory=. They create the directories under /var/lib, /var/cache/, /var/log, or /etc, respectively, with the mode specified in {State,Cache,Log,Configuration}DirectoryMode=. This also fixes #6391.
2017-07-18 14:34:52 +02:00
$1.CacheDirectoryMode, config_parse_mode, 0, offsetof($1, exec_context.directories[EXEC_DIRECTORY_CACHE].mode)
$1.CacheDirectory, config_parse_exec_directories, 0, offsetof($1, exec_context.directories[EXEC_DIRECTORY_CACHE].paths)
$1.LogsDirectoryMode, config_parse_mode, 0, offsetof($1, exec_context.directories[EXEC_DIRECTORY_LOGS].mode)
$1.LogsDirectory, config_parse_exec_directories, 0, offsetof($1, exec_context.directories[EXEC_DIRECTORY_LOGS].paths)
$1.ConfigurationDirectoryMode, config_parse_mode, 0, offsetof($1, exec_context.directories[EXEC_DIRECTORY_CONFIGURATION].mode)
$1.ConfigurationDirectory, config_parse_exec_directories, 0, offsetof($1, exec_context.directories[EXEC_DIRECTORY_CONFIGURATION].paths)
core: move timeout_clean_usec from Service to ExecContext
2019-08-25 10:47:57 +02:00
$1.TimeoutCleanSec, config_parse_sec, 0, offsetof($1, exec_context.timeout_clean_usec)
core: ProtectHostname= feature Let services use a private UTS namespace. In addition, a seccomp filter is installed on set{host,domain}name and a ro bind mounts on /proc/sys/kernel/{host,domain}name.
2019-02-08 18:25:00 +01:00
$1.ProtectHostname, config_parse_bool, 0, offsetof($1, exec_context.protect_hostname)
core: warn when unit files with unsupported options are parsed
2014-02-17 17:49:09 +01:00
m4_ifdef(`HAVE_PAM',
`$1.PAMName, config_parse_unit_string_printf, 0, offsetof($1, exec_context.pam_name)',
When warning about unsupported options, be more detailed
2014-11-30 16:21:49 +01:00
`$1.PAMName, config_parse_warn_compat, DISABLED_CONFIGURATION, 0')
service: ignore SIGPIPE by default
2012-02-09 03:18:04 +01:00
$1.IgnoreSIGPIPE, config_parse_bool, 0, offsetof($1, exec_context.ignore_sigpipe)
exec: Add SELinuxContext configuration item This permit to let system administrators decide of the domain of a service. This can be used with templated units to have each service in a différent domain ( for example, a per customer database, using MLS or anything ), or can be used to force a non selinux enabled system (jvm, erlang, etc) to start in a different domain for each service.
2014-02-06 10:05:16 +01:00
$1.UtmpIdentifier, config_parse_unit_string_printf, 0, offsetof($1, exec_context.utmp_id)
core: optionally create LOGIN_PROCESS or USER_PROCESS utmp entries When generating utmp/wtmp entries, optionally add both LOGIN_PROCESS and INIT_PROCESS entries or even all three of LOGIN_PROCESS, INIT_PROCESS and USER_PROCESS entries, instead of just a single INIT_PROCESS entry. With this change systemd may be used to not only invoke a getty directly in a SysV-compliant way but alternatively also a login(1) implementation or even forego getty and login entirely, and invoke arbitrary shells in a way that they appear in who(1) or w(1). This is preparation for a later commit that adds a "machinectl shell" operation to invoke a shell in a container, in a way that is compatible with who(1) and w(1).
2015-08-23 13:14:04 +02:00
$1.UtmpMode, config_parse_exec_utmp_mode, 0, offsetof($1, exec_context.utmp_mode)
core: warn when unit files with unsupported options are parsed
2014-02-17 17:49:09 +01:00
m4_ifdef(`HAVE_SELINUX',
`$1.SELinuxContext, config_parse_exec_selinux_context, 0, offsetof($1, exec_context)',
When warning about unsupported options, be more detailed
2014-11-30 16:21:49 +01:00
`$1.SELinuxContext, config_parse_warn_compat, DISABLED_CONFIGURATION, 0')
core: Add AppArmor profile switching This permit to switch to a specific apparmor profile when starting a daemon. This will result in a non operation if apparmor is disabled. It also add a new build requirement on libapparmor for using this feature.
2014-02-20 16:19:44 +01:00
m4_ifdef(`HAVE_APPARMOR',
smack: introduce new SmackProcessLabel option In service file, if the file has some of special SMACK label in ExecStart= and systemd has no permission for the special SMACK label then permission error will occurred. To resolve this, systemd should be able to set its SMACK label to something accessible of ExecStart=. So introduce new SmackProcessLabel. If label is specified with SmackProcessLabel= then the child systemd will set its label to that. To successfully execute the ExecStart=, accessible label should be specified with SmackProcessLabel=. Additionally, by SMACK policy, if the file in ExecStart= has no SMACK64EXEC then the executed process will have given label by SmackProcessLabel=. But if the file has SMACK64EXEC then the SMACK64EXEC label will be overridden. [zj: reword man page]
2014-11-24 12:46:20 +01:00
`$1.AppArmorProfile, config_parse_exec_apparmor_profile, 0, offsetof($1, exec_context)',
When warning about unsupported options, be more detailed
2014-11-30 16:21:49 +01:00
`$1.AppArmorProfile, config_parse_warn_compat, DISABLED_CONFIGURATION, 0')
build-sys: s/HAVE_SMACK/ENABLE_SMACK/ Same justification as for HAVE_UTMP.
2017-10-03 12:22:40 +02:00
m4_ifdef(`ENABLE_SMACK',
smack: introduce new SmackProcessLabel option In service file, if the file has some of special SMACK label in ExecStart= and systemd has no permission for the special SMACK label then permission error will occurred. To resolve this, systemd should be able to set its SMACK label to something accessible of ExecStart=. So introduce new SmackProcessLabel. If label is specified with SmackProcessLabel= then the child systemd will set its label to that. To successfully execute the ExecStart=, accessible label should be specified with SmackProcessLabel=. Additionally, by SMACK policy, if the file in ExecStart= has no SMACK64EXEC then the executed process will have given label by SmackProcessLabel=. But if the file has SMACK64EXEC then the SMACK64EXEC label will be overridden. [zj: reword man page]
2014-11-24 12:46:20 +01:00
`$1.SmackProcessLabel, config_parse_exec_smack_process_label, 0, offsetof($1, exec_context)',
When warning about unsupported options, be more detailed
2014-11-30 16:21:49 +01:00
`$1.SmackProcessLabel, config_parse_warn_compat, DISABLED_CONFIGURATION, 0')'
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
)m4_dnl
unit: split off KillContext from ExecContext containing only kill definitions
2012-07-19 23:47:10 +02:00
m4_define(`KILL_CONTEXT_CONFIG_ITEMS',
util: rename parse_usec() to parse_sec() sinds the default unit is seconds Internally we store all time values in usec_t, however parse_usec() actually was used mostly to parse values in seconds (unless explicit units were specified to define a different unit). Hence, be clear about this and name the function about what we pass into it, not what we get out of it.
2013-04-02 20:38:16 +02:00
`$1.SendSIGKILL, config_parse_bool, 0, offsetof($1, kill_context.send_sigkill)
core: optionally send SIGHUP in addition to the configured kill signal This is useful to fake session ends for processes like shells.
2013-07-30 01:54:59 +02:00
$1.SendSIGHUP, config_parse_bool, 0, offsetof($1, kill_context.send_sighup)
unit: split off KillContext from ExecContext containing only kill definitions
2012-07-19 23:47:10 +02:00
$1.KillMode, config_parse_kill_mode, 0, offsetof($1, kill_context.kill_mode)
Make final kill signal configurable Usecase is to allow changing the final kill from SIGKILL to SIGQUIT which should create a core dump useful for debugging why the service didn't stop with the SIGTERM
2018-07-20 17:22:43 +02:00
$1.KillSignal, config_parse_signal, 0, offsetof($1, kill_context.kill_signal)
core: add support for RestartKillSignal= to override signal used for restart jobs v2: - if RestartKillSignal= is not specified, fall back to KillSignal=. This is necessary to preserve backwards compatibility (and keep KillSignal= generally useful).
2019-10-01 15:15:06 +02:00
$1.RestartKillSignal, config_parse_signal, 0, offsetof($1, kill_context.restart_kill_signal)
Make Watchdog Signal Configurable Allows configuring the watchdog signal (with a default of SIGABRT). This allows an alternative to SIGABRT when coredumps are not desirable. Appropriate references to SIGABRT or aborting were renamed to reflect more liberal watchdog signals. Closes #8658
2018-09-19 21:03:01 +02:00
$1.FinalKillSignal, config_parse_signal, 0, offsetof($1, kill_context.final_kill_signal)
$1.WatchdogSignal, config_parse_signal, 0, offsetof($1, kill_context.watchdog_signal)'
unit: split off KillContext from ExecContext containing only kill definitions
2012-07-19 23:47:10 +02:00
)m4_dnl
core: add new .slice unit type for partitioning systems In order to prepare for the kernel cgroup rework, let's introduce a new unit type to systemd, the "slice". Slices can be arranged in a tree and are useful to partition resources freely and hierarchally by the user. Each service unit can now be assigned to one of these slices, and later on login users and machines may too. Slices translate pretty directly to the cgroup hierarchy, and the various objects can be assigned to any of the slices in the tree.
2013-06-17 21:33:26 +02:00
m4_define(`CGROUP_CONTEXT_CONFIG_ITEMS',
core: parse Slice= from the unit type specific unit file section Since not all unit types know Slice= it belongs in the unit type specific unit file section.
2013-07-01 02:52:17 +02:00
`$1.Slice, config_parse_unit_slice, 0, 0
pid1: fix the names of AllowedCPUs= and AllowedMemoryNodes= The original PR was submitted with CPUSetCpus and CPUSetMems, which was later changed to AllowedCPUs and AllowedMemmoryNodes everywhere (including the parser used by systemd-run), but not in the parser for unit files. Since we already released -rc1, let's keep support for the old names. I think we can remove it in a release or two if anyone remembers to do that. Fixes #14126. Follow-up for 047f5d63d7a1ab75073f8485e2f9b550d25b0772.
2019-11-24 14:14:43 +01:00
$1.AllowedCPUs, config_parse_allowed_cpus, 0, offsetof($1, cgroup_context)
$1.AllowedMemoryNodes, config_parse_allowed_mems, 0, offsetof($1, cgroup_context)
core: parse Slice= from the unit type specific unit file section Since not all unit types know Slice= it belongs in the unit type specific unit file section.
2013-07-01 02:52:17 +02:00
$1.CPUAccounting, config_parse_bool, 0, offsetof($1, cgroup_context.cpu_accounting)
load-fragment: use DEFINE_CONFIG_PARSE_*() macros
2018-05-29 05:57:06 +02:00
$1.CPUWeight, config_parse_cg_weight, 0, offsetof($1, cgroup_context.cpu_weight)
$1.StartupCPUWeight, config_parse_cg_weight, 0, offsetof($1, cgroup_context.startup_cpu_weight)
cgroup: rework startup logic Introduce a (unsigned long) -1 as "unset" state for cpu shares/block io weights, and keep the startup unit set around all the time.
2014-05-22 00:06:16 +02:00
$1.CPUShares, config_parse_cpu_shares, 0, offsetof($1, cgroup_context.cpu_shares)
$1.StartupCPUShares, config_parse_cpu_shares, 0, offsetof($1, cgroup_context.startup_cpu_shares)
core: expose CFS CPU time quota as high-level unit properties
2014-04-25 13:27:25 +02:00
$1.CPUQuota, config_parse_cpu_quota, 0, offsetof($1, cgroup_context)
core: add CPUQuotaPeriodSec= This new setting allows configuration of CFS period on the CPU cgroup, instead of using a hardcoded default of 100ms. Tested: - Legacy cgroup + Unified cgroup - systemctl set-property - systemctl show - Confirmed that the cgroup settings (such as cpu.cfs_period_ns) were set appropriately, including updating the CPU quota (cpu.cfs_quota_ns) when CPUQuotaPeriodSec= is updated. - Checked that clamping works properly when either period or (quota * period) are below the resolution of 1ms, or if period is above the max of 1s.
2018-11-02 17:21:57 +01:00
$1.CPUQuotaPeriodSec, config_parse_sec_def_infinity, 0, offsetof($1, cgroup_context.cpu_quota_period_usec)
core: general cgroup rework Replace the very generic cgroup hookup with a much simpler one. With this change only the high-level cgroup settings remain, the ability to set arbitrary cgroup attributes is removed, so is support for adding units to arbitrary cgroup controllers or setting arbitrary paths for them (especially paths that are different for the various controllers). This also introduces a new -.slice root slice, that is the parent of system.slice and friends. This enables easy admin configuration of root-level cgrouo properties. This replaces DeviceDeny= by DevicePolicy=, and implicitly adds in /dev/null, /dev/zero and friends if DeviceAllow= is used (unless this is turned off by DevicePolicy=).
2013-06-27 04:14:27 +02:00
$1.MemoryAccounting, config_parse_bool, 0, offsetof($1, cgroup_context.memory_accounting)
core: add MemoryMin The kernel added support for a new cgroup memory controller knob memory.min in bf8d5d52ffe8 ("memcg: introduce memory.min") which was merged during v4.18 merge window. Add MemoryMin to support memory.min.
2018-06-09 02:33:14 +02:00
$1.MemoryMin, config_parse_memory_limit, 0, offsetof($1, cgroup_context)
cgroup: Readd some plumbing for DefaultMemoryMin Somehow these got lost in the previous PR, rendering DefaultMemoryMin not very useful.
2019-05-03 14:19:05 +02:00
$1.DefaultMemoryMin, config_parse_memory_limit, 0, offsetof($1, cgroup_context)
cgroup: Implement default propagation of MemoryLow with DefaultMemoryLow In cgroup v2 we have protection tunables -- currently MemoryLow and MemoryMin (there will be more in future for other resources, too). The design of these protection tunables requires not only intermediate cgroups to propagate protections, but also the units at the leaf of that resource's operation to accept it (by setting MemoryLow or MemoryMin). This makes sense from an low-level API design perspective, but it's a good idea to also have a higher-level abstraction that can, by default, propagate these resources to children recursively. In this patch, this happens by having descendants set memory.low to N if their ancestor has DefaultMemoryLow=N -- assuming they don't set a separate MemoryLow value. Any affected unit can opt out of this propagation by manually setting `MemoryLow` to some value in its unit configuration. A unit can also stop further propagation by setting `DefaultMemoryLow=` with no argument. This removes further propagation in the subtree, but has no effect on the unit itself (for that, use `MemoryLow=0`). Our use case in production is simplifying the configuration of machines which heavily rely on memory protection tunables, but currently require tweaking a huge number of unit files to make that a reality. This directive makes that significantly less fragile, and decreases the risk of misconfiguration. After this patch is merged, I will implement DefaultMemoryMin= using the same principles.
2019-03-28 13:50:50 +01:00
$1.DefaultMemoryLow, config_parse_memory_limit, 0, offsetof($1, cgroup_context)
core: add cgroup memory controller support on the unified hierarchy (#3315) On the unified hierarchy, memory controller implements three control knobs - low, high and max which enables more useable and versatile control over memory usage. This patch implements support for the three control knobs. * MemoryLow, MemoryHigh and MemoryMax are added for memory.low, memory.high and memory.max, respectively. * As all absolute limits on the unified hierarchy use "max" for no limit, make memory limit parse functions accept "max" in addition to "infinity" and document "max" for the new knobs. * Implement compatibility translation between MemoryMax and MemoryLimit. v2: - Fixed missing else's in config_parse_memory_limit(). - Fixed missing newline when writing out drop-ins. - Coding style updates to use "val > 0" instead of "val". - Minor updates to documentation.
2016-05-27 18:10:18 +02:00
$1.MemoryLow, config_parse_memory_limit, 0, offsetof($1, cgroup_context)
$1.MemoryHigh, config_parse_memory_limit, 0, offsetof($1, cgroup_context)
$1.MemoryMax, config_parse_memory_limit, 0, offsetof($1, cgroup_context)
core: introduce MemorySwapMax= Similar to MemoryMax=, MemorySwapMax= limits swap usage. This controls controls "memory.swap.max" attribute in unified cgroup.
2016-07-04 09:03:54 +02:00
$1.MemorySwapMax, config_parse_memory_limit, 0, offsetof($1, cgroup_context)
core: general cgroup rework Replace the very generic cgroup hookup with a much simpler one. With this change only the high-level cgroup settings remain, the ability to set arbitrary cgroup attributes is removed, so is support for adding units to arbitrary cgroup controllers or setting arbitrary paths for them (especially paths that are different for the various controllers). This also introduces a new -.slice root slice, that is the parent of system.slice and friends. This enables easy admin configuration of root-level cgrouo properties. This replaces DeviceDeny= by DevicePolicy=, and implicitly adds in /dev/null, /dev/zero and friends if DeviceAllow= is used (unless this is turned off by DevicePolicy=).
2013-06-27 04:14:27 +02:00
$1.MemoryLimit, config_parse_memory_limit, 0, offsetof($1, cgroup_context)
$1.DeviceAllow, config_parse_device_allow, 0, offsetof($1, cgroup_context)
$1.DevicePolicy, config_parse_device_policy, 0, offsetof($1, cgroup_context.device_policy)
core: add io controller support on the unified hierarchy On the unified hierarchy, blkio controller is renamed to io and the interface is changed significantly. * blkio.weight and blkio.weight_device are consolidated into io.weight which uses the standardized weight range [1, 10000] with 100 as the default value. * blkio.throttle.{read|write}_{bps|iops}_device are consolidated into io.max. Expansion of throttling features is being worked on to support work-conserving absolute limits (io.low and io.high). * All stats are consolidated into io.stats. This patchset adds support for the new interface. As the interface has been revamped and new features are expected to be added, it seems best to treat it as a separate controller rather than trying to expand the blkio settings although we might add automatic translation if only blkio settings are specified. * io.weight handling is mostly identical to blkio.weight[_device] handling except that the weight range is different. * Both read and write bandwidth settings are consolidated into CGroupIODeviceLimit which describes all limits applicable to the device. This makes it less painful to add new limits. * "max" can be used to specify the maximum limit which is equivalent to no config for max limits and treated as such. If a given CGroupIODeviceLimit doesn't contain any non-default configs, the config struct is discarded once the no limit config is applied to cgroup. * lookup_blkio_device() is renamed to lookup_block_device(). Signed-off-by: Tejun Heo <htejun@fb.com>
2016-05-05 22:42:55 +02:00
$1.IOAccounting, config_parse_bool, 0, offsetof($1, cgroup_context.io_accounting)
load-fragment: use DEFINE_CONFIG_PARSE_*() macros
2018-05-29 05:57:06 +02:00
$1.IOWeight, config_parse_cg_weight, 0, offsetof($1, cgroup_context.io_weight)
$1.StartupIOWeight, config_parse_cg_weight, 0, offsetof($1, cgroup_context.startup_io_weight)
core: add io controller support on the unified hierarchy On the unified hierarchy, blkio controller is renamed to io and the interface is changed significantly. * blkio.weight and blkio.weight_device are consolidated into io.weight which uses the standardized weight range [1, 10000] with 100 as the default value. * blkio.throttle.{read|write}_{bps|iops}_device are consolidated into io.max. Expansion of throttling features is being worked on to support work-conserving absolute limits (io.low and io.high). * All stats are consolidated into io.stats. This patchset adds support for the new interface. As the interface has been revamped and new features are expected to be added, it seems best to treat it as a separate controller rather than trying to expand the blkio settings although we might add automatic translation if only blkio settings are specified. * io.weight handling is mostly identical to blkio.weight[_device] handling except that the weight range is different. * Both read and write bandwidth settings are consolidated into CGroupIODeviceLimit which describes all limits applicable to the device. This makes it less painful to add new limits. * "max" can be used to specify the maximum limit which is equivalent to no config for max limits and treated as such. If a given CGroupIODeviceLimit doesn't contain any non-default configs, the config struct is discarded once the no limit config is applied to cgroup. * lookup_blkio_device() is renamed to lookup_block_device(). Signed-off-by: Tejun Heo <htejun@fb.com>
2016-05-05 22:42:55 +02:00
$1.IODeviceWeight, config_parse_io_device_weight, 0, offsetof($1, cgroup_context)
$1.IOReadBandwidthMax, config_parse_io_limit, 0, offsetof($1, cgroup_context)
$1.IOWriteBandwidthMax, config_parse_io_limit, 0, offsetof($1, cgroup_context)
core: add support for IOReadIOPSMax and IOWriteIOPSMax cgroup IO controller supports maximum limits for both bandwidth and IOPS but systemd resource control currently only supports bandwidth limits. This patch adds support for IOReadIOPSMax and IOWriteIOPSMax when unified cgroup hierarchy is in use. It isn't difficult to also add BlockIOReadIOPS and BlockIOWriteIOPS for legacy hierarchies but IO control on legacy hierarchies is half-broken anyway, so let's leave it alone for now.
2016-05-18 22:50:56 +02:00
$1.IOReadIOPSMax, config_parse_io_limit, 0, offsetof($1, cgroup_context)
$1.IOWriteIOPSMax, config_parse_io_limit, 0, offsetof($1, cgroup_context)
core: add IODeviceLatencyTargetSec This adds support for the following proposed latency based IO control mechanism. https://lkml.org/lkml/2018/6/5/428
2018-06-13 23:16:35 +02:00
$1.IODeviceLatencyTargetSec, config_parse_io_device_latency, 0, offsetof($1, cgroup_context)
core: general cgroup rework Replace the very generic cgroup hookup with a much simpler one. With this change only the high-level cgroup settings remain, the ability to set arbitrary cgroup attributes is removed, so is support for adding units to arbitrary cgroup controllers or setting arbitrary paths for them (especially paths that are different for the various controllers). This also introduces a new -.slice root slice, that is the parent of system.slice and friends. This enables easy admin configuration of root-level cgrouo properties. This replaces DeviceDeny= by DevicePolicy=, and implicitly adds in /dev/null, /dev/zero and friends if DeviceAllow= is used (unless this is turned off by DevicePolicy=).
2013-06-27 04:14:27 +02:00
$1.BlockIOAccounting, config_parse_bool, 0, offsetof($1, cgroup_context.blockio_accounting)
cgroup: rework startup logic Introduce a (unsigned long) -1 as "unset" state for cpu shares/block io weights, and keep the startup unit set around all the time.
2014-05-22 00:06:16 +02:00
$1.BlockIOWeight, config_parse_blockio_weight, 0, offsetof($1, cgroup_context.blockio_weight)
cgroups: simplify CPUQuota= logic Only accept cpu quota values in percentages, get rid of period definition. It's not clear whether the CFS period controllable per-cgroup even has a future in the kernel, hence let's simplify all this, hardcode the period to 100ms and only accept percentage based quota values.
2014-05-22 04:53:12 +02:00
$1.StartupBlockIOWeight, config_parse_blockio_weight, 0, offsetof($1, cgroup_context.startup_blockio_weight)
cgroup: split out per-device BlockIOWeight= setting into BlockIODeviceWeight= This way we can nicely map the configuration directive to properties and back, without requiring two different signatures for the same property.
2013-07-11 20:40:18 +02:00
$1.BlockIODeviceWeight, config_parse_blockio_device_weight, 0, offsetof($1, cgroup_context)
core: general cgroup rework Replace the very generic cgroup hookup with a much simpler one. With this change only the high-level cgroup settings remain, the ability to set arbitrary cgroup attributes is removed, so is support for adding units to arbitrary cgroup controllers or setting arbitrary paths for them (especially paths that are different for the various controllers). This also introduces a new -.slice root slice, that is the parent of system.slice and friends. This enables easy admin configuration of root-level cgrouo properties. This replaces DeviceDeny= by DevicePolicy=, and implicitly adds in /dev/null, /dev/zero and friends if DeviceAllow= is used (unless this is turned off by DevicePolicy=).
2013-06-27 04:14:27 +02:00
$1.BlockIOReadBandwidth, config_parse_blockio_bandwidth, 0, offsetof($1, cgroup_context)
core: introduce new Delegate=yes/no property controlling creation of cgroup subhierarchies For priviliged units this resource control property ensures that the processes have all controllers systemd manages enabled. For unpriviliged services (those with User= set) this ensures that access rights to the service cgroup is granted to the user in question, to create further subgroups. Note that this only applies to the name=systemd hierarchy though, as access to other controllers is not safe for unpriviliged processes. Delegate=yes should be set for container scopes where a systemd instance inside the container shall manage the hierarchies below its own cgroup and have access to all controllers. Delegate=yes should also be set for user@.service, so that systemd --user can run, controlling its own cgroup tree. This commit changes machined, systemd-nspawn@.service and user@.service to set this boolean, in order to ensure that container management will just work, and the user systemd instance can run fine.
2014-11-05 17:57:23 +01:00
$1.BlockIOWriteBandwidth, config_parse_blockio_bandwidth, 0, offsetof($1, cgroup_context)
core: add support for the "pids" cgroup controller This adds support for the new "pids" cgroup controller of 4.3 kernels. It allows accounting the number of tasks in a cgroup and enforcing limits on it. This adds two new setting TasksAccounting= and TasksMax= to each unit, as well as a gloabl option DefaultTasksAccounting=. This also updated "cgtop" to optionally make use of the new kernel-provided accounting. systemctl has been updated to show the number of tasks for each service if it is available. This patch also adds correct support for undoing memory limits for units using a MemoryLimit=infinity syntax. We do the same for TasksMax= now and hence keep things in sync here.
2015-09-10 12:32:16 +02:00
$1.TasksAccounting, config_parse_bool, 0, offsetof($1, cgroup_context.tasks_accounting)
core: add new DefaultTasksMax= setting for system.conf This allows initializing the TasksMax= setting of all units by default to some fixed value, instead of leaving it at infinity as before.
2015-11-13 17:13:55 +01:00
$1.TasksMax, config_parse_tasks_max, 0, offsetof($1, cgroup_context.tasks_max)
core: rework the Delegate= unit file setting to take a list of controller names Previously it was not possible to select which controllers to enable for a unit where Delegate=yes was set, as all controllers were enabled. With this change, this is made configurable, and thus delegation units can pick specifically what they want to manage themselves, and what they don't care about.
2017-11-09 15:29:34 +01:00
$1.Delegate, config_parse_delegate, 0, offsetof($1, cgroup_context)
cgroup: Add DisableControllers= directive to disable controller in subtree Some controllers (like the CPU controller) have a performance cost that is non-trivial on certain workloads. While this can be mitigated and improved to an extent, there will for some controllers always be some overheads associated with the benefits gained from the controller. Inside Facebook, the fix applied has been to disable the CPU controller forcibly with `cgroup_disable=cpu` on the kernel command line. This presents a problem: to disable or reenable the controller, a reboot is required, but this is quite cumbersome and slow to do for many thousands of machines, especially machines where disabling/enabling a stateful service on a machine is a matter of several minutes. Currently systemd provides some configuration knobs for these in the form of `[Default]CPUAccounting`, `[Default]MemoryAccounting`, and the like. The limitation of these is that Default*Accounting is overrideable by individual services, of which any one could decide to reenable a controller within the hierarchy at any point just by using a controller feature implicitly (eg. `CPUWeight`), even if the use of that CPU feature could just be opportunistic. Since many services are provided by the distribution, or by upstream teams at a particular organisation, it's not a sustainable solution to simply try to find and remove offending directives from these units. This commit presents a more direct solution -- a DisableControllers= directive that forcibly disallows a controller from being enabled within a subtree.
2018-12-03 15:38:06 +01:00
$1.DisableControllers, config_parse_disable_controllers, 0, offsetof($1, cgroup_context)
cgroup, unit, fragment parser: make use of new firewall functions
2017-09-05 19:27:53 +02:00
$1.IPAccounting, config_parse_bool, 0, offsetof($1, cgroup_context.ip_accounting)
$1.IPAddressAllow, config_parse_ip_address_access, 0, offsetof($1, cgroup_context.ip_address_allow)
$1.IPAddressDeny, config_parse_ip_address_access, 0, offsetof($1, cgroup_context.ip_address_deny)
bpf-firewall: custom BPF programs through IP(Ingress|Egress)FilterPath= Takes a single /sys/fs/bpf/pinned_prog string as argument, but may be specified multiple times. An empty assignment resets all previous filters. Closes https://github.com/systemd/systemd/issues/10227
2019-04-23 12:14:20 +02:00
$1.IPIngressFilterPath, config_parse_ip_filter_bpf_progs, 0, offsetof($1, cgroup_context.ip_filters_ingress)
$1.IPEgressFilterPath, config_parse_ip_filter_bpf_progs, 0, offsetof($1, cgroup_context.ip_filters_egress)
cgroup: remove support for NetClass= directive Support for net_cls.class_id through the NetClass= configuration directive has been added in v227 in preparation for a per-unit packet filter mechanism. However, it turns out the kernel people have decided to deprecate the net_cls and net_prio controllers in v2. Tejun provides a comprehensive justification for this in his commit, which has landed during the merge window for kernel v4.5: https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=bd1060a1d671 As we're aiming for full support for the v2 cgroup hierarchy, we can no longer support this feature. Userspace tool such as nftables are moving over to setting rules that are specific to the full cgroup path of a task, which obsoletes these controllers anyway. This commit removes support for tweaking details in the net_cls controller, but keeps the NetClass= directive around for legacy compatibility reasons.
2016-02-10 15:44:01 +01:00
$1.NetClass, config_parse_warn_compat, DISABLED_LEGACY, 0'
core: add new .slice unit type for partitioning systems In order to prepare for the kernel cgroup rework, let's introduce a new unit type to systemd, the "slice". Slices can be arranged in a tree and are useful to partition resources freely and hierarchally by the user. Each service unit can now be assigned to one of these slices, and later on login users and machines may too. Slices translate pretty directly to the cgroup hierarchy, and the various objects can be assigned to any of the slices in the tree.
2013-06-17 21:33:26 +02:00
)m4_dnl
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 12:04:08 +01:00
Unit.Description, config_parse_unit_string_printf, 0, offsetof(Unit, description)
units: introduce new Documentation= field and make use of it everywhere This should help making the boot process a bit easier to explore and understand for the administrator. The simple idea is that "systemctl status" now shows a link to documentation alongside the other status and decriptionary information of a service. This patch adds the necessary fields to all our shipped units if we have proper documentation for them.
2012-05-21 15:12:18 +02:00
Unit.Documentation, config_parse_documentation, 0, offsetof(Unit, documentation)
core: enable specifier expansion for What=/Where=/Type=/SourcePath= too Using specifiers in these settings isn't particularly useful by itself, but it unifies behaviour a bit. It's kinda surprising that What= in mount units resolves specifies, but Where= does not. Hence let's add that too. Also, it's surprising Where=/What= in mount units behaves differently than in automount and swap units, hence resolve specifiers there too. Then, Type= in mount units is nowadays an arbitrary, sometimes non-trivial string (think fuse!), hence let's also expand specifiers there, to match the rest of the mount settings. This has the benefit that when writing code that generates unit files, less care has to be taken to check whether escaping of specifiers is necessary or not: broadly everything that takes arbitrary user strings now does specifier expansion, while enums/numerics/booleans do not.
2017-11-21 20:03:51 +01:00
Unit.SourcePath, config_parse_unit_path_printf, 0, offsetof(Unit, source_path)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Unit.Requires, config_parse_unit_deps, UNIT_REQUIRES, 0
Unit.Requisite, config_parse_unit_deps, UNIT_REQUISITE, 0
Unit.Wants, config_parse_unit_deps, UNIT_WANTS, 0
unit: rename BindTo= to BindsTo= all other dependencies are in 3rd person. Change BindTo= accordingly to BindsTo=. Of course, the dependency is widely used, hence we parse the old name too for compatibility.
2012-07-13 23:34:40 +02:00
Unit.BindsTo, config_parse_unit_deps, UNIT_BINDS_TO, 0
Unit.BindTo, config_parse_unit_deps, UNIT_BINDS_TO, 0
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Unit.Conflicts, config_parse_unit_deps, UNIT_CONFLICTS, 0
Unit.Before, config_parse_unit_deps, UNIT_BEFORE, 0
Unit.After, config_parse_unit_deps, UNIT_AFTER, 0
Unit.OnFailure, config_parse_unit_deps, UNIT_ON_FAILURE, 0
unit: rename BindTo= to BindsTo= all other dependencies are in 3rd person. Change BindTo= accordingly to BindsTo=. Of course, the dependency is widely used, hence we parse the old name too for compatibility.
2012-07-13 23:34:40 +02:00
Unit.PropagatesReloadTo, config_parse_unit_deps, UNIT_PROPAGATES_RELOAD_TO, 0
Unit.PropagateReloadTo, config_parse_unit_deps, UNIT_PROPAGATES_RELOAD_TO, 0
Unit.ReloadPropagatedFrom, config_parse_unit_deps, UNIT_RELOAD_PROPAGATED_FROM, 0
Unit.PropagateReloadFrom, config_parse_unit_deps, UNIT_RELOAD_PROPAGATED_FROM, 0
systemd: added new dependency PartOf This should address TODO item "new dependency type to "group" services in a target". Semantic of new dependency is as follows. Once configured it creates dependency which will cause that all dependent units get stopped if unit they all depend on is stopped or restarted. Usual use case would be configuring PartOf=some.target in template unit file and WantedBy=some.target in [Install] section and enabling desired number of instances. In this case starting one instance won't pull in target but stopping or starting target(in case of WantedBy is properly configured) will cause stop/start of all instances.
2012-07-20 15:55:01 +02:00
Unit.PartOf, config_parse_unit_deps, UNIT_PART_OF, 0
service: add the ability for units to join other unit's PrivateNetwork= and PrivateTmp= namespaces
2013-11-27 20:23:18 +01:00
Unit.JoinsNamespaceOf, config_parse_unit_deps, UNIT_JOINS_NAMESPACE_OF, 0
core: remove support for RequiresOverridable= and RequisiteOverridable= As discussed at systemd.conf 2015 and on also raised on the ML: http://lists.freedesktop.org/archives/systemd-devel/2015-November/034880.html This removes the two XyzOverridable= unit dependencies, that were basically never used, and do not enhance user experience in any way. Most folks looking for the functionality this provides probably opt for the "ignore-dependencies" job mode, and that's probably a good idea. Hence, let's simplify systemd's dependency engine and remove these two dependency types (and their inverses). The unit file parser and the dbus property parser will now redirect the settings/properties to result in an equivalent non-overridable dependency. In the case of the unit file parser we generate a warning, to inform the user. The dbus properties for this unit type stay available on the unit objects, but they are now hidden from usual introspection and will always return the empty list when queried. This should provide enough compatibility for the few unit files that actually ever made use of this.
2015-11-12 19:21:47 +01:00
Unit.RequiresOverridable, config_parse_obsolete_unit_deps, UNIT_REQUIRES, 0
core/load-fragment: fix alignment
2017-11-08 06:29:47 +01:00
Unit.RequisiteOverridable, config_parse_obsolete_unit_deps, UNIT_REQUISITE, 0
core: rework how we match mount units against each other Previously to automatically create dependencies between mount units we matched every mount unit agains all others resulting in O(n^2) complexity. On setups with large amounts of mount units this might make things slow. This change replaces the matching code to use a hashtable that is keyed by a path prefix, and points to a set of units that require that path to be around. When a new mount unit is installed it is hence sufficient to simply look up this set of units via its own file system paths to know which units to order after itself. This patch also changes all unit types to only create automatic mount dependencies via the RequiresMountsFor= logic, and this is exposed to the outside to make things more transparent. With this change we still have some O(n) complexities in place when handling mounts, but that's currently unavoidable due to kernel APIs, and still substantially better than O(n^2) as before. https://bugs.freedesktop.org/show_bug.cgi?id=69740
2013-09-26 20:14:24 +02:00
Unit.RequiresMountsFor, config_parse_unit_requires_mounts_for, 0, 0
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 12:04:08 +01:00
Unit.StopWhenUnneeded, config_parse_bool, 0, offsetof(Unit, stop_when_unneeded)
Unit.RefuseManualStart, config_parse_bool, 0, offsetof(Unit, refuse_manual_start)
Unit.RefuseManualStop, config_parse_bool, 0, offsetof(Unit, refuse_manual_stop)
Unit.AllowIsolate, config_parse_bool, 0, offsetof(Unit, allow_isolate)
Unit.DefaultDependencies, config_parse_bool, 0, offsetof(Unit, default_dependencies)
core: replace OnFailureIsolate= setting by a more generic OnFailureJobMode= setting and make use of it where applicable
2013-11-26 01:39:53 +01:00
Unit.OnFailureJobMode, config_parse_job_mode, 0, offsetof(Unit, on_failure_job_mode)
load-fragment: obsolete OnFailureIsolate=
2017-12-29 09:00:40 +01:00
m4_dnl The following is a legacy alias name for compatibility
core: replace OnFailureIsolate= setting by a more generic OnFailureJobMode= setting and make use of it where applicable
2013-11-26 01:39:53 +01:00
Unit.OnFailureIsolate, config_parse_job_mode_isolate, 0, offsetof(Unit, on_failure_job_mode)
unit: remove union Unit Now that objects of all unit types are allocated the exact amount of memory they need, the Unit union has lost its purpose. Remove it. "Unit" is a more natural name for the base unit class than "Meta", so rename Meta to Unit. Access to members of the base class gets simplified.
2012-01-15 12:04:08 +01:00
Unit.IgnoreOnIsolate, config_parse_bool, 0, offsetof(Unit, ignore_on_isolate)
Remove snapshot unit type Snapshots were never useful or used for anything. Many systemd developers that I spoke to at systemd.conf2015, didn't even know they existed, so it is fairly safe to assume that this type can be deleted without harm. The fundamental problem with snapshots is that the state of the system is dynamic, devices come and go, users log in and out, timers fire... and restoring all units to some state from the past would "undo" those changes, which isn't really possible. Tested by creating a snapshot, running the new binary, and checking that the transition did not cause errors, and the snapshot is gone, and snapshots cannot be created anymore. New systemctl says: Unknown operation snapshot. Old systemctl says: Failed to create snapshot: Support for snapshots has been removed. IgnoreOnSnaphost settings are warned about and ignored: Support for option IgnoreOnSnapshot= has been removed and it is ignored http://lists.freedesktop.org/archives/systemd-devel/2015-November/034872.html
2015-11-08 14:12:54 +01:00
Unit.IgnoreOnSnapshot, config_parse_warn_compat, DISABLED_LEGACY, 0
unit: when JobTimeoutSec= is turned off, implicitly turn off JobRunningTimeoutSec= too We added JobRunningTimeoutSec= late, and Dracut configured only JobTimeoutSec= to turn of root device timeouts before. With this change we'll propagate a reset of JobTimeoutSec= into JobRunningTimeoutSec=, but only if the latter wasn't set explicitly. This should restore compatibility with older systemd versions. Fixes: #6402
2017-09-27 17:30:50 +02:00
Unit.JobTimeoutSec, config_parse_job_timeout_sec, 0, 0
Unit.JobRunningTimeoutSec, config_parse_job_running_timeout_sec, 0, 0
failure-action: generalize failure action to emergency action
2016-10-20 15:27:37 +02:00
Unit.JobTimeoutAction, config_parse_emergency_action, 0, offsetof(Unit, job_timeout_action)
core: turn on specifier expansion for more unit file settings Let's permit specifier expansion at a numbre of additional fields, where arbitrary strings might be passed where this might be useful one day. (Or at least where there's no clear reason where it wouldn't make sense to have.)
2016-12-05 19:38:39 +01:00
Unit.JobTimeoutRebootArgument, config_parse_unit_string_printf, 0, offsetof(Unit, job_timeout_reboot_arg)
pid1: rename start_limit to start_ratelimit This way it is clearer what the type is. We also have auto_stop_ratelimit adjacent, and it feels ugly to have a different suffix for those two.
2019-09-19 17:45:41 +02:00
Unit.StartLimitIntervalSec, config_parse_sec, 0, offsetof(Unit, start_ratelimit.interval)
core: rename StartLimitInterval= to StartLimitIntervalSec= We generally follow the rule that for time settings we suffix the setting name with "Sec" to indicate the default unit if none is specified. The only exception was the rate limiting interval settings. Fix this, and keep the old names for compatibility. Do the same for journald's RateLimitInterval= setting
2016-04-26 20:46:20 +02:00
m4_dnl The following is a legacy alias name for compatibility
pid1: rename start_limit to start_ratelimit This way it is clearer what the type is. We also have auto_stop_ratelimit adjacent, and it feels ugly to have a different suffix for those two.
2019-09-19 17:45:41 +02:00
Unit.StartLimitInterval, config_parse_sec, 0, offsetof(Unit, start_ratelimit.interval)
Unit.StartLimitBurst, config_parse_unsigned, 0, offsetof(Unit, start_ratelimit.burst)
failure-action: generalize failure action to emergency action
2016-10-20 15:27:37 +02:00
Unit.StartLimitAction, config_parse_emergency_action, 0, offsetof(Unit, start_limit_action)
core: generalize FailureAction= move it from service to unit All kinds of units can fail, hence it makes sense to offer this as generic concept for all unit types.
2017-11-16 15:02:56 +01:00
Unit.FailureAction, config_parse_emergency_action, 0, offsetof(Unit, failure_action)
core: introduce SuccessAction= as unit file property SuccessAction= is similar to FailureAction= but declares what to do on success of a unit, rather than on failure. This is useful for running commands in qemu/nspawn images, that shall power down on completion. We frequently see "ExecStopPost=/usr/bin/systemctl poweroff" or so in unit files like this. Offer a simple, more declarative alternative for this. While we are at it, hook up failure action with unit_dump() and transient units too.
2017-11-16 15:18:01 +01:00
Unit.SuccessAction, config_parse_emergency_action, 0, offsetof(Unit, success_action)
core: allow to set exit status when using SuccessAction=/FailureAction=exit in units This adds SuccessActionExitStatus= and FailureActionExitStatus= that may be used to configure the exit status to propagate in when SuccessAction=exit or FailureAction=exit is used. When not specified let's also propagate the exit status of the main process we fork off for the unit.
2018-11-16 11:41:18 +01:00
Unit.FailureActionExitStatus, config_parse_exit_status, 0, offsetof(Unit, failure_action_exit_status)
Unit.SuccessActionExitStatus, config_parse_exit_status, 0, offsetof(Unit, success_action_exit_status)
core: turn on specifier expansion for more unit file settings Let's permit specifier expansion at a numbre of additional fields, where arbitrary strings might be passed where this might be useful one day. (Or at least where there's no clear reason where it wouldn't make sense to have.)
2016-12-05 19:38:39 +01:00
Unit.RebootArgument, config_parse_unit_string_printf, 0, offsetof(Unit, reboot_arg)
analyze: add 'condition' verb We didn't have a straightforward way to parse and evaluate those strings. Prompted by #12881.
2019-06-26 14:58:45 +02:00
m4_dnl Also add any conditions to condition_definitions[] in src/analyze/analyze-condition.c.
core: introduce the concept of AssertXYZ= similar to ConditionXYZ=, but fatal for a start job if not met
2014-11-06 13:43:45 +01:00
Unit.ConditionPathExists, config_parse_unit_condition_path, CONDITION_PATH_EXISTS, offsetof(Unit, conditions)
Unit.ConditionPathExistsGlob, config_parse_unit_condition_path, CONDITION_PATH_EXISTS_GLOB, offsetof(Unit, conditions)
Unit.ConditionPathIsDirectory, config_parse_unit_condition_path, CONDITION_PATH_IS_DIRECTORY, offsetof(Unit, conditions)
Unit.ConditionPathIsSymbolicLink,config_parse_unit_condition_path, CONDITION_PATH_IS_SYMBOLIC_LINK,offsetof(Unit, conditions)
Unit.ConditionPathIsMountPoint, config_parse_unit_condition_path, CONDITION_PATH_IS_MOUNT_POINT, offsetof(Unit, conditions)
Unit.ConditionPathIsReadWrite, config_parse_unit_condition_path, CONDITION_PATH_IS_READ_WRITE, offsetof(Unit, conditions)
Unit.ConditionDirectoryNotEmpty, config_parse_unit_condition_path, CONDITION_DIRECTORY_NOT_EMPTY, offsetof(Unit, conditions)
Unit.ConditionFileNotEmpty, config_parse_unit_condition_path, CONDITION_FILE_NOT_EMPTY, offsetof(Unit, conditions)
Unit.ConditionFileIsExecutable, config_parse_unit_condition_path, CONDITION_FILE_IS_EXECUTABLE, offsetof(Unit, conditions)
Unit.ConditionNeedsUpdate, config_parse_unit_condition_path, CONDITION_NEEDS_UPDATE, offsetof(Unit, conditions)
Unit.ConditionFirstBoot, config_parse_unit_condition_string, CONDITION_FIRST_BOOT, offsetof(Unit, conditions)
Unit.ConditionKernelCommandLine, config_parse_unit_condition_string, CONDITION_KERNEL_COMMAND_LINE, offsetof(Unit, conditions)
core,udev,networkd: add ConditionKernelVersion= This adds a simple condition/assert/match to the service manager, to udev's .link handling and to networkd, for matching the kernel version string. In this version we only do fnmatch() based globbing, but we might want to extend that to version comparisons later on, if we like, by slightly extending the syntax with ">=", "<=", ">", "<" and "==" expressions.
2017-12-13 20:34:13 +01:00
Unit.ConditionKernelVersion, config_parse_unit_condition_string, CONDITION_KERNEL_VERSION, offsetof(Unit, conditions)
core: introduce the concept of AssertXYZ= similar to ConditionXYZ=, but fatal for a start job if not met
2014-11-06 13:43:45 +01:00
Unit.ConditionArchitecture, config_parse_unit_condition_string, CONDITION_ARCHITECTURE, offsetof(Unit, conditions)
Unit.ConditionVirtualization, config_parse_unit_condition_string, CONDITION_VIRTUALIZATION, offsetof(Unit, conditions)
Unit.ConditionSecurity, config_parse_unit_condition_string, CONDITION_SECURITY, offsetof(Unit, conditions)
Unit.ConditionCapability, config_parse_unit_condition_string, CONDITION_CAPABILITY, offsetof(Unit, conditions)
Unit.ConditionHost, config_parse_unit_condition_string, CONDITION_HOST, offsetof(Unit, conditions)
Unit.ConditionACPower, config_parse_unit_condition_string, CONDITION_AC_POWER, offsetof(Unit, conditions)
core: add ConditionUser and ConditionGroup This adds two options that are useful for user units. In particular, it is useful to check ConditionUser=!0 to not start for the root user. Closes: #5187
2017-04-09 01:32:13 +02:00
Unit.ConditionUser, config_parse_unit_condition_string, CONDITION_USER, offsetof(Unit, conditions)
Unit.ConditionGroup, config_parse_unit_condition_string, CONDITION_GROUP, offsetof(Unit, conditions)
condition: Create AssertControlGroupController (#7630) Up until now, the behaviour in systemd has (mostly) been to silently ignore failures to action unit directives that refer to an unavailble controller. The addition of AssertControlGroupController and its conditional counterpart allow explicit specification of the desired behaviour when such a situation occurs. As for how this can happen, it is possible that a particular controller is not available in the cgroup hierarchy. One possible reason for this is that, in the running kernel, the controller simply doesn't exist -- for example, the CPU controller in cgroup v2 has only recently been merged and was out of tree until then. Another possibility is that the controller exists, but has been forcibly disabled by `cgroup_disable=` on the kernel command line. In future this will also support whatever comes out of issue #7624, `DefaultXAccounting=never`, or similar.
2017-12-18 08:53:29 +01:00
Unit.ConditionControlGroupController, config_parse_unit_condition_string, CONDITION_CONTROL_GROUP_CONTROLLER, offsetof(Unit, conditions)
core: introduce the concept of AssertXYZ= similar to ConditionXYZ=, but fatal for a start job if not met
2014-11-06 13:43:45 +01:00
Unit.ConditionNull, config_parse_unit_condition_null, 0, offsetof(Unit, conditions)
Unit.AssertPathExists, config_parse_unit_condition_path, CONDITION_PATH_EXISTS, offsetof(Unit, asserts)
Unit.AssertPathExistsGlob, config_parse_unit_condition_path, CONDITION_PATH_EXISTS_GLOB, offsetof(Unit, asserts)
Unit.AssertPathIsDirectory, config_parse_unit_condition_path, CONDITION_PATH_IS_DIRECTORY, offsetof(Unit, asserts)
Unit.AssertPathIsSymbolicLink, config_parse_unit_condition_path, CONDITION_PATH_IS_SYMBOLIC_LINK,offsetof(Unit, asserts)
Unit.AssertPathIsMountPoint, config_parse_unit_condition_path, CONDITION_PATH_IS_MOUNT_POINT, offsetof(Unit, asserts)
Unit.AssertPathIsReadWrite, config_parse_unit_condition_path, CONDITION_PATH_IS_READ_WRITE, offsetof(Unit, asserts)
Unit.AssertDirectoryNotEmpty, config_parse_unit_condition_path, CONDITION_DIRECTORY_NOT_EMPTY, offsetof(Unit, asserts)
Unit.AssertFileNotEmpty, config_parse_unit_condition_path, CONDITION_FILE_NOT_EMPTY, offsetof(Unit, asserts)
Unit.AssertFileIsExecutable, config_parse_unit_condition_path, CONDITION_FILE_IS_EXECUTABLE, offsetof(Unit, asserts)
Unit.AssertNeedsUpdate, config_parse_unit_condition_path, CONDITION_NEEDS_UPDATE, offsetof(Unit, asserts)
Unit.AssertFirstBoot, config_parse_unit_condition_string, CONDITION_FIRST_BOOT, offsetof(Unit, asserts)
Unit.AssertKernelCommandLine, config_parse_unit_condition_string, CONDITION_KERNEL_COMMAND_LINE, offsetof(Unit, asserts)
core,udev,networkd: add ConditionKernelVersion= This adds a simple condition/assert/match to the service manager, to udev's .link handling and to networkd, for matching the kernel version string. In this version we only do fnmatch() based globbing, but we might want to extend that to version comparisons later on, if we like, by slightly extending the syntax with ">=", "<=", ">", "<" and "==" expressions.
2017-12-13 20:34:13 +01:00
Unit.AssertKernelVersion, config_parse_unit_condition_string, CONDITION_KERNEL_VERSION, offsetof(Unit, asserts)
core: introduce the concept of AssertXYZ= similar to ConditionXYZ=, but fatal for a start job if not met
2014-11-06 13:43:45 +01:00
Unit.AssertArchitecture, config_parse_unit_condition_string, CONDITION_ARCHITECTURE, offsetof(Unit, asserts)
Unit.AssertVirtualization, config_parse_unit_condition_string, CONDITION_VIRTUALIZATION, offsetof(Unit, asserts)
Unit.AssertSecurity, config_parse_unit_condition_string, CONDITION_SECURITY, offsetof(Unit, asserts)
Unit.AssertCapability, config_parse_unit_condition_string, CONDITION_CAPABILITY, offsetof(Unit, asserts)
Unit.AssertHost, config_parse_unit_condition_string, CONDITION_HOST, offsetof(Unit, asserts)
Unit.AssertACPower, config_parse_unit_condition_string, CONDITION_AC_POWER, offsetof(Unit, asserts)
core: add ConditionUser and ConditionGroup This adds two options that are useful for user units. In particular, it is useful to check ConditionUser=!0 to not start for the root user. Closes: #5187
2017-04-09 01:32:13 +02:00
Unit.AssertUser, config_parse_unit_condition_string, CONDITION_USER, offsetof(Unit, asserts)
Unit.AssertGroup, config_parse_unit_condition_string, CONDITION_GROUP, offsetof(Unit, asserts)
condition: Create AssertControlGroupController (#7630) Up until now, the behaviour in systemd has (mostly) been to silently ignore failures to action unit directives that refer to an unavailble controller. The addition of AssertControlGroupController and its conditional counterpart allow explicit specification of the desired behaviour when such a situation occurs. As for how this can happen, it is possible that a particular controller is not available in the cgroup hierarchy. One possible reason for this is that, in the running kernel, the controller simply doesn't exist -- for example, the CPU controller in cgroup v2 has only recently been merged and was out of tree until then. Another possibility is that the controller exists, but has been forcibly disabled by `cgroup_disable=` on the kernel command line. In future this will also support whatever comes out of issue #7624, `DefaultXAccounting=never`, or similar.
2017-12-18 08:53:29 +01:00
Unit.AssertControlGroupController, config_parse_unit_condition_string, CONDITION_CONTROL_GROUP_CONTROLLER, offsetof(Unit, asserts)
core: introduce the concept of AssertXYZ= similar to ConditionXYZ=, but fatal for a start job if not met
2014-11-06 13:43:45 +01:00
Unit.AssertNull, config_parse_unit_condition_null, 0, offsetof(Unit, asserts)
core: add a new unit file setting CollectMode= for tweaking the GC logic Right now, the option only takes one of two possible values "inactive" or "inactive-or-failed", the former being the default, and exposing same behaviour as the status quo ante. If set to "inactive-or-failed" units may be collected by the GC logic when in the "failed" state too. This logic should be a nicer alternative to using the "-" modifier for ExecStart= and friends, as the exit data is collected and logged about and only removed when the GC comes along. This should be useful in particular for per-connection socket-activated services, as well as "systemd-run" command lines that shall leave no artifacts in the system. I was thinking about whether to expose this as a boolean, but opted for an enum instead, as I have the suspicion other tweaks like this might be a added later on, in which case we extend this setting instead of having to add yet another one. Also, let's add some documentation for the GC logic.
2017-11-13 17:14:07 +01:00
Unit.CollectMode, config_parse_collect_mode, 0, offsetof(Unit, collect_mode)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
m4_dnl
core: log about /var/run/ prefix used in PIDFile=, patch it to be /run instead In a way this is a follow-up for a2d1fb882c4308bc10362d971f333c5031d60069, but adds a similar warning for PIDFile=. There's a much stronger case for doing this kind of notification in tmpfiles.d (since it helps relating lines to each other for the purpose of merging them). Doing this for PIDFile= is mostly about being systematic and copying tmpfiles.d/ behaviour here. While we are at it, let's also support relative filenames in PIDFile= now, and prefix them with /run, to make them absolute. Fixes: #10657
2018-11-09 18:19:40 +01:00
Service.PIDFile, config_parse_pid_file, 0, offsetof(Service, pid_file)
core: ExecCondition= for services Closes #10596
2019-06-29 02:02:30 +02:00
Service.ExecCondition, config_parse_exec, SERVICE_EXEC_CONDITION, offsetof(Service, exec_command)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Service.ExecStartPre, config_parse_exec, SERVICE_EXEC_START_PRE, offsetof(Service, exec_command)
Service.ExecStart, config_parse_exec, SERVICE_EXEC_START, offsetof(Service, exec_command)
Service.ExecStartPost, config_parse_exec, SERVICE_EXEC_START_POST, offsetof(Service, exec_command)
Service.ExecReload, config_parse_exec, SERVICE_EXEC_RELOAD, offsetof(Service, exec_command)
Service.ExecStop, config_parse_exec, SERVICE_EXEC_STOP, offsetof(Service, exec_command)
Service.ExecStopPost, config_parse_exec, SERVICE_EXEC_STOP_POST, offsetof(Service, exec_command)
util: rename parse_usec() to parse_sec() sinds the default unit is seconds Internally we store all time values in usec_t, however parse_usec() actually was used mostly to parse values in seconds (unless explicit units were specified to define a different unit). Hence, be clear about this and name the function about what we pass into it, not what we get out of it.
2013-04-02 20:38:16 +02:00
Service.RestartSec, config_parse_sec, 0, offsetof(Service, restart_usec)
core: simplify how we parse TimeoutSec=, TimeoutStartSec= and TimeoutStopSec= Let's make things more obvious by placing the parse_usec() invocation directly in config_parse_service_timeout().
2016-02-08 23:54:54 +01:00
Service.TimeoutSec, config_parse_service_timeout, 0, 0
Service.TimeoutStartSec, config_parse_service_timeout, 0, 0
load-fragment: use config_parse_sec_fix_0() for TimeoutStopSec=
2018-05-25 05:16:24 +02:00
Service.TimeoutStopSec, config_parse_sec_fix_0, 0, offsetof(Service, timeout_stop_usec)
service: handle abort stops with dedicated timeout When shooting down a service with SIGABRT the user might want to have a much longer stop timeout than on regular stops/shutdowns. Especially in the face of short stop timeouts the time might not be sufficient to write huge core dumps before the service is killed. This commit adds a dedicated (Default)TimeoutAbortSec= timer that is used when stopping a service via SIGABRT. In all other cases the existing TimeoutStopSec= is used. The timer value is unset by default to skip the special handling and use TimeoutStopSec= for state 'stop-watchdog' to keep the old behaviour. If the service is in state 'stop-watchdog' and the service should be stopped explicitly we still go to 'stop-sigterm' and re-apply the usual TimeoutStopSec= timeout.
2017-11-29 07:43:44 +01:00
Service.TimeoutAbortSec, config_parse_service_timeout_abort, 0, 0
core: let user define start-/stop-timeout behaviour The usual behaviour when a timeout expires is to terminate/kill the service. This is what user usually want in production systems. To debug services that fail to start/stop (especially sporadic failures) it might be necessary to trigger the watchdog machinery and write core dumps, though. Likewise, it is usually just a waste of time to gracefully stop a stuck service. Instead it might save time to go directly into kill mode. This commit adds two new options to services: TimeoutStartFailureMode= and TimeoutStopFailureMode=. Both take the same values and tweak the behavior of systemd when a start/stop timeout expires: * 'terminate': is the default behaviour as it has always been, * 'abort': triggers the watchdog machinery and will send SIGABRT (unless WatchdogSignal was changed) and * 'kill' will directly send SIGKILL. To handle the stop failure mode in stop-post state too a new final-watchdog state needs to be introduced.
2019-04-16 16:45:20 +02:00
Service.TimeoutStartFailureMode, config_parse_service_timeout_failure_mode, 0, offsetof(Service, timeout_start_failure_mode)
Service.TimeoutStopFailureMode, config_parse_service_timeout_failure_mode, 0, offsetof(Service, timeout_stop_failure_mode)
core: rework unit timeout handling, and add new setting RuntimeMaxSec= This clean-ups timeout handling in PID 1. Specifically, instead of storing 0 in internal timeout variables as indication for a disabled timeout, use USEC_INFINITY which is in-line with how we do this in the rest of our code (following the logic that 0 means "no", and USEC_INFINITY means "never"). This also replace all usec_t additions with invocations to usec_add(), so that USEC_INFINITY is properly propagated, and sd-event considers it has indication for turning off the event source. This also alters the deserialization of the units to restart timeouts from the time they were originally started from. Before this patch timeouts would be restarted beginning with the time of the deserialization, which could lead to artificially prolonged timeouts if a daemon reload took place. Finally, a new RuntimeMaxSec= setting is introduced for service units, that specifies a maximum runtime after which a specific service is forcibly terminated. This is useful to put time limits on time-intensive processing jobs. This also simplifies the various xyz_spawn() calls of the various types in that explicit distruction of the timers is removed, as that is done anyway by the state change handlers, and a state change is always done when the xyz_spawn() calls fail. Fixes: #2249
2016-02-01 21:48:10 +01:00
Service.RuntimeMaxSec, config_parse_sec, 0, offsetof(Service, runtime_max_usec)
util: rename parse_usec() to parse_sec() sinds the default unit is seconds Internally we store all time values in usec_t, however parse_usec() actually was used mostly to parse values in seconds (unless explicit units were specified to define a different unit). Hence, be clear about this and name the function about what we pass into it, not what we get out of it.
2013-04-02 20:38:16 +02:00
Service.WatchdogSec, config_parse_sec, 0, offsetof(Service, watchdog_usec)
core: generalize FailureAction= move it from service to unit All kinds of units can fail, hence it makes sense to offer this as generic concept for all unit types.
2017-11-16 15:02:56 +01:00
m4_dnl The following five only exist for compatibility, they moved into Unit, see above
pid1: rename start_limit to start_ratelimit This way it is clearer what the type is. We also have auto_stop_ratelimit adjacent, and it feels ugly to have a different suffix for those two.
2019-09-19 17:45:41 +02:00
Service.StartLimitInterval, config_parse_sec, 0, offsetof(Unit, start_ratelimit.interval)
Service.StartLimitBurst, config_parse_unsigned, 0, offsetof(Unit, start_ratelimit.burst)
failure-action: generalize failure action to emergency action
2016-10-20 15:27:37 +02:00
Service.StartLimitAction, config_parse_emergency_action, 0, offsetof(Unit, start_limit_action)
core: generalize FailureAction= move it from service to unit All kinds of units can fail, hence it makes sense to offer this as generic concept for all unit types.
2017-11-16 15:02:56 +01:00
Service.FailureAction, config_parse_emergency_action, 0, offsetof(Unit, failure_action)
core: use config_parse_unit_string_printf() for decoding RebootArgument= All other cases where we accept a reboot argument are decoded with config_parse_unit_string_printf() rather than config_parse_unit_path_printf(), and that's really the only thing what makes sense here, hence adjust this here, too.
2017-11-21 19:23:31 +01:00
Service.RebootArgument, config_parse_unit_string_printf, 0, offsetof(Unit, reboot_arg)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Service.Type, config_parse_service_type, 0, offsetof(Service, type)
Service.Restart, config_parse_service_restart, 0, offsetof(Service, restart)
Service.PermissionsStartOnly, config_parse_bool, 0, offsetof(Service, permissions_start_only)
Service.RootDirectoryStartOnly, config_parse_bool, 0, offsetof(Service, root_directory_start_only)
Service.RemainAfterExit, config_parse_bool, 0, offsetof(Service, remain_after_exit)
Service.GuessMainPID, config_parse_bool, 0, offsetof(Service, guess_main_pid)
core: introduce new RestartForceExitStatus= service setting This does the inverse of RestartPreventExitStatus=: it forces a restart of a service when a certain exit status is returned by a service process.
2014-07-03 12:47:40 +02:00
Service.RestartPreventExitStatus, config_parse_set_status, 0, offsetof(Service, restart_prevent_status)
Service.RestartForceExitStatus, config_parse_set_status, 0, offsetof(Service, restart_force_status)
service: add options RestartPreventExitStatus and SuccessExitStatus In some cases, like wrong configuration, restarting after error does not help, so administrator can specify statuses by RestartPreventExitStatus which will not cause restart of a service. Sometimes you have non-standart exit status, so this can be specified by SuccessfulExitStatus.
2012-08-13 13:58:01 +02:00
Service.SuccessExitStatus, config_parse_set_status, 0, offsetof(Service, success_status)
core: warn and ignore SysVStartPriority= Option was being parsed but not used for anything.
2014-11-30 16:42:53 +01:00
Service.SysVStartPriority, config_parse_warn_compat, DISABLED_LEGACY, 0
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Service.NonBlocking, config_parse_bool, 0, offsetof(Service, exec_context.non_blocking)
conf-parse: don't accept invalid bus names as BusName= arguments in service units
2015-01-07 22:07:09 +01:00
Service.BusName, config_parse_bus_name, 0, offsetof(Service, bus_name)
core: add new logic for services to store file descriptors in PID 1 With this change it is possible to send file descriptors to PID 1, via sd_pid_notify_with_fds() which PID 1 will store individually for each service, and pass via the usual fd passing logic on next invocation. This is useful for enable daemon reload schemes where daemons serialize their state to /run, push their fds into PID 1 and terminate, restoring their state on next start from the data in /run and passed in from PID 1. The fds are kept by PID 1 as long as no POLLHUP or POLLERR is seen on them, and the service they belong to are either not dead or failed, or have a job queued.
2015-01-06 00:26:25 +01:00
Service.FileDescriptorStoreMax, config_parse_unsigned, 0, offsetof(Service, n_fd_store_max)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Service.NotifyAccess, config_parse_notify_access, 0, offsetof(Service, notify_access)
Service.Sockets, config_parse_service_sockets, 0, 0
Remove kdbus custom endpoint support This feature will not be used anytime soon, so remove a bit of cruft. The BusPolicy= config directive will stay around as compat noop.
2016-02-11 22:12:04 +01:00
Service.BusPolicy, config_parse_warn_compat, DISABLED_LEGACY, 0
core: turn on specifier expansion for more unit file settings Let's permit specifier expansion at a numbre of additional fields, where arbitrary strings might be passed where this might be useful one day. (Or at least where there's no clear reason where it wouldn't make sense to have.)
2016-12-05 19:38:39 +01:00
Service.USBFunctionDescriptors, config_parse_unit_path_printf, 0, offsetof(Service, usb_function_descriptors)
Service.USBFunctionStrings, config_parse_unit_path_printf, 0, offsetof(Service, usb_function_strings)
core: implement OOMPolicy= and watch cgroups for OOM killings This adds a new per-service OOMPolicy= (along with a global DefaultOOMPolicy=) that controls what to do if a process of the service is killed by the kernel's OOM killer. It has three different values: "continue" (old behaviour), "stop" (terminate the service), "kill" (let the kernel kill all the service's processes). On top of that, track OOM killer events per unit: generate a per-unit structured, recognizable log message when we see an OOM killer event, and put the service in a failure state if an OOM killer event was seen and the selected policy was not "continue". A new "result" is defined for this case: "oom-kill". All of this relies on new cgroupv2 kernel functionality: the "memory.events" notification interface and the "memory.oom.group" attribute (which makes the kernel kill all cgroup processes automatically).
2019-03-19 19:05:19 +01:00
Service.OOMPolicy, config_parse_oom_policy, 0, offsetof(Service, oom_policy)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
EXEC_CONTEXT_CONFIG_ITEMS(Service)m4_dnl
core: add new .slice unit type for partitioning systems In order to prepare for the kernel cgroup rework, let's introduce a new unit type to systemd, the "slice". Slices can be arranged in a tree and are useful to partition resources freely and hierarchally by the user. Each service unit can now be assigned to one of these slices, and later on login users and machines may too. Slices translate pretty directly to the cgroup hierarchy, and the various objects can be assigned to any of the slices in the tree.
2013-06-17 21:33:26 +02:00
CGROUP_CONTEXT_CONFIG_ITEMS(Service)m4_dnl
unit: split off KillContext from ExecContext containing only kill definitions
2012-07-19 23:47:10 +02:00
KILL_CONTEXT_CONFIG_ITEMS(Service)m4_dnl
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
m4_dnl
units: for all unit settings that take lists, allow the empty string for resetting the lists https://bugzilla.redhat.com/show_bug.cgi?id=756787
2013-01-17 02:27:06 +01:00
Socket.ListenStream, config_parse_socket_listen, SOCKET_SOCKET, 0
Socket.ListenDatagram, config_parse_socket_listen, SOCKET_SOCKET, 0
Socket.ListenSequentialPacket, config_parse_socket_listen, SOCKET_SOCKET, 0
Socket.ListenFIFO, config_parse_socket_listen, SOCKET_FIFO, 0
Socket.ListenNetlink, config_parse_socket_listen, SOCKET_SOCKET, 0
Socket.ListenSpecial, config_parse_socket_listen, SOCKET_SPECIAL, 0
Socket.ListenMessageQueue, config_parse_socket_listen, SOCKET_MQUEUE, 0
core: Add socket type for usb functionfs endpoints For handling functionfs endpoints additional socket type is added.
2015-09-21 15:43:47 +02:00
Socket.ListenUSBFunction, config_parse_socket_listen, SOCKET_USB_FUNCTION, 0
load-fragment: make SocketProtocol= accept the empty string
2018-05-29 05:49:47 +02:00
Socket.SocketProtocol, config_parse_socket_protocol, 0, offsetof(Socket, socket_protocol)
socket-util: rename parse_socket_address_bind_ipv6_only_or_bool() to socket_address_bind_ipv6_only_or_bool_from_string() Hence, we can define config_parse_socket_bind() by using DEFINE_CONFIG_PARSE_ENUM() macro.
2018-05-29 05:40:28 +02:00
Socket.BindIPv6Only, config_parse_socket_bind, 0, offsetof(Socket, bind_ipv6_only)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Socket.Backlog, config_parse_unsigned, 0, offsetof(Socket, backlog)
Socket.BindToDevice, config_parse_socket_bindtodevice, 0, 0
Socket.ExecStartPre, config_parse_exec, SOCKET_EXEC_START_PRE, offsetof(Socket, exec_command)
Socket.ExecStartPost, config_parse_exec, SOCKET_EXEC_START_POST, offsetof(Socket, exec_command)
Socket.ExecStopPre, config_parse_exec, SOCKET_EXEC_STOP_PRE, offsetof(Socket, exec_command)
Socket.ExecStopPost, config_parse_exec, SOCKET_EXEC_STOP_POST, offsetof(Socket, exec_command)
Allow TimeoutSec=0 to work as documented in mount units and elsewhere (#6013) Since commit 36c16a7cdd6c ("core: rework unit timeout handling, and add new setting RuntimeMaxSec=") TimeoutSec=0 in mount units has cause the mount to timeout immediately instead of never as documented. There is a similar problem with Socket.TimeoutSec and Swap.TimeoutSec. These are easily fixed using config_parse_sec_fix_0(). Automount.TimeoutIdleSec looks like it could have the same problem, but doesn't because the kernel treats '0' as 'no timeout'. It handle USEC_INFINITY correctly only because that constant has the value '-1', and when round up, it becomes zero. To avoid possible confusion, use config_parse_sec_fix_0() as well, and explicitly handle USEC_INFINITY.
2017-05-23 09:42:26 +02:00
Socket.TimeoutSec, config_parse_sec_fix_0, 0, offsetof(Socket, timeout_usec)
shared/user-util: allow usernames with dots in specific fields People do have usernames with dots, and it makes them very unhappy that systemd doesn't like their that. It seems that there is no actual problem with allowing dots in the username. In particular chown declares ":" as the official separator, and internally in systemd we never rely on "." as the seperator between user and group (nor do we call chown directly). Using dots in the name is probably not a very good idea, but we don't need to care. Debian tools (adduser) do not allow users with dots to be created. This patch allows *existing* names with dots to be used in User, Group, SupplementaryGroups, SocketUser, SocketGroup fields, both in unit files and on the command line. DynamicUsers and sysusers still follow the strict policy. user@.service and tmpfiles already allowed arbitrary user names, and this remains unchanged. Fixes #12754.
2019-08-01 09:58:27 +02:00
Socket.SocketUser, config_parse_user_group_compat, 0, offsetof(Socket, user)
Socket.SocketGroup, config_parse_user_group_compat, 0, offsetof(Socket, group)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Socket.SocketMode, config_parse_mode, 0, offsetof(Socket, socket_mode)
socket: add SocketUser= and SocketGroup= for chown()ing sockets in the file system This is relatively complex, as we cannot invoke NSS from PID 1, and thus need to fork a helper process temporarily.
2014-06-05 09:55:53 +02:00
Socket.DirectoryMode, config_parse_mode, 0, offsetof(Socket, directory_mode)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Socket.Accept, config_parse_bool, 0, offsetof(Socket, accept)
core: add new setting Writable= to ListenSpecial= socket units Writable= is a new boolean setting. If ture, then ListenSpecial= will open the specified path in O_RDWR mode, rather than just O_RDONLY. This is useful for implementing services like rfkill, where /dev/rfkill is more useful when opened in write mode, if we want to not only save but also restore its state.
2015-10-01 14:28:13 +02:00
Socket.Writable, config_parse_bool, 0, offsetof(Socket, writable)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Socket.MaxConnections, config_parse_unsigned, 0, offsetof(Socket, max_connections)
socket: add support to control no. of connections from one source (#3607) Introduce MaxConnectionsPerSource= that is number of concurrent connections allowed per IP. RFE: 1939
2016-08-02 19:48:23 +02:00
Socket.MaxConnectionsPerSource, config_parse_unsigned, 0, offsetof(Socket, max_connections_per_source)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Socket.KeepAlive, config_parse_bool, 0, offsetof(Socket, keep_alive)
socket: suffix newly added TCP sockopt time properties with "Sec" This is what we have done so far for all other time values, and hence we should do this here. This indicates the default unit of time values specified here, if they don't contain a unit.
2014-08-19 21:57:37 +02:00
Socket.KeepAliveTimeSec, config_parse_sec, 0, offsetof(Socket, keep_alive_time)
Socket.KeepAliveIntervalSec, config_parse_sec, 0, offsetof(Socket, keep_alive_interval)
socket: Add Support for TCP keep alive variables The tcp keep alive variables now can be configured via conf parameter. Follwing variables are now supported by this patch. tcp_keepalive_intvl: The number of seconds between TCP keep-alive probes tcp_keepalive_probes: The maximum number of TCP keep-alive probes to send before giving up and killing the connection if no response is obtained from the other end. tcp_keepalive_time: The number of seconds a connection needs to be idle before TCP begins sending out keep-alive probes.
2014-08-14 19:36:11 +02:00
Socket.KeepAliveProbes, config_parse_unsigned, 0, offsetof(Socket, keep_alive_cnt)
socket: suffix newly added TCP sockopt time properties with "Sec" This is what we have done so far for all other time values, and hence we should do this here. This indicates the default unit of time values specified here, if they don't contain a unit.
2014-08-19 21:57:37 +02:00
Socket.DeferAcceptSec, config_parse_sec, 0, offsetof(Socket, defer_accept)
socket: add support for tcp nagle This patch adds support for TCP TCP_NODELAY socket option. This can be configured via NoDelay conf parameter. TCP Nagle's algorithm works by combining a number of small outgoing messages, and sending them all at once. This controls the TCP_NODELAY socket option.
2014-07-28 08:48:29 +02:00
Socket.NoDelay, config_parse_bool, 0, offsetof(Socket, no_delay)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Socket.Priority, config_parse_int, 0, offsetof(Socket, priority)
core: clean up some confusing regarding SI decimal and IEC binary suffixes for sizes According to Wikipedia it is customary to specify hardware metrics and transfer speeds to the basis 1000 (SI decimal), while software metrics and physical volatile memory (RAM) sizes to the basis 1024 (IEC binary). So far we specified everything in IEC, let's fix that and be more true to what's otherwise customary. Since we don't want to parse "Mi" instead of "M" we document each time what the context used is.
2014-02-23 03:13:54 +01:00
Socket.ReceiveBuffer, config_parse_iec_size, 0, offsetof(Socket, receive_buffer)
Socket.SendBuffer, config_parse_iec_size, 0, offsetof(Socket, send_buffer)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Socket.IPTOS, config_parse_ip_tos, 0, offsetof(Socket, ip_tos)
Socket.IPTTL, config_parse_int, 0, offsetof(Socket, ip_ttl)
Socket.Mark, config_parse_int, 0, offsetof(Socket, mark)
core: clean up some confusing regarding SI decimal and IEC binary suffixes for sizes According to Wikipedia it is customary to specify hardware metrics and transfer speeds to the basis 1000 (SI decimal), while software metrics and physical volatile memory (RAM) sizes to the basis 1024 (IEC binary). So far we specified everything in IEC, let's fix that and be more true to what's otherwise customary. Since we don't want to parse "Mi" instead of "M" we document each time what the context used is.
2014-02-23 03:13:54 +01:00
Socket.PipeSize, config_parse_iec_size, 0, offsetof(Socket, pipe_size)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Socket.FreeBind, config_parse_bool, 0, offsetof(Socket, free_bind)
Socket.Transparent, config_parse_bool, 0, offsetof(Socket, transparent)
Socket.Broadcast, config_parse_bool, 0, offsetof(Socket, broadcast)
socket: rename the PassCred= option to PassCredentials=, since we don't want to needlessly abbreviate options unless they are very well established
2011-12-31 01:07:49 +01:00
Socket.PassCredentials, config_parse_bool, 0, offsetof(Socket, pass_cred)
socket: add option for SO_PASSEC https://bugzilla.redhat.com/show_bug.cgi?id=798760 (Note that this work is not complete yet, as the kernel seems to send us useless data with SCM_SECURITY enabled)
2012-03-13 00:00:27 +01:00
Socket.PassSecurity, config_parse_bool, 0, offsetof(Socket, pass_sec)
core: add new PassPacketInfo= socket unit property
2020-05-27 19:36:56 +02:00
Socket.PassPacketInfo, config_parse_bool, 0, offsetof(Socket, pass_pktinfo)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Socket.TCPCongestion, config_parse_string, 0, offsetof(Socket, tcp_congestion)
core: convert PID 1 to libsystemd-bus This patch converts PID 1 to libsystemd-bus and thus drops the dependency on libdbus. The only remaining code using libdbus is a test case that validates our bus marshalling against libdbus' marshalling, and this dependency can be turned off. This patch also adds a couple of things to libsystem-bus, that are necessary to make the port work: - Synthesizing of "Disconnected" messages when bus connections are severed. - Support for attaching multiple vtables for the same interface on the same path. This patch also fixes the SetDefaultTarget() and GetDefaultTarget() bus calls which used an inappropriate signature. As a side effect we will now generate PropertiesChanged messages which carry property contents, rather than just invalidation information.
2013-11-19 21:12:59 +01:00
Socket.ReusePort, config_parse_bool, 0, offsetof(Socket, reuse_port)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Socket.MessageQueueMaxMessages, config_parse_long, 0, offsetof(Socket, mq_maxmsg)
Socket.MessageQueueMessageSize, config_parse_long, 0, offsetof(Socket, mq_msgsize)
socket: optionally remove sockets/FIFOs in the file system after use
2014-06-04 13:10:43 +02:00
Socket.RemoveOnStop, config_parse_bool, 0, offsetof(Socket, remove_on_stop)
socket: add new Symlinks= option for socket units With Symlinks= we can manage one or more symlinks to AF_UNIX or FIFO nodes in the file system, with the same lifecycle as the socket itself. This has two benefits: first, this allows us to remove /dev/log and /dev/initctl from /dev, thus leaving only symlinks, device nodes and directories in the /dev tree. More importantly however, this allows us to move /dev/log out of /dev, while still making it accessible there, so that PrivateDevices= can provide /dev/log too.
2014-06-04 16:19:00 +02:00
Socket.Symlinks, config_parse_unit_path_strv_printf, 0, offsetof(Socket, symlinks)
core: add support for naming file descriptors passed using socket activation This adds support for naming file descriptors passed using socket activation. The names are passed in a new $LISTEN_FDNAMES= environment variable, that matches the existign $LISTEN_FDS= one and contains a colon-separated list of names. This also adds support for naming fds submitted to the per-service fd store using FDNAME= in the sd_notify() message. This also adds a new FileDescriptorName= setting for socket unit files to set the name for fds created by socket units. This also adds a new call sd_listen_fds_with_names(), that is similar to sd_listen_fds(), but also returns the names of the fds. systemd-activate gained the new --fdname= switch to specify a name for testing socket activation. This is based on #1247 by Maciej Wereski. Fixes #1247.
2015-10-04 17:36:19 +02:00
Socket.FileDescriptorName, config_parse_fdname, 0, 0
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Socket.Service, config_parse_socket_service, 0, 0
core: introduce activation rate limiting for socket units This adds two new settings TriggerLimitIntervalSec= and TriggerLimitBurst= that define a rate limit for activation of socket units. When the limit is hit, the socket is is put into a failure mode. This is an alternative fix for #2467, since the original fix resulted in issue #2684. In a later commit the StartLimitInterval=/StartLimitBurst= rate limiter will be changed to be applied after any start conditions checks are made. This way, there are two separate rate limiters enforced: one at triggering time, before any jobs are queued with this patch, as well as the start limit that is moved again to be run immediately before the unit is activated. Condition checks are done in between the two, and thus no longer affect the start limit.
2016-04-26 20:26:15 +02:00
Socket.TriggerLimitIntervalSec, config_parse_sec, 0, offsetof(Socket, trigger_limit.interval)
Socket.TriggerLimitBurst, config_parse_unsigned, 0, offsetof(Socket, trigger_limit.burst)
build-sys: s/HAVE_SMACK/ENABLE_SMACK/ Same justification as for HAVE_UTMP.
2017-10-03 12:22:40 +02:00
m4_ifdef(`ENABLE_SMACK',
core: turn on specifier expansion for more unit file settings Let's permit specifier expansion at a numbre of additional fields, where arbitrary strings might be passed where this might be useful one day. (Or at least where there's no clear reason where it wouldn't make sense to have.)
2016-12-05 19:38:39 +01:00
`Socket.SmackLabel, config_parse_unit_string_printf, 0, offsetof(Socket, smack)
Socket.SmackLabelIPIn, config_parse_unit_string_printf, 0, offsetof(Socket, smack_ip_in)
Socket.SmackLabelIPOut, config_parse_unit_string_printf, 0, offsetof(Socket, smack_ip_out)',
When warning about unsupported options, be more detailed
2014-11-30 16:21:49 +01:00
`Socket.SmackLabel, config_parse_warn_compat, DISABLED_CONFIGURATION, 0
Socket.SmackLabelIPIn, config_parse_warn_compat, DISABLED_CONFIGURATION, 0
Socket.SmackLabelIPOut, config_parse_warn_compat, DISABLED_CONFIGURATION, 0')
socket: introduce SELinuxContextFromNet option This makes possible to spawn service instances triggered by socket with MLS/MCS SELinux labels which are created based on information provided by connected peer. Implementation of label_get_child_mls_label derived from xinetd. Reviewed-by: Paul Moore <pmoore@redhat.com>
2014-07-24 10:40:28 +02:00
m4_ifdef(`HAVE_SELINUX',
`Socket.SELinuxContextFromNet, config_parse_bool, 0, offsetof(Socket, selinux_context_from_net)',
When warning about unsupported options, be more detailed
2014-11-30 16:21:49 +01:00
`Socket.SELinuxContextFromNet, config_parse_warn_compat, DISABLED_CONFIGURATION, 0')
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
EXEC_CONTEXT_CONFIG_ITEMS(Socket)m4_dnl
core: add new .slice unit type for partitioning systems In order to prepare for the kernel cgroup rework, let's introduce a new unit type to systemd, the "slice". Slices can be arranged in a tree and are useful to partition resources freely and hierarchally by the user. Each service unit can now be assigned to one of these slices, and later on login users and machines may too. Slices translate pretty directly to the cgroup hierarchy, and the various objects can be assigned to any of the slices in the tree.
2013-06-17 21:33:26 +02:00
CGROUP_CONTEXT_CONFIG_ITEMS(Socket)m4_dnl
unit: split off KillContext from ExecContext containing only kill definitions
2012-07-19 23:47:10 +02:00
KILL_CONTEXT_CONFIG_ITEMS(Socket)m4_dnl
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
m4_dnl
core: turn on specifier expansion for more unit file settings Let's permit specifier expansion at a numbre of additional fields, where arbitrary strings might be passed where this might be useful one day. (Or at least where there's no clear reason where it wouldn't make sense to have.)
2016-12-05 19:38:39 +01:00
Mount.What, config_parse_unit_string_printf, 0, offsetof(Mount, parameters_fragment.what)
core: enable specifier expansion for What=/Where=/Type=/SourcePath= too Using specifiers in these settings isn't particularly useful by itself, but it unifies behaviour a bit. It's kinda surprising that What= in mount units resolves specifies, but Where= does not. Hence let's add that too. Also, it's surprising Where=/What= in mount units behaves differently than in automount and swap units, hence resolve specifiers there too. Then, Type= in mount units is nowadays an arbitrary, sometimes non-trivial string (think fuse!), hence let's also expand specifiers there, to match the rest of the mount settings. This has the benefit that when writing code that generates unit files, less care has to be taken to check whether escaping of specifiers is necessary or not: broadly everything that takes arbitrary user strings now does specifier expansion, while enums/numerics/booleans do not.
2017-11-21 20:03:51 +01:00
Mount.Where, config_parse_unit_path_printf, 0, offsetof(Mount, where)
core: turn on specifier expansion for more unit file settings Let's permit specifier expansion at a numbre of additional fields, where arbitrary strings might be passed where this might be useful one day. (Or at least where there's no clear reason where it wouldn't make sense to have.)
2016-12-05 19:38:39 +01:00
Mount.Options, config_parse_unit_string_printf, 0, offsetof(Mount, parameters_fragment.options)
core: enable specifier expansion for What=/Where=/Type=/SourcePath= too Using specifiers in these settings isn't particularly useful by itself, but it unifies behaviour a bit. It's kinda surprising that What= in mount units resolves specifies, but Where= does not. Hence let's add that too. Also, it's surprising Where=/What= in mount units behaves differently than in automount and swap units, hence resolve specifiers there too. Then, Type= in mount units is nowadays an arbitrary, sometimes non-trivial string (think fuse!), hence let's also expand specifiers there, to match the rest of the mount settings. This has the benefit that when writing code that generates unit files, less care has to be taken to check whether escaping of specifiers is necessary or not: broadly everything that takes arbitrary user strings now does specifier expansion, while enums/numerics/booleans do not.
2017-11-21 20:03:51 +01:00
Mount.Type, config_parse_unit_string_printf, 0, offsetof(Mount, parameters_fragment.fstype)
Allow TimeoutSec=0 to work as documented in mount units and elsewhere (#6013) Since commit 36c16a7cdd6c ("core: rework unit timeout handling, and add new setting RuntimeMaxSec=") TimeoutSec=0 in mount units has cause the mount to timeout immediately instead of never as documented. There is a similar problem with Socket.TimeoutSec and Swap.TimeoutSec. These are easily fixed using config_parse_sec_fix_0(). Automount.TimeoutIdleSec looks like it could have the same problem, but doesn't because the kernel treats '0' as 'no timeout'. It handle USEC_INFINITY correctly only because that constant has the value '-1', and when round up, it becomes zero. To avoid possible confusion, use config_parse_sec_fix_0() as well, and explicitly handle USEC_INFINITY.
2017-05-23 09:42:26 +02:00
Mount.TimeoutSec, config_parse_sec_fix_0, 0, offsetof(Mount, timeout_usec)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Mount.DirectoryMode, config_parse_mode, 0, offsetof(Mount, directory_mode)
mount: add new SloppyOptions= setting for mount units, mapping to mount(8)'s "-s" switch
2014-06-16 01:02:27 +02:00
Mount.SloppyOptions, config_parse_bool, 0, offsetof(Mount, sloppy_options)
mount: add new LazyUnmount= setting for mount units, mapping to umount(8)'s "-l" switch (#3827)
2016-08-26 17:57:22 +02:00
Mount.LazyUnmount, config_parse_bool, 0, offsetof(Mount, lazy_unmount)
mount: add new ForceUnmount= setting for mount units, mapping to umount(8)'s "-f" switch
2016-08-27 16:27:49 +02:00
Mount.ForceUnmount, config_parse_bool, 0, offsetof(Mount, force_unmount)
mount: add ReadWriteOnly property to fail on read-only mounts Systems where a mount point is expected to be read-write needs a way to fail mount units that fallback as read-only. Add a property to allow setting the -w option when calling mount(8).
2020-05-01 10:20:17 +02:00
Mount.ReadWriteOnly, config_parse_bool, 0, offsetof(Mount, read_write_only)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
EXEC_CONTEXT_CONFIG_ITEMS(Mount)m4_dnl
core: add new .slice unit type for partitioning systems In order to prepare for the kernel cgroup rework, let's introduce a new unit type to systemd, the "slice". Slices can be arranged in a tree and are useful to partition resources freely and hierarchally by the user. Each service unit can now be assigned to one of these slices, and later on login users and machines may too. Slices translate pretty directly to the cgroup hierarchy, and the various objects can be assigned to any of the slices in the tree.
2013-06-17 21:33:26 +02:00
CGROUP_CONTEXT_CONFIG_ITEMS(Mount)m4_dnl
unit: split off KillContext from ExecContext containing only kill definitions
2012-07-19 23:47:10 +02:00
KILL_CONTEXT_CONFIG_ITEMS(Mount)m4_dnl
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
m4_dnl
core: enable specifier expansion for What=/Where=/Type=/SourcePath= too Using specifiers in these settings isn't particularly useful by itself, but it unifies behaviour a bit. It's kinda surprising that What= in mount units resolves specifies, but Where= does not. Hence let's add that too. Also, it's surprising Where=/What= in mount units behaves differently than in automount and swap units, hence resolve specifiers there too. Then, Type= in mount units is nowadays an arbitrary, sometimes non-trivial string (think fuse!), hence let's also expand specifiers there, to match the rest of the mount settings. This has the benefit that when writing code that generates unit files, less care has to be taken to check whether escaping of specifiers is necessary or not: broadly everything that takes arbitrary user strings now does specifier expansion, while enums/numerics/booleans do not.
2017-11-21 20:03:51 +01:00
Automount.Where, config_parse_unit_path_printf, 0, offsetof(Automount, where)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Automount.DirectoryMode, config_parse_mode, 0, offsetof(Automount, directory_mode)
Allow TimeoutSec=0 to work as documented in mount units and elsewhere (#6013) Since commit 36c16a7cdd6c ("core: rework unit timeout handling, and add new setting RuntimeMaxSec=") TimeoutSec=0 in mount units has cause the mount to timeout immediately instead of never as documented. There is a similar problem with Socket.TimeoutSec and Swap.TimeoutSec. These are easily fixed using config_parse_sec_fix_0(). Automount.TimeoutIdleSec looks like it could have the same problem, but doesn't because the kernel treats '0' as 'no timeout'. It handle USEC_INFINITY correctly only because that constant has the value '-1', and when round up, it becomes zero. To avoid possible confusion, use config_parse_sec_fix_0() as well, and explicitly handle USEC_INFINITY.
2017-05-23 09:42:26 +02:00
Automount.TimeoutIdleSec, config_parse_sec_fix_0, 0, offsetof(Automount, timeout_idle_usec)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
m4_dnl
core: enable specifier expansion for What=/Where=/Type=/SourcePath= too Using specifiers in these settings isn't particularly useful by itself, but it unifies behaviour a bit. It's kinda surprising that What= in mount units resolves specifies, but Where= does not. Hence let's add that too. Also, it's surprising Where=/What= in mount units behaves differently than in automount and swap units, hence resolve specifiers there too. Then, Type= in mount units is nowadays an arbitrary, sometimes non-trivial string (think fuse!), hence let's also expand specifiers there, to match the rest of the mount settings. This has the benefit that when writing code that generates unit files, less care has to be taken to check whether escaping of specifiers is necessary or not: broadly everything that takes arbitrary user strings now does specifier expansion, while enums/numerics/booleans do not.
2017-11-21 20:03:51 +01:00
Swap.What, config_parse_unit_path_printf, 0, offsetof(Swap, parameters_fragment.what)
core: initialize priority_set when parsing swap unit files Fixes: #14524
2020-01-09 17:02:56 +01:00
Swap.Priority, config_parse_swap_priority, 0, 0
core: turn on specifier expansion for more unit file settings Let's permit specifier expansion at a numbre of additional fields, where arbitrary strings might be passed where this might be useful one day. (Or at least where there's no clear reason where it wouldn't make sense to have.)
2016-12-05 19:38:39 +01:00
Swap.Options, config_parse_unit_string_printf, 0, offsetof(Swap, parameters_fragment.options)
Allow TimeoutSec=0 to work as documented in mount units and elsewhere (#6013) Since commit 36c16a7cdd6c ("core: rework unit timeout handling, and add new setting RuntimeMaxSec=") TimeoutSec=0 in mount units has cause the mount to timeout immediately instead of never as documented. There is a similar problem with Socket.TimeoutSec and Swap.TimeoutSec. These are easily fixed using config_parse_sec_fix_0(). Automount.TimeoutIdleSec looks like it could have the same problem, but doesn't because the kernel treats '0' as 'no timeout'. It handle USEC_INFINITY correctly only because that constant has the value '-1', and when round up, it becomes zero. To avoid possible confusion, use config_parse_sec_fix_0() as well, and explicitly handle USEC_INFINITY.
2017-05-23 09:42:26 +02:00
Swap.TimeoutSec, config_parse_sec_fix_0, 0, offsetof(Swap, timeout_usec)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
EXEC_CONTEXT_CONFIG_ITEMS(Swap)m4_dnl
core: add new .slice unit type for partitioning systems In order to prepare for the kernel cgroup rework, let's introduce a new unit type to systemd, the "slice". Slices can be arranged in a tree and are useful to partition resources freely and hierarchally by the user. Each service unit can now be assigned to one of these slices, and later on login users and machines may too. Slices translate pretty directly to the cgroup hierarchy, and the various objects can be assigned to any of the slices in the tree.
2013-06-17 21:33:26 +02:00
CGROUP_CONTEXT_CONFIG_ITEMS(Swap)m4_dnl
unit: split off KillContext from ExecContext containing only kill definitions
2012-07-19 23:47:10 +02:00
KILL_CONTEXT_CONFIG_ITEMS(Swap)m4_dnl
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
m4_dnl
core: simply timer expression parsing by using ".ltype" field of conf-parser logic No change of behaviour. Let's just not parse the lvalue all the time with timer_base_from_string() if we can already pass it in parsed.
2019-04-01 17:39:11 +02:00
Timer.OnCalendar, config_parse_timer, TIMER_CALENDAR, 0
Timer.OnActiveSec, config_parse_timer, TIMER_ACTIVE, 0
Timer.OnBootSec, config_parse_timer, TIMER_BOOT, 0
Timer.OnStartupSec, config_parse_timer, TIMER_STARTUP, 0
Timer.OnUnitActiveSec, config_parse_timer, TIMER_UNIT_ACTIVE, 0
Timer.OnUnitInactiveSec, config_parse_timer, TIMER_UNIT_INACTIVE, 0
core: optionally, trigger .timer units on timezone and clock changes Fixes: #6228
2019-03-14 21:36:47 +01:00
Timer.OnClockChange, config_parse_bool, 0, offsetof(Timer, on_clock_change)
Timer.OnTimezoneChange, config_parse_bool, 0, offsetof(Timer, on_timezone_change)
timer: add timer persistance (aka anacron-like behaviour)
2014-03-21 03:25:28 +01:00
Timer.Persistent, config_parse_bool, 0, offsetof(Timer, persistent)
timer: support timers that can resume the system from suspend
2014-03-24 16:09:54 +01:00
Timer.WakeSystem, config_parse_bool, 0, offsetof(Timer, wake_system)
core: add RemainAfterElapse= setting to timer units Previously, after a timer unit elapsed we'd leave it around for good, which has the nice benefit that starting a timer that shall trigger at a specific point in time multiple times will only result in one trigger instead of possibly many. With this change a new option RemainAfterElapse= is added. It defaults to "true", to mimic the old behaviour. If set to "false" timer units will be unloaded after they elapsed. This is specifically useful for transient timer units.
2015-11-17 20:13:36 +01:00
Timer.RemainAfterElapse, config_parse_bool, 0, offsetof(Timer, remain_after_elapse)
timer: make timer accuracy configurable And make it default to 1min
2013-11-21 22:07:51 +01:00
Timer.AccuracySec, config_parse_sec, 0, offsetof(Timer, accuracy_usec)
core: rename Random* to RandomizedDelay* The name RandomSec is too generic: "Sec" just specifies the default unit type, and "Random" by itself is not enough. Rename to something that should give the user general idea what the setting does without looking at documentation.
2015-11-26 22:32:41 +01:00
Timer.RandomizedDelaySec, config_parse_sec, 0, offsetof(Timer, random_usec)
unit: rework trigger dependency logic Instead of having explicit type-specific callbacks that inform the triggering unit when a triggered unit changes state, make this generic so that state changes are forwarded betwee any triggered and triggering unit. Also, get rid of UnitRef references from automount, timer, path units, to the units they trigger and rely exclsuively on UNIT_TRIGGER type dendencies.
2013-04-23 20:53:16 +02:00
Timer.Unit, config_parse_trigger_unit, 0, 0
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
m4_dnl
Path.PathExists, config_parse_path_spec, 0, 0
Path.PathExistsGlob, config_parse_path_spec, 0, 0
Path.PathChanged, config_parse_path_spec, 0, 0
path: add missing pieces for PathModified PATH_MODIFIED worked internally for PID files detection, but was unusable in units.
2011-12-08 12:09:10 +01:00
Path.PathModified, config_parse_path_spec, 0, 0
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Path.DirectoryNotEmpty, config_parse_path_spec, 0, 0
unit: rework trigger dependency logic Instead of having explicit type-specific callbacks that inform the triggering unit when a triggered unit changes state, make this generic so that state changes are forwarded betwee any triggered and triggering unit. Also, get rid of UnitRef references from automount, timer, path units, to the units they trigger and rely exclsuively on UNIT_TRIGGER type dendencies.
2013-04-23 20:53:16 +02:00
Path.Unit, config_parse_trigger_unit, 0, 0
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Path.MakeDirectory, config_parse_bool, 0, offsetof(Path, make_directory)
Path.DirectoryMode, config_parse_mode, 0, offsetof(Path, directory_mode)
core: add new .slice unit type for partitioning systems In order to prepare for the kernel cgroup rework, let's introduce a new unit type to systemd, the "slice". Slices can be arranged in a tree and are useful to partition resources freely and hierarchally by the user. Each service unit can now be assigned to one of these slices, and later on login users and machines may too. Slices translate pretty directly to the cgroup hierarchy, and the various objects can be assigned to any of the slices in the tree.
2013-06-17 21:33:26 +02:00
m4_dnl
CGROUP_CONTEXT_CONFIG_ITEMS(Slice)m4_dnl
unit: save description/slice of transient units to /run This is necessary so that these properties survive a daemon reload.
2013-07-10 21:13:56 +02:00
m4_dnl
CGROUP_CONTEXT_CONFIG_ITEMS(Scope)m4_dnl
core: make sure scope attributes survive a reload
2013-07-30 02:50:44 +02:00
KILL_CONTEXT_CONFIG_ITEMS(Scope)m4_dnl
scope: Support RuntimeMaxSec= directive in scope units Just as `RuntimeMaxSec=` is supported for service units, add support for it to scope units. This will gracefully kill a scope after the timeout expires from the moment the scope enters the running state. This could be used for time-limited login sessions, for example. Signed-off-by: Philip Withnall <withnall@endlessm.com> Fixes: #12035
2019-06-12 09:45:26 +02:00
Scope.RuntimeMaxSec, config_parse_sec, 0, offsetof(Scope, runtime_max_usec)
core: make sure scope attributes survive a reload
2013-07-30 02:50:44 +02:00
Scope.TimeoutStopSec, config_parse_sec, 0, offsetof(Scope, timeout_stop_usec)
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
m4_dnl The [Install] section is ignored here.
Install.Alias, NULL, 0, 0
Install.WantedBy, NULL, 0, 0
unit: introduce RequiredBy= setting in [Install], to complement WantedBy=
2012-05-21 15:27:26 +02:00
Install.RequiredBy, NULL, 0, 0
load-fragment: speed up parsing by using a perfect hash table with configuration settings built by gperf
2011-08-01 00:43:05 +02:00
Install.Also, NULL, 0, 0
install: introduce new DefaultInstance= field for [Install] sections The DefaultInstance= name is used when enabling template units when only specifying the template name, but no instance. Add DefaultInstance=tty1 to getty@.service, so that when the template itself is enabled an instance for tty1 is created. This is useful so that we "systemctl preset-all" can work properly, because we can operate on getty@.service after finding it, and the right instance is created.
2014-06-17 00:15:31 +02:00
Install.DefaultInstance, NULL, 0, 0
Reference in a new issue Copy permalink