src/core/dbus-mount.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include "bus-util.h"
  22 #include "dbus-cgroup.h"
  23 #include "dbus-execute.h"
  24 #include "dbus-kill.h"
  25 #include "dbus-mount.h"
  26 #include "mount.h"
  27 #include "string-util.h"
  28 #include "unit.h"
  29
  30 static int property_get_what(
  31                 sd_bus *bus,
  32                 const char *path,
  33                 const char *interface,
  34                 const char *property,
  35                 sd_bus_message *reply,
  36                 void *userdata,
  37                 sd_bus_error *error) {
  38
  39         Mount *m = userdata;
  40         const char *d = NULL;
  41
  42         assert(bus);
  43         assert(reply);
  44         assert(m);
  45
  46         if (m->from_proc_self_mountinfo && m->parameters_proc_self_mountinfo.what)
  47                 d = m->parameters_proc_self_mountinfo.what;
  48         else if (m->from_fragment && m->parameters_fragment.what)
  49                 d = m->parameters_fragment.what;
  50
  51         return sd_bus_message_append(reply, "s", d);
  52 }
  53
  54 static int property_get_options(
  55                 sd_bus *bus,
  56                 const char *path,
  57                 const char *interface,
  58                 const char *property,
  59                 sd_bus_message *reply,
  60                 void *userdata,
  61                 sd_bus_error *error) {
  62
  63         Mount *m = userdata;
  64         const char *d = NULL;
  65
  66         assert(bus);
  67         assert(reply);
  68         assert(m);
  69
  70         if (m->from_proc_self_mountinfo && m->parameters_proc_self_mountinfo.options)
  71                 d = m->parameters_proc_self_mountinfo.options;
  72         else if (m->from_fragment && m->parameters_fragment.options)
  73                 d = m->parameters_fragment.options;
  74
  75         return sd_bus_message_append(reply, "s", d);
  76 }
  77
  78 static int property_get_type(
  79                 sd_bus *bus,
  80                 const char *path,
  81                 const char *interface,
  82                 const char *property,
  83                 sd_bus_message *reply,
  84                 void *userdata,
  85                 sd_bus_error *error) {
  86
  87         const char *fstype = NULL;
  88         Mount *m = userdata;
  89
  90         assert(bus);
  91         assert(reply);
  92         assert(m);
  93
  94         if (m->from_proc_self_mountinfo && m->parameters_proc_self_mountinfo.fstype)
  95                 fstype = m->parameters_proc_self_mountinfo.fstype;
  96         else if (m->from_fragment && m->parameters_fragment.fstype)
  97                 fstype = m->parameters_fragment.fstype;
  98
  99         return sd_bus_message_append(reply, "s", fstype);
 100 }
 101
 102 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, mount_result, MountResult);
 103
 104 const sd_bus_vtable bus_mount_vtable[] = {
 105         SD_BUS_VTABLE_START(0),
 106         SD_BUS_PROPERTY("Where", "s", NULL, offsetof(Mount, where), SD_BUS_VTABLE_PROPERTY_CONST),
 107         SD_BUS_PROPERTY("What", "s", property_get_what, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 108         SD_BUS_PROPERTY("Options","s", property_get_options, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 109         SD_BUS_PROPERTY("Type", "s", property_get_type, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 110         SD_BUS_PROPERTY("TimeoutUSec", "t", bus_property_get_usec, offsetof(Mount, timeout_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 111         SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Mount, control_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 112         SD_BUS_PROPERTY("DirectoryMode", "u", bus_property_get_mode, offsetof(Mount, directory_mode), SD_BUS_VTABLE_PROPERTY_CONST),
 113         SD_BUS_PROPERTY("SloppyOptions", "b", bus_property_get_bool, offsetof(Mount, sloppy_options), SD_BUS_VTABLE_PROPERTY_CONST),
 114         SD_BUS_PROPERTY("LazyUnmount", "b", bus_property_get_bool, offsetof(Mount, lazy_unmount), SD_BUS_VTABLE_PROPERTY_CONST),
 115         SD_BUS_PROPERTY("ForceUnmount", "b", bus_property_get_bool, offsetof(Mount, force_unmount), SD_BUS_VTABLE_PROPERTY_CONST),
 116         SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Mount, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 117         SD_BUS_PROPERTY("UID", "u", NULL, offsetof(Unit, ref_uid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 118         SD_BUS_PROPERTY("GID", "u", NULL, offsetof(Unit, ref_gid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
 119         BUS_EXEC_COMMAND_VTABLE("ExecMount", offsetof(Mount, exec_command[MOUNT_EXEC_MOUNT]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 120         BUS_EXEC_COMMAND_VTABLE("ExecUnmount", offsetof(Mount, exec_command[MOUNT_EXEC_UNMOUNT]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 121         BUS_EXEC_COMMAND_VTABLE("ExecRemount", offsetof(Mount, exec_command[MOUNT_EXEC_REMOUNT]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
 122         SD_BUS_VTABLE_END
 123 };
 124
 125 static int bus_mount_set_transient_property(
 126                 Mount *m,
 127                 const char *name,
 128                 sd_bus_message *message,
 129                 UnitWriteFlags flags,
 130                 sd_bus_error *error) {
 131
 132         const char *new_property;
 133         char **property;
 134         int r;
 135
 136         assert(m);
 137         assert(name);
 138         assert(message);
 139
 140         flags |= UNIT_PRIVATE;
 141
 142         if (streq(name, "What"))
 143                 property = &m->parameters_fragment.what;
 144         else if (streq(name, "Options"))
 145                 property = &m->parameters_fragment.options;
 146         else if (streq(name, "Type"))
 147                 property = &m->parameters_fragment.fstype;
 148         else
 149                 return 0;
 150
 151         r = sd_bus_message_read(message, "s", &new_property);
 152         if (r < 0)
 153                 return r;
 154
 155         if (!UNIT_WRITE_FLAGS_NOOP(flags)) {
 156
 157                 r = free_and_strdup(property, new_property);
 158                 if (r < 0)
 159                         return r;
 160
 161                 unit_write_settingf(UNIT(m), flags|UNIT_ESCAPE_SPECIFIERS, name, "%s=%s", name, new_property);
 162         }
 163
 164         return 1;
 165 }
 166
 167 int bus_mount_set_property(
 168                 Unit *u,
 169                 const char *name,
 170                 sd_bus_message *message,
 171                 UnitWriteFlags flags,
 172                 sd_bus_error *error) {
 173
 174         Mount *m = MOUNT(u);
 175         int r;
 176
 177         assert(m);
 178         assert(name);
 179         assert(message);
 180
 181         r = bus_cgroup_set_property(u, &m->cgroup_context, name, message, flags, error);
 182         if (r != 0)
 183                 return r;
 184
 185         if (u->transient && u->load_state == UNIT_STUB) {
 186                 /* This is a transient unit, let's load a little more */
 187
 188                 r = bus_mount_set_transient_property(m, name, message, flags, error);
 189                 if (r != 0)
 190                         return r;
 191
 192                 r = bus_exec_context_set_transient_property(u, &m->exec_context, name, message, flags, error);
 193                 if (r != 0)
 194                         return r;
 195
 196                 r = bus_kill_context_set_transient_property(u, &m->kill_context, name, message, flags, error);
 197                 if (r != 0)
 198                         return r;
 199         }
 200
 201         return 0;
 202 }
 203
 204 int bus_mount_commit_properties(Unit *u) {
 205         assert(u);
 206
 207         unit_update_cgroup_members_masks(u);
 208         unit_realize_cgroup(u);
 209
 210         return 0;
 211 }