HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

man/systemd.exec.xml

343,875 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 151cff518a70dc4761d7305857f83b6888834572

Lines 2001–3000 of 5,316

              <row>
                <entry><varname>DefaultDependency=no</varname></entry>
                <entry>no</entry>
                <entry><varname>$TMPDIR=/tmp</varname></entry>
                <entry>(none)</entry>
              </row>
            </tbody>
          </tgroup>
        </table>
 
        <para>Note that the implementation of this setting might be impossible (for example if mount namespaces are not
        available), and the unit should be written in a way that does not solely rely on this setting for
        security.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>PrivateDevices=</varname></term>
 
        <listitem><para>Takes a boolean argument. If true, sets up a new <filename>/dev/</filename> mount for
        the executed processes and only adds API pseudo devices such as <filename>/dev/null</filename>,
        <filename>/dev/zero</filename> or <filename>/dev/random</filename> (as well as the pseudo TTY
        subsystem) to it, but no physical devices such as <filename>/dev/sda</filename>, system memory
        <filename>/dev/mem</filename>, system ports <filename>/dev/port</filename> and others. This is useful
        to turn off physical device access by the executed process. Defaults to false.</para>
 
        <para>Enabling this option will install a system call filter to block low-level I/O system calls that
        are grouped in the <varname>@raw-io</varname> set, remove <constant>CAP_MKNOD</constant> and
        <constant>CAP_SYS_RAWIO</constant> from the capability bounding set for the unit, and set
        <varname>DevicePolicy=closed</varname> (see
        <citerefentry><refentrytitle>systemd.resource-control</refentrytitle><manvolnum>5</manvolnum></citerefentry>
        for details). Note that using this setting will disconnect propagation of mounts from the service to
        the host (propagation in the opposite direction continues to work). This means that this setting may
        not be used for services which shall be able to install mount points in the main mount namespace. The
        new <filename>/dev/</filename> will be mounted read-only and 'noexec'. The latter may break old
        programs which try to set up executable memory by using
        <citerefentry><refentrytitle>mmap</refentrytitle><manvolnum>2</manvolnum></citerefentry> of
        <filename>/dev/zero</filename> instead of using <constant>MAP_ANON</constant>. For this setting the
        same restrictions regarding mount propagation and privileges apply as for
        <varname>ReadOnlyPaths=</varname> and related calls, see above.</para>
 
        <para>Note that the implementation of this setting might be impossible (for example if mount
        namespaces are not available), and the unit should be written in a way that does not solely rely on
        this setting for security.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/>
 
        <para>When access to some but not all devices must be possible, the <varname>DeviceAllow=</varname>
        setting might be used instead. See
        <citerefentry><refentrytitle>systemd.resource-control</refentrytitle><manvolnum>5</manvolnum></citerefentry>.
        </para>
 
        <xi:include href="version-info.xml" xpointer="v209"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>PrivateNetwork=</varname></term>
 
        <listitem><para>Takes a boolean argument. If true, sets up a new network namespace for the executed processes
        and configures only the loopback network device <literal>lo</literal> inside it. No other network devices will
        be available to the executed process. This is useful to turn off network access by the executed process.
        Defaults to false. It is possible to run two or more units within the same private network namespace by using
        the <varname>JoinsNamespaceOf=</varname> directive, see
        <citerefentry><refentrytitle>systemd.unit</refentrytitle><manvolnum>5</manvolnum></citerefentry> for
        details. Note that this option will disconnect all socket families from the host, including
        <constant>AF_NETLINK</constant> and <constant>AF_UNIX</constant>. Effectively, for
        <constant>AF_NETLINK</constant> this means that device configuration events received from
        <citerefentry><refentrytitle>systemd-udevd.service</refentrytitle><manvolnum>8</manvolnum></citerefentry> are
        not delivered to the unit's processes. And for <constant>AF_UNIX</constant> this has the effect that
        <constant>AF_UNIX</constant> sockets in the abstract socket namespace of the host will become unavailable to
        the unit's processes (however, those located in the file system will continue to be accessible).</para>
 
        <para>Note that the implementation of this setting might be impossible (for example if network namespaces are
        not available), and the unit should be written in a way that does not solely rely on this setting for
        security.</para>
 
        <para>When this option is enabled, <varname>PrivateMounts=</varname> is implied unless it is
        explicitly disabled, and <filename>/sys</filename> will be remounted to associate it with the new
        network namespace.</para>
 
        <para>When this option is used on a socket unit any sockets bound on behalf of this unit will be
        bound within a private network namespace. This may be combined with
        <varname>JoinsNamespaceOf=</varname> to listen on sockets inside of network namespaces of other
        services.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>UserNamespacePath=</varname></term>
 
        <listitem><para>Takes an absolute file system path referring to a Linux user namespace
        pseudo-file (i.e. a file like <filename>/proc/$PID/ns/user</filename> or a bind mount or symlink to
        one). When set the invoked processes are added to the user namespace referenced by that path. The
        path has to point to a valid namespace file at the moment the processes are forked off. If this
        option is used <varname>PrivateUsers=</varname> has no effect.</para>
 
        <para>This option is only available for system services.</para>
 
        <xi:include href="version-info.xml" xpointer="v259"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>NetworkNamespacePath=</varname></term>
 
        <listitem><para>Takes an absolute file system path referring to a Linux network namespace
        pseudo-file (i.e. a file like <filename>/proc/$PID/ns/net</filename> or a bind mount or symlink to
        one). When set the invoked processes are added to the network namespace referenced by that path. The
        path has to point to a valid namespace file at the moment the processes are forked off. If this
        option is used <varname>PrivateNetwork=</varname> has no effect. If this option is used together with
        <varname>JoinsNamespaceOf=</varname> then it only has an effect if this unit is started before any of
        the listed units that have <varname>PrivateNetwork=</varname> or
        <varname>NetworkNamespacePath=</varname> configured, as otherwise the network namespace of those
        units is reused.</para>
 
        <para>When this option is enabled, <varname>PrivateMounts=</varname> is implied unless it is
        explicitly disabled, and <filename>/sys</filename> will be remounted to associate it with the new
        network namespace.</para>
 
        <para>When this option is used on a socket unit any sockets bound on behalf of this unit will be
        bound within the specified network namespace.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v242"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>PrivateIPC=</varname></term>
 
        <listitem><para>Takes a boolean argument. If true, sets up a new IPC namespace for the executed processes.
        Each IPC namespace has its own set of System V IPC identifiers and its own POSIX message queue file system.
        This is useful to avoid name clash of IPC identifiers. Defaults to false. It is possible to run two or
        more units within the same private IPC namespace by using the <varname>JoinsNamespaceOf=</varname> directive,
        see <citerefentry><refentrytitle>systemd.unit</refentrytitle><manvolnum>5</manvolnum></citerefentry> for
        details.</para>
 
        <para>Note that IPC namespacing does not have an effect on
        <constant>AF_UNIX</constant> sockets, which are the most common
        form of IPC used on Linux. Instead, <constant>AF_UNIX</constant>
        sockets in the file system are subject to mount namespacing, and
        those in the abstract namespace are subject to network namespacing.
        IPC namespacing only has an effect on SysV IPC (which is mostly
        legacy) as well as POSIX message queues (for which
        <constant>AF_UNIX</constant>/<constant>SOCK_SEQPACKET</constant>
        sockets are typically a better replacement). IPC namespacing also
        has no effect on POSIX shared memory (which is subject to mount
        namespacing) either. See
        <citerefentry project='man-pages'><refentrytitle>ipc_namespaces</refentrytitle><manvolnum>7</manvolnum></citerefentry> for
        the details.</para>
 
        <para>Note that the implementation of this setting might be impossible (for example if IPC namespaces are
        not available), and the unit should be written in a way that does not solely rely on this setting for
        security.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v248"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>IPCNamespacePath=</varname></term>
 
        <listitem><para>Takes an absolute file system path referring to a Linux IPC namespace
        pseudo-file (i.e. a file like <filename>/proc/$PID/ns/ipc</filename> or a bind mount or symlink to
        one). When set the invoked processes are added to the network namespace referenced by that path. The
        path has to point to a valid namespace file at the moment the processes are forked off. If this
        option is used <varname>PrivateIPC=</varname> has no effect. If this option is used together with
        <varname>JoinsNamespaceOf=</varname> then it only has an effect if this unit is started before any of
        the listed units that have <varname>PrivateIPC=</varname> or
        <varname>IPCNamespacePath=</varname> configured, as otherwise the network namespace of those
        units is reused.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v248"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>MemoryKSM=</varname></term>
 
        <listitem><para>Takes a boolean argument. When set, it enables KSM (kernel samepage merging) for
        the processes. KSM is a memory-saving de-duplication feature. Anonymous memory pages with identical
        content can be replaced by a single write-protected page. This feature should only be enabled for
        jobs that share the same security domain. For details, see
        <ulink url="https://docs.kernel.org/admin-guide/mm/ksm.html">Kernel Samepage Merging</ulink> in the
        kernel documentation.</para>
 
        <para>Note that this functionality might not be available, for example if KSM is disabled in the
        kernel, or the kernel does not support controlling KSM at the process level through
        <citerefentry><refentrytitle>prctl</refentrytitle><manvolnum>2</manvolnum></citerefentry>.</para>
 
        <xi:include href="version-info.xml" xpointer="v254"/>
        </listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>MemoryTHP=</varname></term>
 
        <listitem><para>Transparent Hugepages (THPs) is a Linux kernel feature that manages memory
        using larger pages (2MB on x86, compared to the default 4KB). The main goal is to improve memory management
        efficiency and system performance, especially for memory-intensive applications.
        However, it can cause drawbacks in some scenarios, such as memory regression and latency spikes.
        THP policy is governed for the entire system via <filename>/sys/kernel/mm/transparent_hugepage/enabled</filename>.
        However, it can be overridden for individual workloads via
        <citerefentry><refentrytitle>prctl</refentrytitle><manvolnum>2</manvolnum></citerefentry>.
        <varname>MemoryTHP=</varname> may be used to disable THPs at process invocation time to stop providing
        THPs for workloads where the drawbacks outweigh the advantages.
        When <varname>MemoryTHP=</varname> is set to <literal>inherit</literal> or not set at all, systemd
        inherits THP settings from the process that starts it and no
        <citerefentry><refentrytitle>prctl</refentrytitle><manvolnum>2</manvolnum></citerefentry>
        <constant>PR_SET_THP_DISABLE</constant> call is made.
        When set to <literal>disable</literal>, <varname>MemoryTHP=</varname> disables THPs completely for the process,
        irrespecitive of global THP controls.
        When set to <literal>madvise</literal>, <varname>MemoryTHP=</varname> disables THPs for the process except when
        specifically requested via <citerefentry><refentrytitle>madvise</refentrytitle><manvolnum>2</manvolnum></citerefentry>
        by the process with <constant>MADV_HUGEPAGE</constant> or <constant>MADV_COLLAPSE</constant>.
        When set to <literal>system</literal>, <varname>MemoryTHP=</varname> resets the THP policy to system wide policy.
        This can be used when the process that starts systemd has already disabled THPs via
        <constant>PR_SET_THP_DISABLE</constant>, and we want to restore the system default THP setting at
        process invocation time. For details, see
        <ulink url="https://docs.kernel.org/admin-guide/mm/transhuge.html">Transparent Hugepage Support</ulink>
        in the kernel documentation.</para>
        <para>Note that this functionality might not be available, for example if THP is disabled in the
        kernel, or the kernel does not support controlling THP at the process level through
        <citerefentry><refentrytitle>prctl</refentrytitle><manvolnum>2</manvolnum></citerefentry>.</para>
 
        <xi:include href="version-info.xml" xpointer="v260"/>
        </listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>PrivatePIDs=</varname></term>
 
        <listitem><para>Takes a boolean argument. Defaults to false. If enabled, sets up a new PID namespace
        for the executed processes. Each executed process is now PID 1 - the init process - in the new namespace.
        <filename>/proc/</filename> is mounted such that only processes in the PID namespace are visible.
        If <varname>PrivatePIDs=</varname> is set, <varname>MountAPIVFS=yes</varname> is implied.</para>
 
        <para><varname>PrivatePIDs=</varname> is only supported for service units. This setting is not supported
        with <varname>Type=forking</varname> since the kernel will kill all processes in the PID namespace if
        the init process terminates.</para>
 
        <para>This setting will be ignored if the kernel does not support PID namespaces.</para>
 
        <para>Note unprivileged user services (i.e. a service run by the per-user instance of the service manager)
        will fail with <varname>PrivatePIDs=yes</varname> if <filename>/proc/</filename> is masked
        (i.e. <filename>/proc/kmsg</filename> is over-mounted with <constant>tmpfs</constant> like
        <citerefentry><refentrytitle>systemd-nspawn</refentrytitle><manvolnum>1</manvolnum></citerefentry> does).
        This is due to a kernel restriction not allowing unprivileged user namespaces to mount a less restrictive
        instance of <filename>/proc/</filename>.</para>
 
        <xi:include href="version-info.xml" xpointer="v257"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>PrivateUsers=</varname></term>
 
        <listitem><para>Takes a boolean argument or one of <literal>self</literal>,
        <literal>identity</literal>, <literal>full</literal> or <literal>managed</literal>. Defaults to
        false. If enabled, sets up a new user namespace for the executed processes and configures a user and
        group mapping. If set to a true value or <literal>self</literal>, a minimal user and group mapping is
        configured that maps the <literal>root</literal> user and group as well as the unit's own user and
        group to themselves and everything else to the <literal>nobody</literal> user and group. This is
        useful to securely detach the user and group databases used by the unit from the rest of the system,
        and thus to create an effective sandbox environment. All files, directories, processes, IPC objects
        and other resources owned by users/groups not equaling <literal>root</literal> or the unit's own will
        stay visible from within the unit but appear owned by the <literal>nobody</literal> user and
        group. </para>
 
        <para>If the parameter is <literal>identity</literal>, user namespacing is set up with an identity
        mapping for the first 65536 UIDs/GIDs. Any UIDs/GIDs above 65536 will be mapped to the
        <literal>nobody</literal> user and group, respectively. While this does not provide UID/GID isolation,
        since all UIDs/GIDs are chosen identically it does provide process capability isolation, and hence is
        often a good choice if proper user namespacing with distinct UID maps is not appropriate.</para>
 
        <para>If the parameter is <literal>full</literal>, user namespacing is set up with an identity
        mapping for all UIDs/GIDs. In addition, for system services, <literal>full</literal> allows the unit
        to call <function>setgroups()</function> system calls (by setting
        <filename>/proc/<replaceable>pid</replaceable>/setgroups</filename> to <literal>allow</literal>).
        Similar to <literal>identity</literal>, this does not provide UID/GID isolation, but it does provide
        process capability isolation. If this mode is enabled, all unit processes are run without privileges
        in the host user namespace (regardless of whether the unit's own user/group is
        <literal>root</literal> or not). Specifically this means that the process will have zero process
        capabilities on the host's user namespace, but full capabilities within the service's user
        namespace. Settings such as <varname>CapabilityBoundingSet=</varname> will affect only the latter,
        and there's no way to acquire additional capabilities in the host's user namespace.</para>
 
        <para>If the parameter is <literal>managed</literal> a transient, dynamically allocated range of
        65536 UIDs/GIDs is allocated for the unit, and a UID/GID mapping is assigned to the unit's process
        so the UID/GID 0 from inside the unit maps to the first UID/GID of the allocated mapping. Note that
        in this mode the UID/GID the service process will run as is different depending if looking from the
        host side (where it will be a high, dynamically assigned UID) or from inside the unit (where it will
        be 0). Also note that this mode will enable file system UID mapping for the file systems this service
        accesses, mapping the "foreign" UID range on disk to the selected dynamic UID range at
        runtime.</para>
 
        <para>When this setting is set up by a per-user instance of the service manager, the mapping of the
        <literal>root</literal> user and group to itself is omitted (unless the user manager is root).
        Additionally, in the per-user instance manager case, the
        user namespace will be set up before most other namespaces. This means that combining
        <varname>PrivateUsers=</varname><option>true</option> with other namespaces will enable use of features not
        normally supported by the per-user instances of the service manager.</para>
 
        <para>This setting is particularly useful in conjunction with
        <varname>RootDirectory=</varname>/<varname>RootImage=</varname>, as the need to synchronize the user and group
        databases in the root directory and on the host is reduced, as the only users and groups who need to be matched
        are <literal>root</literal>, <literal>nobody</literal> and the unit's own user and group.</para>
 
        <xi:include href="version-info.xml" xpointer="v232"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>ProtectHostname=</varname></term>
 
        <listitem><para>Takes a boolean argument or <literal>private</literal>. If enabled, sets up a new UTS
        namespace for the executed processes. If enabled, a hostname can be optionally specified following a
        colon (e.g. <literal>yes:foo</literal> or <literal>private:host.example.com</literal>), and the
        hostname is set in the new UTS namespace for the unit. If set to a true value, changing hostname or
        domainname via <function>sethostname()</function> and <function>setdomainname()</function> system
        calls is prevented. If set to <literal>private</literal>, changing hostname or domainname is allowed
        but only affects the unit's UTS namespace. Defaults to off.</para>
 
        <para>Note that the implementation of this setting might be impossible (for example if UTS namespaces
        are not available), and the unit should be written in a way that does not solely rely on this setting
        for security.</para>
 
        <para>Note that when this option is enabled for a service hostname changes no longer propagate from
        the system into the service, it is hence not suitable for services that need to take notice of system
        hostname changes dynamically.</para>
 
        <para>Note that this option does not prevent changing system hostname via <command>hostnamectl</command>.
        However, <varname>User=</varname> and <varname>Group=</varname> may be used to run as an unprivileged user
        to disallow changing system hostname. See <function>SetHostname()</function> in
        <citerefentry project="man-pages"><refentrytitle>org.freedesktop.hostname1</refentrytitle><manvolnum>5</manvolnum></citerefentry>
        for more details.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v242"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>ProtectClock=</varname></term>
 
        <listitem><para>Takes a boolean argument. If set, writes to the hardware clock or system clock will
        be denied. Defaults to off. Enabling this option removes <constant>CAP_SYS_TIME</constant> and
        <constant>CAP_WAKE_ALARM</constant> from the capability bounding set for this unit, installs a system
        call filter to block calls that can set the clock, and <varname>DeviceAllow=char-rtc r</varname> is
        implied. Note that the system calls are blocked altogether, the filter does not take into account
        that some of the calls can be used to read the clock state with some parameter combinations.
        Effectively, <filename>/dev/rtc0</filename>, <filename>/dev/rtc1</filename>, etc. are made read-only
        to the service. See
        <citerefentry><refentrytitle>systemd.resource-control</refentrytitle><manvolnum>5</manvolnum></citerefentry>
        for the details about <varname>DeviceAllow=</varname>.</para>
 
        <para>It is recommended to turn this on for most services that do not need modify the clock or check
        its state.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v245"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>ProtectKernelTunables=</varname></term>
 
        <listitem><para>Takes a boolean argument. If true, kernel variables accessible through
        <filename>/proc/sys/</filename>, <filename>/sys/</filename>, <filename>/proc/sysrq-trigger</filename>,
        <filename>/proc/latency_stats</filename>, <filename>/proc/acpi</filename>,
        <filename>/proc/timer_stats</filename>, <filename>/proc/fs</filename> and <filename>/proc/irq</filename> will
        be made read-only and <filename>/proc/kallsyms</filename> as well as <filename>/proc/kcore</filename> will be
        inaccessible to all processes of the unit.
        Usually, tunable kernel variables should be initialized only at boot-time, for example with the
        <citerefentry><refentrytitle>sysctl.d</refentrytitle><manvolnum>5</manvolnum></citerefentry> mechanism. Few
        services need to write to these at runtime; it is hence recommended to turn this on for most services. For this
        setting the same restrictions regarding mount propagation and privileges apply as for
        <varname>ReadOnlyPaths=</varname> and related calls, see above. Defaults to off.
        Note that this option does not prevent indirect changes to kernel tunables affected by IPC calls to
        other processes. However, <varname>InaccessiblePaths=</varname> may be used to make relevant IPC file system
        objects inaccessible. If <varname>ProtectKernelTunables=</varname> is set,
        <varname>MountAPIVFS=yes</varname> is implied.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v232"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>ProtectKernelModules=</varname></term>
 
        <listitem><para>Takes a boolean argument. If true, explicit module loading will be denied. This allows
        module load and unload operations to be turned off on modular kernels. It is recommended to turn this on for most services
        that do not need special file systems or extra kernel modules to work. Defaults to off. Enabling this option
        removes <constant>CAP_SYS_MODULE</constant> from the capability bounding set for the unit, and installs a
        system call filter to block module system calls, also <filename>/usr/lib/modules</filename> is made
        inaccessible. For this setting the same restrictions regarding mount propagation and privileges apply as for
        <varname>ReadOnlyPaths=</varname> and related calls, see above. Note that limited automatic module loading due
        to user configuration or kernel mapping tables might still happen as side effect of requested user operations,
        both privileged and unprivileged. To disable module auto-load feature please see
        <citerefentry><refentrytitle>sysctl.d</refentrytitle><manvolnum>5</manvolnum></citerefentry>
        <constant>kernel.modules_disabled</constant> mechanism and
        <filename>/proc/sys/kernel/modules_disabled</filename> documentation.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v232"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>ProtectKernelLogs=</varname></term>
 
        <listitem><para>Takes a boolean argument. If true, access to the kernel log ring buffer will be denied. It is
        recommended to turn this on for most services that do not need to read from or write to the kernel log ring
        buffer. Enabling this option removes <constant>CAP_SYSLOG</constant> from the capability bounding set for this
        unit, and installs a system call filter to block the
        <citerefentry project='man-pages'><refentrytitle>syslog</refentrytitle><manvolnum>2</manvolnum></citerefentry>
        system call (not to be confused with the libc API
        <citerefentry project='man-pages'><refentrytitle>syslog</refentrytitle><manvolnum>3</manvolnum></citerefentry>
        for userspace logging). The kernel exposes its log buffer to userspace via <filename>/dev/kmsg</filename> and
        <filename>/proc/kmsg</filename>. If enabled, these are made inaccessible to all the processes in the unit.
        </para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v244"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>ProtectControlGroups=</varname></term>
 
        <listitem><para>Takes a boolean argument or the special values <literal>private</literal> or
        <literal>strict</literal>. If true, the Linux Control Groups (<citerefentry project='man-pages'>
        <refentrytitle>cgroups</refentrytitle><manvolnum>7</manvolnum></citerefentry>) hierarchies
        accessible through <filename>/sys/fs/cgroup/</filename> will be made read-only to all processes of the
        unit. If set to <literal>private</literal>, the unit will run in a cgroup namespace with a private
        writable mount of <filename>/sys/fs/cgroup/</filename>. If set to <literal>strict</literal>, the unit
        will run in a cgroup namespace with a private read-only mount of <filename>/sys/fs/cgroup/</filename>.
        Defaults to off. If <varname>ProtectControlGroups=</varname> is set, <varname>MountAPIVFS=yes</varname>
        is implied. Note <literal>private</literal> and <literal>strict</literal> are downgraded to false and
        true respectively unless the system is using the unified control group hierarchy and the kernel supports
        cgroup namespaces.</para>
 
        <para>Except for container managers no services should require write access to the control groups hierarchies;
        it is hence recommended to set <varname>ProtectControlGroups=</varname> to true or <literal>strict</literal>
        for most services. For this setting the same restrictions regarding mount propagation and privileges apply
        as for <varname>ReadOnlyPaths=</varname> and related settings, see above.</para>
 
        <xi:include href="system-only.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v232"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>RestrictAddressFamilies=</varname></term>
 
        <listitem><para>Restricts the set of socket address families accessible to the processes of this
        unit. Takes <literal>none</literal>, or a space-separated list of address family names to
        allow-list, such as <constant>AF_UNIX</constant>, <constant>AF_INET</constant> or
        <constant>AF_INET6</constant>, see
        <citerefentry project='man-pages'><refentrytitle>address_families</refentrytitle><manvolnum>7</manvolnum></citerefentry>
        for all possible options. When <literal>none</literal> is specified, then all address
        families will be denied. When prefixed with <literal>~</literal> the listed address
        families will be applied as deny list, otherwise as allow list.</para>
 
        <para>By default, no restrictions apply, all address families are accessible to processes. If
        assigned the empty string, any previous address family restriction changes are undone. This setting
        does not affect commands prefixed with <literal>+</literal>.</para>
 
        <para>Use this option to limit exposure of processes to remote access, in particular via exotic and
        sensitive network protocols, such as <constant>AF_PACKET</constant>. Note that in most cases, the
        local <constant>AF_UNIX</constant> address family should be included in the configured allow list as
        it is frequently used for local communication, including for
        <citerefentry><refentrytitle>syslog</refentrytitle><manvolnum>2</manvolnum></citerefentry>
        logging.</para>
 
        <para>Note that this restricts access to the <citerefentry
        project='man-pages'><refentrytitle>socket</refentrytitle><manvolnum>2</manvolnum></citerefentry>
        system call only. Sockets passed into the process by other means (for example, by using socket
        activation with socket units, see
        <citerefentry><refentrytitle>systemd.socket</refentrytitle><manvolnum>5</manvolnum></citerefentry>)
        are unaffected. Also, sockets created with <function>socketpair()</function> (which creates connected
        AF_UNIX sockets) or the
        <citerefentry project='man-pages'><refentrytitle>io_uring</refentrytitle><manvolnum>7</manvolnum></citerefentry>
        functions, are not affected. Thus, it is recommended to combined this setting with
        <varname>SystemCallFilter=@service</varname>, to only allow a limited subset of system calls.</para>
 
        <para>Note that this option is limited to some ABIs, in particular x86-64, but currently has no
        effect on 32-bit x86, s390, s390x, mips, mips-le, ppc, ppc-le, ppc64, or ppc64-le, and is ignored. On
        systems supporting multiple ABIs (such as x86/x86-64) it is recommended to turn off alternative ABIs
        for services, so that they cannot be used to circumvent the restrictions of this option.
        Specifically, it is recommended to combine this option with
        <varname>SystemCallArchitectures=native</varname> or similar. </para>
 
        <xi:include href="version-info.xml" xpointer="v211"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>RestrictFileSystems=</varname></term>
 
        <listitem><para>Restricts the set of filesystems processes of this unit can open files on. Takes a space-separated
        list of filesystem names. Any filesystem listed is made accessible to the unit's processes, access to filesystem
        types not listed is prohibited (allow-listing). If the first character of the list is <literal>~</literal>, the
        effect is inverted: access to the filesystems listed is prohibited (deny-listing). If the empty string is assigned,
        access to filesystems is not restricted.</para>
 
        <para>If you specify both types of this option (i.e. allow-listing and deny-listing), the first encountered will take
        precedence and will dictate the default action (allow access to the filesystem or deny it). Then the next occurrences
        of this option will add or delete the listed filesystems from the set of the restricted filesystems, depending on its
        type and the default action.</para>
 
        <para>Example: if a unit has the following,
        <programlisting>RestrictFileSystems=ext4 tmpfs
RestrictFileSystems=ext2 ext4</programlisting>
        then access to <constant>ext4</constant>, <constant>tmpfs</constant>, and <constant>ext2</constant> is allowed
        and access to other filesystems is denied.</para>
 
        <para>Example: if a unit has the following,
        <programlisting>RestrictFileSystems=ext4 tmpfs
RestrictFileSystems=~ext4</programlisting>
        then only access <constant>tmpfs</constant> is allowed.</para>
 
        <para>Example: if a unit has the following,
        <programlisting>RestrictFileSystems=~ext4 tmpfs
RestrictFileSystems=ext4</programlisting>
        then only access to <constant>tmpfs</constant> is denied.</para>
 
        <para>As the number of possible filesystems is large, predefined sets of filesystems are provided. A set
        starts with <literal>@</literal> character, followed by name of the set.</para>
 
        <table>
          <title>Currently predefined filesystem sets</title>
 
          <tgroup cols='2'>
            <colspec colname='set' />
            <colspec colname='description' />
            <thead>
              <row>
                <entry>Set</entry>
                <entry>Description</entry>
              </row>
            </thead>
            <tbody>
              <row>
                <entry>@basic-api</entry>
                <entry>Basic filesystem API.</entry>
              </row>
              <row>
                <entry>@auxiliary-api</entry>
                <entry>Auxiliary filesystem API.</entry>
              </row>
              <row>
                <entry>@common-block</entry>
                <entry>Common block device filesystems.</entry>
              </row>
              <row>
                <entry>@historical-block</entry>
                <entry>Historical block device filesystems.</entry>
              </row>
              <row>
                <entry>@network</entry>
                <entry>Well-known network filesystems.</entry>
              </row>
              <row>
                <entry>@privileged-api</entry>
                <entry>Privileged filesystem API.</entry>
              </row>
              <row>
                <entry>@temporary</entry>
                <entry>Temporary filesystems: tmpfs, ramfs.</entry>
              </row>
              <row>
                <entry>@known</entry>
                <entry>All known filesystems defined by the kernel. This list is defined statically in systemd based on a kernel version that was available when this systemd version was released. It will become progressively more out-of-date as the kernel is updated.</entry>
              </row>
            </tbody>
          </tgroup>
        </table>
 
        <para>Use
        <citerefentry><refentrytitle>systemd-analyze</refentrytitle><manvolnum>1</manvolnum></citerefentry>'s
        <command>filesystems</command> command to retrieve a list of filesystems defined on the local
        system.</para>
 
        <para>Note that this setting might not be supported on some systems (for example if the LSM eBPF hook is
        not enabled in the underlying kernel or if not using the unified control group hierarchy). In that case this setting
        has no effect.</para>
 
        <xi:include href="cgroup-sandboxing.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v250"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>RestrictNamespaces=</varname></term>
 
        <listitem><para>Restricts access to Linux namespace functionality for the processes of this unit. For details
        about Linux namespaces, see <citerefentry
        project='man-pages'><refentrytitle>namespaces</refentrytitle><manvolnum>7</manvolnum></citerefentry>. Either
        takes a boolean argument, or a space-separated list of namespace type identifiers. If false (the default), no
        restrictions on namespace creation and switching are made. If true, access to any kind of namespacing is
        prohibited. Otherwise, a space-separated list of namespace type identifiers must be specified, consisting of
        any combination of: <constant>cgroup</constant>, <constant>ipc</constant>, <constant>net</constant>,
        <constant>mnt</constant>, <constant>pid</constant>, <constant>user</constant>, <constant>uts</constant>, and
        <constant>time</constant>. Any namespace type listed is made accessible to the unit's processes, access to
        namespace types not listed is prohibited (allow-listing). By prepending the list with a single tilde
        character (<literal>~</literal>) the effect may be inverted: only the listed namespace types will be made
        inaccessible, all unlisted ones are permitted (deny-listing). If the empty string is assigned, the default
        namespace restrictions are applied, which is equivalent to false. This option may appear more than once, in
        which case the namespace types are merged by <constant>OR</constant>, or by <constant>AND</constant> if the
        lines are prefixed with <literal>~</literal> (see examples below). Internally, this setting limits access to
        the <citerefentry><refentrytitle>unshare</refentrytitle><manvolnum>2</manvolnum></citerefentry>,
        <citerefentry><refentrytitle>clone</refentrytitle><manvolnum>2</manvolnum></citerefentry> and
        <citerefentry><refentrytitle>setns</refentrytitle><manvolnum>2</manvolnum></citerefentry> system calls, taking
        the specified flags parameters into account. Note that — if this option is used — in addition to restricting
        creation and switching of the specified types of namespaces (or all of them, if true) access to the
        <function>setns()</function> system call with a zero flags parameter is prohibited. This setting is only
        supported on x86, x86-64, mips, mips-le, mips64, mips64-le, mips64-n32, mips64-le-n32, ppc64, ppc64-le, s390
        and s390x, and enforces no restrictions on other architectures.</para>
 
        <para>Example: if a unit has the following,
        <programlisting>RestrictNamespaces=cgroup ipc
RestrictNamespaces=cgroup net</programlisting>
        then <constant>cgroup</constant>, <constant>ipc</constant>, and <constant>net</constant> are set.
        If the second line is prefixed with <literal>~</literal>, e.g.,
        <programlisting>RestrictNamespaces=cgroup ipc
RestrictNamespaces=~cgroup net</programlisting>
        then, only <constant>ipc</constant> is set.</para>
 
        <xi:include href="version-info.xml" xpointer="v233"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>DelegateNamespaces=</varname></term>
 
        <listitem><para>Delegates ownership of the given namespace types to the user namespace of the
        processes of this unit. For details about Linux namespaces, see <citerefentry
        project='man-pages'><refentrytitle>namespaces</refentrytitle><manvolnum>7</manvolnum></citerefentry>.
        Either takes a boolean argument, or a space-separated list of namespace type identifiers. If false
        (the default), the unit's processes' user namespace will not have ownership over any namespaces
        created during setup of the unit's sandboxed environment. If true, ownership of all namespace types
        (except for user namespaces, where the concept doesn't apply) created during setup of the unit's
        sandboxed environment is delegated to the unit's processes' user namespace. Otherwise, a
        space-separated list of namespace type identifiers must be specified, consisting of any combination
        of: <constant>cgroup</constant>, <constant>ipc</constant>, <constant>net</constant>,
        <constant>mnt</constant>, <constant>pid</constant>, and <constant>uts</constant>. All namespaces of
        the listed types will be owned by the unit's processes' user namespace if they are created during
        setup of the unit's sandboxed environment (allow-listing). By prepending the list with a single tilde
        character (<literal>~</literal>) the effect may be inverted: all namespaces of types not listed and
        created during setup of the unit's sandboxed environment will be owned by the unit's processes' user
        namespace (deny-listing). If the empty string is assigned, the default namespace ownership is
        applied, which is equivalent to false. This option may appear more than once, in which case the
        namespace types are merged by <constant>OR</constant>, or by <constant>AND</constant> if the lines
        are prefixed with <literal>~</literal> (see examples below). Internally, this setting controls the
        order in which namespaces are unshared by systemd. Namespace types that should be owned by the unit's
        processes' user namespace will be unshared after unsharing the user namespace. Internally, this
        setting controls the order in which namespaces are unshared. Delegated namespaces will be unshared
        after the user namespace is unshared. Other namespaces will be unshared before the user namespace is
        unshared.</para>
 
        <para>Delegating any namespace with <varname>DelegateNamespaces=</varname> implies
        <varname>PrivateUsers=self</varname> unless <varname>PrivateUsers=</varname> is explicitly enabled
        already by the unit. Delegating a namespace does not imply that the namespace is unshared, that is
        done with the namespace specific unit setting such as <varname>PrivateNetwork=</varname> or
        <varname>PrivateMounts=</varname>.</para>
 
        <para>Note that some namespace sandboxing options might entail mount namespace for private API VFS instances,
        such as <varname>PrivatePIDs=</varname>, <varname>ProtectControlGroups=private/strict</varname>, or
        <varname>PrivateNetwork=</varname>. If any of the mentioned options are enabled, mount namespace
        is implicitly delegated.</para>
 
        <xi:include href="version-info.xml" xpointer="v258"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>PrivateBPF=</varname></term>
 
        <listitem><para>Takes a boolean argument. If set, mount a private instance of the BPF filesystem
        on <filename>/sys/fs/bpf/</filename>, effectively hiding the host bpffs which contains information
        about loaded programs and maps. Otherwise, if <varname>ProtectKernelTunables=</varname> is set, the
        instance from the host is inherited but mounted read-only. Defaults to false.</para>
 
        <para>This can be used together with the bpffs delegate feature to choose what BPF functions are
        available to the unit's processes. When mounting the BPF filesystem with the fsopen() API, four mount
        options can be specified to set a list of BPF commands, maps, programs and attachment types that are
        allowed to be used. Processes needs to get a file descriptor for the bpffs mountpoint and use that to
        get a token which will enable for that user namespace the BPF functionalities chosen upon bpffs mount.
        A more detailed explanation of the feature can be found in this
        <ulink url="https://lwn.net/Articles/947173/">LWN post</ulink>.</para>
 
 
        <xi:include href="version-info.xml" xpointer="v258"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>BPFDelegateCommands=</varname></term>
 
        <listitem><para>Accepts a list of BPF commands to allow or <literal>any</literal> to allow everything.
        Defaults to none. The accepted values are:
        <xi:include href="bpf-delegate.xml" xpointer="bpf_delegate_cmd"/>
        This will set the <constant>delegate_cmds</constant> bpffs mount option.</para>
 
        <para>Requires <varname>PrivateBPF=yes</varname> to be effective,
        see <varname>PrivateBPF=</varname> more details.</para>
 
        <xi:include href="version-info.xml" xpointer="v258"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>BPFDelegateMaps=</varname></term>
 
        <listitem><para>Accepts a list of BPF maps to allow or <literal>any</literal> to allow everything.
        Defaults to none. The accepted values are:
        <xi:include href="bpf-delegate.xml" xpointer="bpf_delegate_map_type"/>
        This will set the <constant>delegate_maps</constant> bpffs mount option.</para>
 
        <para>Requires <varname>PrivateBPF=yes</varname> to be effective,
        see <varname>PrivateBPF=</varname> more details.</para>
 
        <xi:include href="version-info.xml" xpointer="v258"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>BPFDelegatePrograms=</varname></term>
 
        <listitem><para>Accepts a list of BPF programs to allow or <literal>any</literal> to allow everything.
        Defaults to none. The accepted values are:
        <xi:include href="bpf-delegate.xml" xpointer="bpf_delegate_prog_type"/>
        This will set the <constant>delegate_progs</constant> bpffs mount option.</para>
 
        <para>Requires <varname>PrivateBPF=yes</varname> to be effective,
        see <varname>PrivateBPF=</varname> more details.</para>
 
        <xi:include href="version-info.xml" xpointer="v258"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>BPFDelegateAttachments=</varname></term>
 
        <listitem><para>Accepts a list of BPF attach points to allow or <literal>any</literal> to allow everything.
        Defaults to none. The accepted values are:
        <xi:include href="bpf-delegate.xml" xpointer="bpf_delegate_attach_type"/>
        This will set the <constant>delegate_attachs</constant> bpffs mount option.</para>
 
        <para>Requires <varname>PrivateBPF=yes</varname> to be effective,
        see <varname>PrivateBPF=</varname> more details.</para>
 
        <xi:include href="version-info.xml" xpointer="v258"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>LockPersonality=</varname></term>
 
        <listitem><para>Takes a boolean argument. If set, locks down the <citerefentry
        project='man-pages'><refentrytitle>personality</refentrytitle><manvolnum>2</manvolnum></citerefentry> system
        call so that the kernel execution domain may not be changed from the default or the personality selected with
        <varname>Personality=</varname> directive. This may be useful to improve security, because odd personality
        emulations may be poorly tested and source of vulnerabilities.</para>
 
        <xi:include href="version-info.xml" xpointer="v235"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>MemoryDenyWriteExecute=</varname></term>
 
        <listitem><para>Takes a boolean argument. If set, attempts to create memory mappings that are writable and
        executable at the same time, or to change existing memory mappings to become executable, or mapping shared
        memory segments as executable, are prohibited. Specifically, a system call filter is added (or
        preferably, an equivalent kernel check is enabled with
        <citerefentry><refentrytitle>prctl</refentrytitle><manvolnum>2</manvolnum></citerefentry>) that
        rejects <citerefentry><refentrytitle>mmap</refentrytitle><manvolnum>2</manvolnum></citerefentry>
        system calls with both <constant>PROT_EXEC</constant> and <constant>PROT_WRITE</constant> set,
        <citerefentry><refentrytitle>mprotect</refentrytitle><manvolnum>2</manvolnum></citerefentry> or
        <citerefentry><refentrytitle>pkey_mprotect</refentrytitle><manvolnum>2</manvolnum></citerefentry> system calls
        with <constant>PROT_EXEC</constant> set and
        <citerefentry><refentrytitle>shmat</refentrytitle><manvolnum>2</manvolnum></citerefentry> system calls with
        <constant>SHM_EXEC</constant> set. Note that this option is incompatible with programs and libraries that
        generate program code dynamically at runtime, including JIT execution engines, executable stacks, and code
        "trampoline" feature of various C compilers. This option improves service security, as it makes harder for
        software exploits to change running code dynamically. However, the protection can be circumvented, if
        the service can write to a filesystem, which is not mounted with <constant>noexec</constant> (such as
        <filename>/dev/shm</filename>), or it can use <function>memfd_create()</function>. This can be
        prevented by making such file systems inaccessible to the service
        (e.g. <varname>InaccessiblePaths=/dev/shm</varname>) and installing further system call filters
        (<varname>SystemCallFilter=~memfd_create</varname>). Note that this feature is fully available on
        x86-64, and partially on x86. Specifically, the <function>shmat()</function> protection is not
        available on x86. Note that on systems supporting multiple ABIs (such as x86/x86-64) it is
        recommended to turn off alternative ABIs for services, so that they cannot be used to circumvent the
        restrictions of this option. Specifically, it is recommended to combine this option with
        <varname>SystemCallArchitectures=native</varname> or similar.</para>
 
        <xi:include href="version-info.xml" xpointer="v231"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>RestrictRealtime=</varname></term>
 
        <listitem><para>Takes a boolean argument. If set, any attempts to enable realtime scheduling in a process of
        the unit are refused. This restricts access to realtime task scheduling policies such as
        <constant>SCHED_FIFO</constant>, <constant>SCHED_RR</constant> or <constant>SCHED_DEADLINE</constant>. See
        <citerefentry project='man-pages'><refentrytitle>sched</refentrytitle><manvolnum>7</manvolnum></citerefentry>
        for details about these scheduling policies. Realtime scheduling policies may be used to monopolize CPU
        time for longer periods of time, and may hence be used to lock up or otherwise trigger Denial-of-Service
        situations on the system. It is hence recommended to restrict access to realtime scheduling to the few programs
        that actually require them. Note that the scheduling policy passed to
        <citerefentry project='man-pages'><refentrytitle>sched_setattr</refentrytitle><manvolnum>2</manvolnum></citerefentry>
        cannot be inspected by the system call filter, hence that system call is refused altogether, including
        for non-realtime uses. Defaults to off.</para>
 
        <xi:include href="version-info.xml" xpointer="v231"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>RestrictSUIDSGID=</varname></term>
 
        <listitem><para>Takes a boolean argument. If set, any attempts to set the set-user-ID (SUID) or
        set-group-ID (SGID) bits on files or directories will be denied (for details on these bits see
        <citerefentry
        project='man-pages'><refentrytitle>inode</refentrytitle><manvolnum>7</manvolnum></citerefentry>).
        As the SUID/SGID bits are mechanisms to elevate privileges, and allow users to acquire the
        identity of other users, it is recommended to restrict creation of SUID/SGID files to the few
        programs that actually require them. Note that this restricts marking of any type of file system
        object with these bits, including both regular files and directories (where the SGID is a different
        meaning than for files, see documentation). This option is implied if <varname>DynamicUser=</varname>
        is enabled.</para>
 
        <para>In other cases, this setting defaults to the value set with <varname>DefaultRestrictSUIDSGID=</varname> in
        <citerefentry><refentrytitle>systemd-system.conf</refentrytitle><manvolnum>5</manvolnum></citerefentry>, which
        defaults to off.</para>
 
        <para>This setting is implemented using seccomp filtering. For system calls where the mode bits are
        passed directly as arguments, the call is denied only when the SUID or SGID bits are set. For system
        calls where those bits are passed indirectly and cannot be inspected by the filter, such as
        <function>openat2()</function>, the call is blocked entirely, regardless of the requested mode.</para>
 
        <xi:include href="version-info.xml" xpointer="v242"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>RemoveIPC=</varname></term>
 
        <listitem><para>Takes a boolean parameter. If set, all System V and POSIX IPC objects owned by the user and
        group the processes of this unit are run as are removed when the unit is stopped. This setting only has an
        effect if at least one of <varname>User=</varname>, <varname>Group=</varname> and
        <varname>DynamicUser=</varname> are used. It has no effect on IPC objects owned by the root user. Specifically,
        this removes System V semaphores, as well as System V and POSIX shared memory segments and message queues. If
        multiple units use the same user or group the IPC objects are removed when the last of these units is
        stopped. This setting is implied if <varname>DynamicUser=</varname> is set.</para>
 
        <xi:include href="system-only.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v232"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>PrivateMounts=</varname></term>
 
        <listitem><para>Takes a boolean parameter. If set, the processes of this unit will be run in their own private
        file system (mount) namespace with all mount propagation from the processes towards the host's main file system
        namespace turned off. This means any file system mount points established or removed by the unit's processes
        will be private to them and not be visible to the host. However, file system mount points established or
        removed on the host will be propagated to the unit's processes. See <citerefentry
        project='man-pages'><refentrytitle>mount_namespaces</refentrytitle><manvolnum>7</manvolnum></citerefentry> for
        details on file system namespaces. Defaults to off.</para>
 
        <para>When turned on, this executes three operations for each invoked process: a new
        <constant>CLONE_NEWNS</constant> namespace is created, after which all existing mounts are remounted to
        <constant>MS_SLAVE</constant> to disable propagation from the unit's processes to the host (but leaving
        propagation in the opposite direction in effect). Finally, the mounts are remounted again to the propagation
        mode configured with <varname>MountFlags=</varname>, see below.</para>
 
        <para>File system namespaces are set up individually for each process forked off by the service manager. Mounts
        established in the namespace of the process created by <varname>ExecStartPre=</varname> will hence be cleaned
        up automatically as soon as that process exits and will not be available to subsequent processes forked off for
        <varname>ExecStart=</varname> (and similar applies to the various other commands configured for
        units). Similarly, <varname>JoinsNamespaceOf=</varname> does not permit sharing kernel mount namespaces between
        units, it only enables sharing of the <filename>/tmp/</filename> and <filename>/var/tmp/</filename>
        directories.</para>
 
        <para>Other file system namespace unit settings — <varname>PrivateTmp=</varname>,
        <varname>PrivateDevices=</varname>, <varname>ProtectSystem=</varname>,
        <varname>ProtectHome=</varname>, <varname>ReadOnlyPaths=</varname>,
        <varname>InaccessiblePaths=</varname>, <varname>ReadWritePaths=</varname>,
        <varname>BindPaths=</varname>, <varname>BindReadOnlyPaths=</varname>, … — also enable file system
        namespacing in a fashion equivalent to this option. Hence it is primarily useful to explicitly
        request this behaviour if none of the other settings are used.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/>
 
        <xi:include href="version-info.xml" xpointer="v239"/></listitem>
      </varlistentry>
 
      <varlistentry>
        <term><varname>MountFlags=</varname></term>
 
        <listitem><para>Takes a mount propagation setting: <option>shared</option>, <option>slave</option> or
        <option>private</option>, which controls whether file system mount points in the file system namespaces set up
        for this unit's processes will receive or propagate mounts and unmounts from other file system namespaces. See
        <citerefentry project='man-pages'><refentrytitle>mount</refentrytitle><manvolnum>2</manvolnum></citerefentry>
        for details on mount propagation, and the three propagation flags in particular.</para>
 
        <para>This setting only controls the <emphasis>final</emphasis> propagation setting in effect on all mount
        points of the file system namespace created for each process of this unit. Other file system namespacing unit
        settings (see the discussion in <varname>PrivateMounts=</varname> above) will implicitly disable mount and
        unmount propagation from the unit's processes towards the host by changing the propagation setting of all mount
        points in the unit's file system namespace to <option>slave</option> first. Setting this option to
        <option>shared</option> does not reestablish propagation in that case.</para>
 
        <para>If not set – but file system namespaces are enabled through another file system namespace unit setting –
        <option>shared</option> mount propagation is used, but — as mentioned — as <option>slave</option> is applied
        first, propagation from the unit's processes to the host is still turned off.</para>
 
        <para>It is not recommended to use <option>private</option> mount propagation for units, as this means
        temporary mounts (such as removable media) of the host will stay mounted and thus indefinitely busy in forked
        off processes, as unmount propagation events will not be received by the file system namespace of the unit.</para>
 
        <para>Usually, it is best to leave this setting unmodified, and use higher level file system namespacing
        options instead, in particular <varname>PrivateMounts=</varname>, see above.</para>
 
        <xi:include href="system-or-user-ns.xml" xpointer="singular"/></listitem>
      </varlistentry>
 
    </variablelist>
  </refsect1>
 
  <refsect1>
    <title>System Call Filtering</title>
    <variablelist class='unit-directives'>
 
      <varlistentry>
        <term><varname>SystemCallFilter=</varname></term>
 
        <listitem><para>Takes a space-separated list of system call names or system call groups. If this
        setting is used, system calls executed by the unit processes except for the listed ones will result
        in the system call being denied (allow-listing). If the first character of the list is
        <literal>~</literal>, the effect is inverted: only the listed system calls will be denied
        (deny-listing). This option may be specified more than once, in which case the filter masks are
        merged. If the empty string is assigned, the filter is reset, all prior assignments will have no
        effect.</para>
 
        <para>Commands prefixed with <literal>+</literal> are not subject to filtering. The
        <function>execve()</function>, <function>exit()</function>, <function>exit_group()</function>,
        <function>getrlimit()</function>, <function>rt_sigreturn()</function>,
        <function>sigreturn()</function> system calls and the system calls for querying time and sleeping are
        implicitly allow-listed and do not need to be listed explicitly.</para>
 
        <para>The default action when a system call is denied is to terminate the processes with a
        <constant>SIGSYS</constant> signal. This can changed using <varname>SystemCallErrorNumber=</varname>,
        see below. In addition, deny-listed system calls and system call groups may optionally be suffixed
        with a colon (<literal>:</literal>) and an argument in the same format as
        <varname>SystemCallErrorNumber=</varname>, to take this action when the matching system call is made.
        This takes precedence over the action specified in <varname>SystemCallErrorNumber=</varname>.</para>
 
        <para>This feature makes use of the Secure Computing Mode 2 interfaces of the kernel ('seccomp
        filtering') and is useful for enforcing a minimal sandboxing environment.</para>
 
        <para>Note that on systems supporting multiple ABIs (such as x86/x86-64) it is recommended to turn
        off alternative ABIs for services, so that they cannot be used to circumvent the restrictions of this
        option. Specifically, it is recommended to combine this option with
        <varname>SystemCallArchitectures=native</varname> or similar.</para>
 
        <para>Note that strict system call filters may impact execution and error handling code paths of the
        service invocation. Specifically, access to the <function>execve()</function> system call is required
        for the execution of the service binary — if it is blocked service invocation will necessarily fail.
        Also, if execution of the service binary fails for some reason (for example: missing service
        executable), the error handling logic might require access to an additional set of system calls in
        order to process and log this failure correctly. It might be necessary to temporarily disable system
        call filters in order to allow debugging of such failures.</para>
 
        <para>If you specify both types of this option (i.e. allow-listing and deny-listing), the first
        encountered will take precedence and will dictate the default action (termination or approval of a
        system call). Then the next occurrences of this option will add or delete the listed system calls
        from the set of the filtered system calls, depending of its type and the default action. (For
        example, if you have started with an allow list rule for <function>read()</function> and
        <function>write()</function>, and right after it add a deny list rule for <function>write()</function>,
        then <function>write()</function> will be removed from the set.)</para>
 
        <para>As the number of possible system calls is large, predefined groups of system calls are
        provided. A group starts with <literal>@</literal> character, followed by name of the set.
 
        <table>
          <title>Currently predefined system call sets</title>
 
          <tgroup cols='2'>
            <colspec colname='set' />
            <colspec colname='description' />
            <thead>
              <row>
                <entry>Set</entry>
                <entry>Description</entry>
              </row>
            </thead>
            <tbody>
              <row>
                <entry>@aio</entry>
                <entry>Asynchronous I/O (<citerefentry project='man-pages'><refentrytitle>io_setup</refentrytitle><manvolnum>2</manvolnum></citerefentry>, <citerefentry project='man-pages'><refentrytitle>io_submit</refentrytitle><manvolnum>2</manvolnum></citerefentry>, and related calls)</entry>
              </row>
              <row>
                <entry>@basic-io</entry>