shaba/systemd
1
0
Fork 0
mirror of https://github.com/systemd/systemd.git synced 2024-11-06 16:59:03 +03:00
Code
d182614649
systemd/src/core/dbus-cgroup.c

366 lines
14 KiB
C
Raw Normal View History

core: general cgroup rework Replace the very generic cgroup hookup with a much simpler one. With this change only the high-level cgroup settings remain, the ability to set arbitrary cgroup attributes is removed, so is support for adding units to arbitrary cgroup controllers or setting arbitrary paths for them (especially paths that are different for the various controllers). This also introduces a new -.slice root slice, that is the parent of system.slice and friends. This enables easy admin configuration of root-level cgrouo properties. This replaces DeviceDeny= by DevicePolicy=, and implicitly adds in /dev/null, /dev/zero and friends if DeviceAllow= is used (unless this is turned off by DevicePolicy=).
2013-06-27 06:14:27 +04:00
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
/***
This file is part of systemd.
Copyright 2013 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 <dbus/dbus.h>
dbus: make DeviceAllow=/DevicePolicy= writable
2013-06-28 01:13:17 +04:00
#include "path-util.h"
core: general cgroup rework Replace the very generic cgroup hookup with a much simpler one. With this change only the high-level cgroup settings remain, the ability to set arbitrary cgroup attributes is removed, so is support for adding units to arbitrary cgroup controllers or setting arbitrary paths for them (especially paths that are different for the various controllers). This also introduces a new -.slice root slice, that is the parent of system.slice and friends. This enables easy admin configuration of root-level cgrouo properties. This replaces DeviceDeny= by DevicePolicy=, and implicitly adds in /dev/null, /dev/zero and friends if DeviceAllow= is used (unless this is turned off by DevicePolicy=).
2013-06-27 06:14:27 +04:00
#include "dbus-cgroup.h"
static DEFINE_BUS_PROPERTY_APPEND_ENUM(bus_cgroup_append_device_policy, cgroup_device_policy, CGroupDevicePolicy);
static int bus_cgroup_append_device_weights(DBusMessageIter *i, const char *property, void *data) {
DBusMessageIter sub, sub2;
CGroupContext *c = data;
CGroupBlockIODeviceWeight *w;
assert(i);
assert(property);
assert(c);
if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(st)", &sub))
return -ENOMEM;
LIST_FOREACH(device_weights, w, c->blockio_device_weights) {
if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &w->path) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT64, &w->weight) ||
!dbus_message_iter_close_container(&sub, &sub2))
return -ENOMEM;
}
if (!dbus_message_iter_close_container(i, &sub))
return -ENOMEM;
return 0;
}
static int bus_cgroup_append_device_bandwidths(DBusMessageIter *i, const char *property, void *data) {
DBusMessageIter sub, sub2;
CGroupContext *c = data;
CGroupBlockIODeviceBandwidth *b;
assert(i);
assert(property);
assert(c);
if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(st)", &sub))
return -ENOMEM;
LIST_FOREACH(device_bandwidths, b, c->blockio_device_bandwidths) {
if (streq(property, "BlockIOReadBandwidth") != b->read)
continue;
if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &b->path) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_UINT64, &b->bandwidth) ||
!dbus_message_iter_close_container(&sub, &sub2))
return -ENOMEM;
}
if (!dbus_message_iter_close_container(i, &sub))
return -ENOMEM;
return 0;
}
static int bus_cgroup_append_device_allow(DBusMessageIter *i, const char *property, void *data) {
DBusMessageIter sub, sub2;
CGroupContext *c = data;
CGroupDeviceAllow *a;
assert(i);
assert(property);
assert(c);
if (!dbus_message_iter_open_container(i, DBUS_TYPE_ARRAY, "(ss)", &sub))
return -ENOMEM;
LIST_FOREACH(device_allow, a, c->device_allow) {
const char *rwm;
char buf[4];
unsigned k = 0;
if (a->r)
buf[k++] = 'r';
if (a->w)
buf[k++] = 'w';
if (a->m)
buf[k++] = 'm';
buf[k] = 0;
rwm = buf;
if (!dbus_message_iter_open_container(&sub, DBUS_TYPE_STRUCT, NULL, &sub2) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &a->path) ||
!dbus_message_iter_append_basic(&sub2, DBUS_TYPE_STRING, &rwm) ||
!dbus_message_iter_close_container(&sub, &sub2))
return -ENOMEM;
}
if (!dbus_message_iter_close_container(i, &sub))
return -ENOMEM;
return 0;
}
const BusProperty bus_cgroup_context_properties[] = {
{ "CPUAccounting", bus_property_append_bool, "b", offsetof(CGroupContext, cpu_accounting) },
{ "CPUShares", bus_property_append_ul, "t", offsetof(CGroupContext, cpu_shares) },
{ "BlockIOAccounting", bus_property_append_bool, "b", offsetof(CGroupContext, blockio_accounting) },
{ "BlockIOWeight", bus_property_append_ul, "t", offsetof(CGroupContext, blockio_weight) },
{ "BlockIODeviceWeight", bus_cgroup_append_device_weights, "a(st)", 0 },
{ "BlockIOReadBandwidth", bus_cgroup_append_device_bandwidths, "a(st)", 0 },
{ "BlockIOWriteBandwidth", bus_cgroup_append_device_bandwidths, "a(st)", 0 },
{ "MemoryAccounting", bus_property_append_bool, "b", offsetof(CGroupContext, memory_accounting) },
{ "MemoryLimit", bus_property_append_uint64, "t", offsetof(CGroupContext, memory_limit) },
{ "MemorySoftLimit", bus_property_append_uint64, "t", offsetof(CGroupContext, memory_soft_limit) },
{ "DevicePolicy", bus_cgroup_append_device_policy, "s", offsetof(CGroupContext, device_policy) },
{ "DeviceAllow", bus_cgroup_append_device_allow, "a(ss)", 0 },
{}
};
dbus: add infrastructure for changing multiple properties at once on units and hook some cgroup attributes up to it This introduces two bus calls to make runtime changes to selected bus properties, optionally with persistence. This currently hooks this up only for three cgroup atributes, but this brings the infrastructure to add more changable attributes. This allows setting multiple attributes at once, and takes an array rather than a dictionary of properties, in order to implement simple resetting of lists using the same approach as when they are sourced from unit files. This means, that list properties are appended to by this call, unless they are first reset via assigning the empty list.
2013-06-27 23:14:56 +04:00
int bus_cgroup_set_property(
Unit *u,
CGroupContext *c,
const char *name,
DBusMessageIter *i,
UnitSetPropertiesMode mode,
DBusError *error) {
assert(name);
assert(u);
assert(c);
assert(i);
if (streq(name, "CPUAccounting")) {
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_BOOLEAN)
return -EINVAL;
if (mode != UNIT_CHECK) {
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
dbus_bool_t b;
dbus: add infrastructure for changing multiple properties at once on units and hook some cgroup attributes up to it This introduces two bus calls to make runtime changes to selected bus properties, optionally with persistence. This currently hooks this up only for three cgroup atributes, but this brings the infrastructure to add more changable attributes. This allows setting multiple attributes at once, and takes an array rather than a dictionary of properties, in order to implement simple resetting of lists using the same approach as when they are sourced from unit files. This means, that list properties are appended to by this call, unless they are first reset via assigning the empty list.
2013-06-27 23:14:56 +04:00
dbus_message_iter_get_basic(i, &b);
c->cpu_accounting = b;
core: simplify drop-in writing logic a bit let's make use of some format string magic!
2013-07-11 23:29:33 +04:00
unit_write_drop_in_private(u, mode, name, b ? "CPUAccounting=yes" : "CPUAccounting=no");
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
}
return 1;
} else if (streq(name, "CPUShares")) {
uint64_t u64;
unsigned long ul;
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_UINT64)
return -EINVAL;
dbus_message_iter_get_basic(i, &u64);
ul = (unsigned long) u64;
if (u64 <= 0 || u64 != (uint64_t) ul)
return -EINVAL;
if (mode != UNIT_CHECK) {
c->cpu_shares = ul;
core: simplify drop-in writing logic a bit let's make use of some format string magic!
2013-07-11 23:29:33 +04:00
unit_write_drop_in_private_format(u, mode, name, "CPUShares=%lu", ul);
dbus: add infrastructure for changing multiple properties at once on units and hook some cgroup attributes up to it This introduces two bus calls to make runtime changes to selected bus properties, optionally with persistence. This currently hooks this up only for three cgroup atributes, but this brings the infrastructure to add more changable attributes. This allows setting multiple attributes at once, and takes an array rather than a dictionary of properties, in order to implement simple resetting of lists using the same approach as when they are sourced from unit files. This means, that list properties are appended to by this call, unless they are first reset via assigning the empty list.
2013-06-27 23:14:56 +04:00
}
return 1;
} else if (streq(name, "BlockIOAccounting")) {
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_BOOLEAN)
return -EINVAL;
if (mode != UNIT_CHECK) {
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
dbus_bool_t b;
dbus: add infrastructure for changing multiple properties at once on units and hook some cgroup attributes up to it This introduces two bus calls to make runtime changes to selected bus properties, optionally with persistence. This currently hooks this up only for three cgroup atributes, but this brings the infrastructure to add more changable attributes. This allows setting multiple attributes at once, and takes an array rather than a dictionary of properties, in order to implement simple resetting of lists using the same approach as when they are sourced from unit files. This means, that list properties are appended to by this call, unless they are first reset via assigning the empty list.
2013-06-27 23:14:56 +04:00
dbus_message_iter_get_basic(i, &b);
c->blockio_accounting = b;
core: simplify drop-in writing logic a bit let's make use of some format string magic!
2013-07-11 23:29:33 +04:00
unit_write_drop_in_private(u, mode, name, b ? "BlockIOAccounting=yes" : "BlockIOAccounting=no");
dbus: add infrastructure for changing multiple properties at once on units and hook some cgroup attributes up to it This introduces two bus calls to make runtime changes to selected bus properties, optionally with persistence. This currently hooks this up only for three cgroup atributes, but this brings the infrastructure to add more changable attributes. This allows setting multiple attributes at once, and takes an array rather than a dictionary of properties, in order to implement simple resetting of lists using the same approach as when they are sourced from unit files. This means, that list properties are appended to by this call, unless they are first reset via assigning the empty list.
2013-06-27 23:14:56 +04:00
}
return 1;
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
} else if (streq(name, "BlockIOWeight")) {
uint64_t u64;
unsigned long ul;
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_UINT64)
return -EINVAL;
dbus_message_iter_get_basic(i, &u64);
ul = (unsigned long) u64;
if (u64 < 10 || u64 > 1000)
return -EINVAL;
if (mode != UNIT_CHECK) {
c->cpu_shares = ul;
core: simplify drop-in writing logic a bit let's make use of some format string magic!
2013-07-11 23:29:33 +04:00
unit_write_drop_in_private_format(u, mode, name, "BlockIOWeight=%lu", ul);
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
}
return 1;
dbus: add infrastructure for changing multiple properties at once on units and hook some cgroup attributes up to it This introduces two bus calls to make runtime changes to selected bus properties, optionally with persistence. This currently hooks this up only for three cgroup atributes, but this brings the infrastructure to add more changable attributes. This allows setting multiple attributes at once, and takes an array rather than a dictionary of properties, in order to implement simple resetting of lists using the same approach as when they are sourced from unit files. This means, that list properties are appended to by this call, unless they are first reset via assigning the empty list.
2013-06-27 23:14:56 +04:00
} else if (streq(name, "MemoryAccounting")) {
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_BOOLEAN)
return -EINVAL;
if (mode != UNIT_CHECK) {
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
dbus_bool_t b;
dbus: add infrastructure for changing multiple properties at once on units and hook some cgroup attributes up to it This introduces two bus calls to make runtime changes to selected bus properties, optionally with persistence. This currently hooks this up only for three cgroup atributes, but this brings the infrastructure to add more changable attributes. This allows setting multiple attributes at once, and takes an array rather than a dictionary of properties, in order to implement simple resetting of lists using the same approach as when they are sourced from unit files. This means, that list properties are appended to by this call, unless they are first reset via assigning the empty list.
2013-06-27 23:14:56 +04:00
dbus_message_iter_get_basic(i, &b);
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
c->memory_accounting = b;
core: simplify drop-in writing logic a bit let's make use of some format string magic!
2013-07-11 23:29:33 +04:00
unit_write_drop_in_private(u, mode, name, b ? "MemoryAccounting=yes" : "MemoryAccounting=no");
dbus: add infrastructure for changing multiple properties at once on units and hook some cgroup attributes up to it This introduces two bus calls to make runtime changes to selected bus properties, optionally with persistence. This currently hooks this up only for three cgroup atributes, but this brings the infrastructure to add more changable attributes. This allows setting multiple attributes at once, and takes an array rather than a dictionary of properties, in order to implement simple resetting of lists using the same approach as when they are sourced from unit files. This means, that list properties are appended to by this call, unless they are first reset via assigning the empty list.
2013-06-27 23:14:56 +04:00
}
return 1;
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
} else if (streq(name, "MemoryLimit") || streq(name, "MemorySoftLimit")) {
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_UINT64)
return -EINVAL;
if (mode != UNIT_CHECK) {
uint64_t limit;
dbus_message_iter_get_basic(i, &limit);
core: simplify drop-in writing logic a bit let's make use of some format string magic!
2013-07-11 23:29:33 +04:00
if (streq(name, "MemoryLimit"))
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
c->memory_limit = limit;
core: simplify drop-in writing logic a bit let's make use of some format string magic!
2013-07-11 23:29:33 +04:00
else
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
c->memory_soft_limit = limit;
core: simplify drop-in writing logic a bit let's make use of some format string magic!
2013-07-11 23:29:33 +04:00
unit_write_drop_in_private_format(u, mode, name, "%s=%" PRIu64, name, limit);
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
}
dbus: make DeviceAllow=/DevicePolicy= writable
2013-06-28 01:13:17 +04:00
return 1;
} else if (streq(name, "DevicePolicy")) {
const char *policy;
CGroupDevicePolicy p;
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_STRING)
return -EINVAL;
dbus_message_iter_get_basic(i, &policy);
p = cgroup_device_policy_from_string(policy);
if (p < 0)
return -EINVAL;
if (mode != UNIT_CHECK) {
char *buf;
c->device_policy = p;
buf = strappenda("DevicePolicy=", policy);
core: simplify drop-in writing logic a bit let's make use of some format string magic!
2013-07-11 23:29:33 +04:00
unit_write_drop_in_private(u, mode, name, buf);
dbus: make DeviceAllow=/DevicePolicy= writable
2013-06-28 01:13:17 +04:00
}
return 1;
} else if (streq(name, "DeviceAllow")) {
DBusMessageIter sub;
unsigned n = 0;
if (dbus_message_iter_get_arg_type(i) != DBUS_TYPE_ARRAY ||
dbus_message_iter_get_element_type(i) != DBUS_TYPE_STRUCT)
return -EINVAL;
dbus_message_iter_recurse(i, &sub);
while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
DBusMessageIter sub2;
const char *path, *rwm;
CGroupDeviceAllow *a;
dbus_message_iter_recurse(&sub, &sub2);
if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) < 0 ||
bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &rwm, false) < 0)
return -EINVAL;
if (!path_startswith(path, "/dev")) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "DeviceAllow= requires device node");
return -EINVAL;
}
if (isempty(rwm))
rwm = "rwm";
if (!in_charset(rwm, "rwm")) {
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "DeviceAllow= requires combination of rwm flags");
return -EINVAL;
}
if (mode != UNIT_CHECK) {
a = new0(CGroupDeviceAllow, 1);
if (!a)
return -ENOMEM;
a->path = strdup(path);
if (!a->path) {
free(a);
return -ENOMEM;
}
a->r = !!strchr(rwm, 'r');
a->w = !!strchr(rwm, 'w');
a->m = !!strchr(rwm, 'm');
LIST_PREPEND(CGroupDeviceAllow, device_allow, c->device_allow, a);
}
core: add transient units Transient units can be created via the bus API. They are configured via the method call parameters rather than on-disk files. They are subject to normal GC. Transient units currently may only be created for services (however, we will extend this), and currently only ExecStart= and the cgroup parameters can be configured (also to be extended). Transient units require a unique name, that previously had no configuration file on disk. A tool systemd-run is added that makes use of this functionality to run arbitrary command lines as transient services: $ systemd-run /bin/ping www.heise.de Will cause systemd to create a new transient service and run ping in it.
2013-06-28 06:12:58 +04:00
n++;
dbus: make DeviceAllow=/DevicePolicy= writable
2013-06-28 01:13:17 +04:00
dbus_message_iter_next(&sub);
}
if (mode != UNIT_CHECK) {
_cleanup_free_ char *buf = NULL;
_cleanup_fclose_ FILE *f = NULL;
CGroupDeviceAllow *a;
size_t size = 0;
if (n == 0) {
while (c->device_allow)
cgroup_context_free_device_allow(c, c->device_allow);
}
f = open_memstream(&buf, &size);
if (!f)
return -ENOMEM;
fputs("DeviceAllow=\n", f);
LIST_FOREACH(device_allow, a, c->device_allow)
fprintf(f, "DeviceAllow=%s %s%s%s\n", a->path, a->r ? "r" : "", a->w ? "w" : "", a->m ? "m" : "");
fflush(f);
core: simplify drop-in writing logic a bit let's make use of some format string magic!
2013-07-11 23:29:33 +04:00
unit_write_drop_in_private(u, mode, name, buf);
dbus: make DeviceAllow=/DevicePolicy= writable
2013-06-28 01:13:17 +04:00
}
dbus: make more cgroup attributes runtime settable
2013-06-27 23:50:35 +04:00
return 1;
}
dbus: add infrastructure for changing multiple properties at once on units and hook some cgroup attributes up to it This introduces two bus calls to make runtime changes to selected bus properties, optionally with persistence. This currently hooks this up only for three cgroup atributes, but this brings the infrastructure to add more changable attributes. This allows setting multiple attributes at once, and takes an array rather than a dictionary of properties, in order to implement simple resetting of lists using the same approach as when they are sourced from unit files. This means, that list properties are appended to by this call, unless they are first reset via assigning the empty list.
2013-06-27 23:14:56 +04:00
return 0;
}
Copy Permalink