[thirdparty/systemd.git] / src / dbus-execute.c

/*-*- Mode: C; c-basic-offset: 8 -*-*/

/***
  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 General Public License as published by
  the Free Software Foundation; either version 2 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
  General Public License for more details.

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

#include <errno.h>
#include <dbus/dbus.h>
#include <sys/prctl.h>

#include "dbus-execute.h"
#include "missing.h"
#include "ioprio.h"

DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_execute_append_input, exec_input, ExecInput);
DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_execute_append_output, exec_output, ExecOutput);

int bus_execute_append_oom_adjust(Manager *m, DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int32_t n;

        assert(m);
        assert(i);
        assert(property);
        assert(c);

        if (c->oom_adjust_set)
                n = c->oom_adjust;
        else {
                char *t;

                n = 0;
                if (read_one_line_file("/proc/self/oom_adj", &t) >= 0) {
                        safe_atoi(t, &n);
                        free(t);
                }
        }

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_nice(Manager *m, DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int32_t n;

        assert(m);
        assert(i);
        assert(property);
        assert(c);

        if (c->nice_set)
                n = c->nice;
        else
                n = getpriority(PRIO_PROCESS, 0);

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_ioprio(Manager *m, DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int32_t n;

        assert(m);
        assert(i);
        assert(property);
        assert(c);

        if (c->ioprio_set)
                n = c->ioprio;
        else
                n = ioprio_get(IOPRIO_WHO_PROCESS, 0);

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_cpu_sched_policy(Manager *m, DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int32_t n;

        assert(m);
        assert(i);
        assert(property);
        assert(c);

        if (c->cpu_sched_set)
                n = c->cpu_sched_policy;
        else
                n = sched_getscheduler(0);

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_cpu_sched_priority(Manager *m, DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int32_t n;

        assert(m);
        assert(i);
        assert(property);
        assert(c);

        if (c->cpu_sched_set)
                n = c->cpu_sched_priority;
        else {
                struct sched_param p;
                n = 0;

                zero(p);
                if (sched_getparam(0, &p) >= 0)
                        n = p.sched_priority;
        }

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_affinity(Manager *m, DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        dbus_bool_t b;
        DBusMessageIter sub;

        assert(m);
        assert(i);
        assert(property);
        assert(c);

        if (!(dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "y", &sub)))
                return -ENOMEM;

        if (c->cpuset)
                b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &c->cpuset, CPU_ALLOC_SIZE(c->cpuset_ncpus));
        else
                b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &c->cpuset, 0);

        if (!b)
                return -ENOMEM;

        if (!dbus_message_iter_close_container(i, &sub))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_timer_slack_ns(Manager *m, DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        uint64_t u;

        assert(m);
        assert(i);
        assert(property);
        assert(c);

        if (c->timer_slack_ns_set)
                u = (uint64_t) c->timer_slack_ns_set;
        else
                u = (uint64_t) prctl(PR_GET_TIMERSLACK);

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
                return -ENOMEM;

        return 0;
}

int bus_execute_append_capabilities(Manager *m, DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        char *t = NULL;
        const char *s;
        dbus_bool_t b;

        assert(m);
        assert(i);
        assert(property);
        assert(c);

        if (c->capabilities)
                s = t = cap_to_text(c->capabilities, NULL);
        else
                s = "";

        if (!t)
                return -ENOMEM;

        b = dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &s);
        cap_free(t);

        if (!b)
                return -ENOMEM;

        return 0;
}

int bus_execute_append_rlimits(Manager *m, DBusMessageIter *i, const char *property, void *data) {
        ExecContext *c = data;
        int r;
        uint64_t u;

        assert(m);
        assert(i);
        assert(property);
        assert(c);

        assert_se((r = rlimit_from_string(property)) >= 0);

        if (c->rlimit[r])
                u = (uint64_t) c->rlimit[r]->rlim_max;
        else {
                struct rlimit rl;

                zero(rl);
                getrlimit(r, &rl);

                u = (uint64_t) rl.rlim_max;
        }

        if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
                return -ENOMEM;

        return 0;
}
Commit	Line	Data
4139c1b2 LP	1	/-- Mode: C; c-basic-offset: 8 --/
	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 General Public License as published by
	10	the Free Software Foundation; either version 2 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	General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <errno.h>
	23	#include <dbus/dbus.h>
82c121a4	24	#include <sys/prctl.h>
4139c1b2 LP	25
4139c1b2 LP	26	#include "dbus-execute.h"
82c121a4 LP	27	#include "missing.h"
82c121a4 LP	28	#include "ioprio.h"
4139c1b2 LP	29
	30	DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_execute_append_input, exec_input, ExecInput);
	31	DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_execute_append_output, exec_output, ExecOutput);
82c121a4 LP	32
	33	int bus_execute_append_oom_adjust(Manager m, DBusMessageIter i, const char property, void data) {
	34	ExecContext *c = data;
	35	int32_t n;
	36
	37	assert(m);
	38	assert(i);
	39	assert(property);
	40	assert(c);
	41
	42	if (c->oom_adjust_set)
	43	n = c->oom_adjust;
	44	else {
	45	char *t;
	46
	47	n = 0;
	48	if (read_one_line_file("/proc/self/oom_adj", &t) >= 0) {
	49	safe_atoi(t, &n);
	50	free(t);
	51	}
	52	}
	53
	54	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
	55	return -ENOMEM;
	56
	57	return 0;
	58	}
	59
	60	int bus_execute_append_nice(Manager m, DBusMessageIter i, const char property, void data) {
	61	ExecContext *c = data;
	62	int32_t n;
	63
	64	assert(m);
	65	assert(i);
	66	assert(property);
	67	assert(c);
	68
	69	if (c->nice_set)
	70	n = c->nice;
	71	else
	72	n = getpriority(PRIO_PROCESS, 0);
	73
	74	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
	75	return -ENOMEM;
	76
	77	return 0;
	78	}
	79
	80	int bus_execute_append_ioprio(Manager m, DBusMessageIter i, const char property, void data) {
	81	ExecContext *c = data;
	82	int32_t n;
	83
	84	assert(m);
	85	assert(i);
	86	assert(property);
	87	assert(c);
	88
	89	if (c->ioprio_set)
	90	n = c->ioprio;
	91	else
	92	n = ioprio_get(IOPRIO_WHO_PROCESS, 0);
	93
	94	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
	95	return -ENOMEM;
96
97	return 0;
98	}
99
100	int bus_execute_append_cpu_sched_policy(Manager m, DBusMessageIter i, const char property, void data) {
101	ExecContext *c = data;
102	int32_t n;
103
104	assert(m);
105	assert(i);
106	assert(property);
107	assert(c);
108
109	if (c->cpu_sched_set)
110	n = c->cpu_sched_policy;
111	else
112	n = sched_getscheduler(0);
113
114	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
115	return -ENOMEM;
116
117	return 0;
118	}
119
120	int bus_execute_append_cpu_sched_priority(Manager m, DBusMessageIter i, const char property, void data) {
121	ExecContext *c = data;
122	int32_t n;
123
124	assert(m);
125	assert(i);
126	assert(property);
127	assert(c);
128
129	if (c->cpu_sched_set)
130	n = c->cpu_sched_priority;
131	else {
132	struct sched_param p;
133	n = 0;
134
135	zero(p);
136	if (sched_getparam(0, &p) >= 0)
137	n = p.sched_priority;
138	}
139
140	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_INT32, &n))
141	return -ENOMEM;
142
143	return 0;
144	}
145
146	int bus_execute_append_affinity(Manager m, DBusMessageIter i, const char property, void data) {
147	ExecContext *c = data;
148	dbus_bool_t b;
149	DBusMessageIter sub;
150
151	assert(m);
152	assert(i);
153	assert(property);
154	assert(c);
155
156	if (!(dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "y", &sub)))
157	return -ENOMEM;
158
159	if (c->cpuset)
160	b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &c->cpuset, CPU_ALLOC_SIZE(c->cpuset_ncpus));
161	else
162	b = dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &c->cpuset, 0);
163
164	if (!b)
165	return -ENOMEM;
166
167	if (!dbus_message_iter_close_container(i, &sub))
168	return -ENOMEM;
169
170	return 0;
171	}
172
173	int bus_execute_append_timer_slack_ns(Manager m, DBusMessageIter i, const char property, void data) {
174	ExecContext *c = data;
175	uint64_t u;
176
177	assert(m);
178	assert(i);
179	assert(property);
180	assert(c);
181
182	if (c->timer_slack_ns_set)
183	u = (uint64_t) c->timer_slack_ns_set;
184	else
185	u = (uint64_t) prctl(PR_GET_TIMERSLACK);
186
187	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
188	return -ENOMEM;
189
190	return 0;
191	}
192
193	int bus_execute_append_capabilities(Manager m, DBusMessageIter i, const char property, void data) {
194	ExecContext *c = data;
195	char *t = NULL;
196	const char *s;
197	dbus_bool_t b;
198
199	assert(m);
200	assert(i);
201	assert(property);
202	assert(c);
203
204	if (c->capabilities)
205	s = t = cap_to_text(c->capabilities, NULL);
206	else
207	s = "";
208
209	if (!t)
210	return -ENOMEM;
211
212	b = dbus_message_iter_append_basic(i, DBUS_TYPE_STRING, &s);
213	cap_free(t);
214
215	if (!b)
216	return -ENOMEM;
217
218	return 0;
219	}
220
221	int bus_execute_append_rlimits(Manager m, DBusMessageIter i, const char property, void data) {
222	ExecContext *c = data;
223	int r;
224	uint64_t u;
225
226	assert(m);
227	assert(i);
228	assert(property);
229	assert(c);
230
231	assert_se((r = rlimit_from_string(property)) >= 0);
232
233	if (c->rlimit[r])
234	u = (uint64_t) c->rlimit[r]->rlim_max;
235	else {
236	struct rlimit rl;
237
238	zero(rl);
239	getrlimit(r, &rl);
240
241	u = (uint64_t) rl.rlim_max;
242	}
243
244	if (!dbus_message_iter_append_basic(i, DBUS_TYPE_UINT64, &u))
245	return -ENOMEM;
246
247	return 0;
248	}