[systemd.git] / src / core / dbus-mount.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include "unit.h"
#include "mount.h"
#include "dbus-unit.h"
#include "dbus-execute.h"
#include "dbus-kill.h"
#include "dbus-cgroup.h"
#include "dbus-mount.h"
#include "bus-util.h"

static int property_get_what(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        Mount *m = userdata;
        const char *d;

        assert(bus);
        assert(reply);
        assert(m);

        if (m->from_proc_self_mountinfo && m->parameters_proc_self_mountinfo.what)
                d = m->parameters_proc_self_mountinfo.what;
        else if (m->from_fragment && m->parameters_fragment.what)
                d = m->parameters_fragment.what;
        else
                d = "";

        return sd_bus_message_append(reply, "s", d);
}

static int property_get_options(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        Mount *m = userdata;
        const char *d;

        assert(bus);
        assert(reply);
        assert(m);

        if (m->from_proc_self_mountinfo && m->parameters_proc_self_mountinfo.options)
                d = m->parameters_proc_self_mountinfo.options;
        else if (m->from_fragment && m->parameters_fragment.options)
                d = m->parameters_fragment.options;
        else
                d = "";

        return sd_bus_message_append(reply, "s", d);
}

static int property_get_type(
                sd_bus *bus,
                const char *path,
                const char *interface,
                const char *property,
                sd_bus_message *reply,
                void *userdata,
                sd_bus_error *error) {

        Mount *m = userdata;
        const char *d;

        assert(bus);
        assert(reply);
        assert(m);

        if (m->from_proc_self_mountinfo && m->parameters_proc_self_mountinfo.fstype)
                d = m->parameters_proc_self_mountinfo.fstype;
        else if (m->from_fragment && m->parameters_fragment.fstype)
                d = m->parameters_fragment.fstype;
        else
                d = "";

        return sd_bus_message_append(reply, "s", d);
}

static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_result, mount_result, MountResult);

const sd_bus_vtable bus_mount_vtable[] = {
        SD_BUS_VTABLE_START(0),
        SD_BUS_PROPERTY("Where", "s", NULL, offsetof(Mount, where), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("What", "s", property_get_what, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("Options","s", property_get_options, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("Type", "s", property_get_type, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("TimeoutUSec", "t", bus_property_get_usec, offsetof(Mount, timeout_usec), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("ControlPID", "u", bus_property_get_pid, offsetof(Mount, control_pid), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        SD_BUS_PROPERTY("DirectoryMode", "u", bus_property_get_mode, offsetof(Mount, directory_mode), SD_BUS_VTABLE_PROPERTY_CONST),
        SD_BUS_PROPERTY("Result", "s", property_get_result, offsetof(Mount, result), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
        BUS_EXEC_COMMAND_VTABLE("ExecMount", offsetof(Mount, exec_command[MOUNT_EXEC_MOUNT]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        BUS_EXEC_COMMAND_VTABLE("ExecUnmount", offsetof(Mount, exec_command[MOUNT_EXEC_UNMOUNT]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        BUS_EXEC_COMMAND_VTABLE("ExecRemount", offsetof(Mount, exec_command[MOUNT_EXEC_REMOUNT]), SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION),
        SD_BUS_VTABLE_END
};

static int bus_mount_set_transient_property(
                Mount *m,
                const char *name,
                sd_bus_message *message,
                UnitSetPropertiesMode mode,
                sd_bus_error *error) {

        const char *new_property;
        char **property;
        char *p;
        int r;

        assert(m);
        assert(name);
        assert(message);

        if (streq(name, "What"))
                property = &m->parameters_fragment.what;
        else if (streq(name, "Options"))
                property = &m->parameters_fragment.options;
        else if (streq(name, "Type"))
                property = &m->parameters_fragment.fstype;
        else
                return 0;

        r = sd_bus_message_read(message, "s", &new_property);
        if (r < 0)
                return r;

        if (mode != UNIT_CHECK) {
                p = strdup(new_property);
                if (!p)
                        return -ENOMEM;

                free(*property);
                *property = p;
        }

        return 1;
}

int bus_mount_set_property(
                Unit *u,
                const char *name,
                sd_bus_message *message,
                UnitSetPropertiesMode mode,
                sd_bus_error *error) {

        Mount *m = MOUNT(u);
        int r;

        assert(m);
        assert(name);
        assert(message);

        r = bus_cgroup_set_property(u, &m->cgroup_context, name, message, mode, error);
        if (r != 0)
                return r;

        if (u->transient && u->load_state == UNIT_STUB) {
                /* This is a transient unit, let's load a little more */

                r = bus_mount_set_transient_property(m, name, message, mode, error);
                if (r != 0)
                        return r;

                r = bus_exec_context_set_transient_property(u, &m->exec_context, name, message, mode, error);
                if (r != 0)
                        return r;

                r = bus_kill_context_set_transient_property(u, &m->kill_context, name, message, mode, error);
                if (r != 0)
                        return r;
        }

        return 0;
}

int bus_mount_commit_properties(Unit *u) {
        assert(u);

        unit_update_cgroup_members_masks(u);
        unit_realize_cgroup(u);

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