BindMountUnit(in s name,

in s source,

in s destination,

in b read_only,

in b mkdir);

<variablelist class="dbus-method" generated="True" extra-ref="BindMountUnit()"/>

<para><function>BindMountUnit()</function> can be used to bind mount new files or directories into

a running service mount namespace.</para>

BindMount(in s source,

in s destination,

in b read_only,

in b mkdir);

<variablelist class="dbus-method" generated="True" extra-ref="BindMount()"/>

<refsect2>

<title>Methods</title>

<para><function>BindMount()</function> implements the same operation as the respective method on the

<interfacename>Manager</interfacename> object (see above). However, this method operates on the service

object and hence does not take a unit name parameter. Invoking the methods directly on the Manager

object has the advantage of not requiring a <function>GetUnit()</function> call to get the unit object

for a specific unit name. Calling the methods on the Manager object is hence a round trip

optimization.</para>

</refsect2>

<varlistentry>

<term><command>bind</command> <replaceable>UNIT</replaceable> <replaceable>PATH</replaceable> [<replaceable>PATH</replaceable>]</term>

<listitem><para>Bind mounts a file or directory from the host into the specified unit's view. The first path

argument is the source file or directory on the host, the second path argument is the destination file or

directory in the unit's view. When the latter is omitted, the destination path in the unit's view is the same as

the source path on the host. When combined with the <option>--read-only</option> switch, a ready-only bind

mount is created. When combined with the <option>--mkdir</option> switch, the destination path is first created

before the mount is applied. Note that this option is currently only supported for units that run within a mount

namespace (e.g.: with <option>RootImage=</option>, <option>PrivateMounts=</option>, etc.). This command supports bind

mounting directories, regular files, device nodes, <constant>AF_UNIX</constant> socket nodes, as well as FIFOs.

The bind mount is ephemeral, and it is undone as soon as the current unit process exists.

Note that the namespace mentioned here, where the bind mount will be added to, is the one where the main service

process runs, as other processes run in distinct namespaces (e.g.: <option>ExecReload=</option>,

<option>ExecStartPre=</option>, etc.) </para></listitem>

</varlistentry>

<varlistentry>

<term><option>--mkdir</option></term>

<listitem><para>When used with <command>bind</command>, creates the destination file or directory before

applying the bind mount. Note that even though the name of this option suggests that it is suitable only for

directories, this option also creates the destination file node to mount over if the object to mount is not

a directory, but a regular file, device node, socket or FIFO.</para></listitem>

</varlistentry>

<varlistentry>

<term><option>--read-only</option></term>

<listitem><para>When used with <command>bind</command>, creates a read-only bind mount.</para></listitem>

</varlistentry>

and the API file systems <filename>/proc/</filename>, <filename>/sys/</filename>, <filename>/dev/</filename> and

<filename>/run/</filename> (as an empty <literal>tmpfs</literal>) are mounted inside of it, unless they are

already mounted. Note that this option has no effect unless used in conjunction with

<varname>RootDirectory=</varname>/<varname>RootImage=</varname> as these four mounts are

will be a 1:1 copy of the host's, and include these four mounts. Note that the <filename>/dev/</filename> file

<para>In order to allow propagating mounts at runtime in a safe manner, <filename>/run/systemd/propagate</filename>

on the host will be used to set up new mounts, and <filename>/run/host/incoming/</filename> in the private namespace

will be used as an intermediate step to store them before being moved to the final mount point.</para>

'src/systemctl/systemctl-mount.c',

'src/systemctl/systemctl-mount.h',

[FILE]='link switch-root bind'

"bind:Bind mount a path from the host into a unit's namespace"

(( $+functions[_systemctl_bind] )) || _systemctl_bind() {

_files

}

#include "dbus-service.h"

static int method_bind_mount_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {

/* Only add mounts on fully loaded units */

return method_generic_unit_operation(message, userdata, error, bus_service_method_bind_mount, GENERIC_UNIT_VALIDATE_LOADED);

}

SD_BUS_METHOD_WITH_NAMES("BindMountUnit",

"sssbb",

SD_BUS_PARAM(name)

SD_BUS_PARAM(source)

SD_BUS_PARAM(destination)

SD_BUS_PARAM(read_only)

SD_BUS_PARAM(mkdir),

NULL,,

method_bind_mount_unit,

SD_BUS_VTABLE_UNPRIVILEGED),

#include "execute.h"

#include "locale-util.h"

#include "mount-util.h"

#include "selinux-access.h"

int bus_service_method_bind_mount(sd_bus_message *message, void *userdata, sd_bus_error *error) {

int read_only, make_file_or_directory;

const char *dest, *src, *propagate_directory;

Unit *u = userdata;

ExecContext *c;

pid_t unit_pid;

int r;

assert(message);

assert(u);

if (!MANAGER_IS_SYSTEM(u->manager))

return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Adding bind mounts at runtime is only supported for system managers.");

r = mac_selinux_unit_access_check(u, message, "start", error);

if (r < 0)

return r;

r = sd_bus_message_read(message, "ssbb", &src, &dest, &read_only, &make_file_or_directory);

if (r < 0)

return r;

if (!path_is_absolute(src) || !path_is_normalized(src))

return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Source path must be absolute and normalized.");

if (isempty(dest))

dest = src;

else if (!path_is_absolute(dest) || !path_is_normalized(dest))

return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Destination path must be absolute and normalized.");

r = bus_verify_manage_units_async_full(

u,

"bind-mount",

CAP_SYS_ADMIN,

N_("Authentication is required to bind mount on '$(unit)'."),

true,

message,

error);

if (r < 0)

return r;

if (r == 0)

return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */

if (u->type != UNIT_SERVICE)

return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unit is not of type .service");

/* If it would be dropped at startup time, return an error. The context should always be available, but

c = unit_get_exec_context(u);

if (!c)

return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Cannot access unit execution context");

if (path_startswith_strv(dest, c->inaccessible_paths))

return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "%s is not accessible to this unit", dest);

/* Ensure that the unit was started in a private mount namespace */

if (!exec_needs_mount_namespace(c, NULL, unit_get_exec_runtime(u)))

return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unit not running in private mount namespace, cannot activate bind mount");

unit_pid = unit_main_pid(u);

if (unit_pid == 0 || !UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))

return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unit is not running");

propagate_directory = strjoina("/run/systemd/propagate/", u->id);

r = bind_mount_in_namespace(unit_pid,

propagate_directory,

"/run/systemd/incoming/",

src, dest, read_only, make_file_or_directory);

if (r < 0)

return sd_bus_error_set_errnof(error, r, "Failed to mount %s on %s in unit's namespace: %m", src, dest);

return sd_bus_reply_method_return(message, NULL);

}

SD_BUS_METHOD_WITH_NAMES("BindMount",

"ssbb",

SD_BUS_PARAM(source)

SD_BUS_PARAM(destination)

SD_BUS_PARAM(read_only)

SD_BUS_PARAM(mkdir),

NULL,,

bus_service_method_bind_mount,

SD_BUS_VTABLE_UNPRIVILEGED),

int bus_service_method_bind_mount(sd_bus_message *message, void *userdata, sd_bus_error *error);