@org.freedesktop.DBus.Property.EmitsChangedSignal("const")
readonly u DefaultStartLimitBurst = ...;
@org.freedesktop.DBus.Property.EmitsChangedSignal("const")
- readonly b DefaultCPUAccounting = ...;
- @org.freedesktop.DBus.Property.EmitsChangedSignal("const")
readonly b DefaultIOAccounting = ...;
@org.freedesktop.DBus.Property.EmitsChangedSignal("const")
readonly b DefaultIPAccounting = ...;
<!--property DefaultStartLimitBurst is not documented!-->
- <!--property DefaultCPUAccounting is not documented!-->
-
<!--property DefaultIOAccounting is not documented!-->
<!--property DefaultIPAccounting is not documented!-->
<variablelist class="dbus-property" generated="True" extra-ref="DefaultStartLimitBurst"/>
- <variablelist class="dbus-property" generated="True" extra-ref="DefaultCPUAccounting"/>
-
<variablelist class="dbus-property" generated="True" extra-ref="DefaultIOAccounting"/>
<variablelist class="dbus-property" generated="True" extra-ref="DefaultIPAccounting"/>
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly s DelegateSubgroup = '...';
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
- readonly b CPUAccounting = ...;
- @org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t CPUWeight = ...;
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t StartupCPUWeight = ...;
<!--property DelegateControllers is not documented!-->
- <!--property CPUAccounting is not documented!-->
-
<!--property CPUWeight is not documented!-->
<!--property StartupCPUWeight is not documented!-->
<variablelist class="dbus-property" generated="True" extra-ref="DelegateSubgroup"/>
- <variablelist class="dbus-property" generated="True" extra-ref="CPUAccounting"/>
-
<variablelist class="dbus-property" generated="True" extra-ref="CPUWeight"/>
<variablelist class="dbus-property" generated="True" extra-ref="StartupCPUWeight"/>
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly s DelegateSubgroup = '...';
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
- readonly b CPUAccounting = ...;
- @org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t CPUWeight = ...;
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t StartupCPUWeight = ...;
<!--property DelegateControllers is not documented!-->
- <!--property CPUAccounting is not documented!-->
-
<!--property CPUWeight is not documented!-->
<!--property StartupCPUWeight is not documented!-->
<variablelist class="dbus-property" generated="True" extra-ref="DelegateSubgroup"/>
- <variablelist class="dbus-property" generated="True" extra-ref="CPUAccounting"/>
-
<variablelist class="dbus-property" generated="True" extra-ref="CPUWeight"/>
<variablelist class="dbus-property" generated="True" extra-ref="StartupCPUWeight"/>
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly s DelegateSubgroup = '...';
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
- readonly b CPUAccounting = ...;
- @org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t CPUWeight = ...;
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t StartupCPUWeight = ...;
<!--property DelegateControllers is not documented!-->
- <!--property CPUAccounting is not documented!-->
-
<!--property CPUWeight is not documented!-->
<!--property StartupCPUWeight is not documented!-->
<variablelist class="dbus-property" generated="True" extra-ref="DelegateSubgroup"/>
- <variablelist class="dbus-property" generated="True" extra-ref="CPUAccounting"/>
-
<variablelist class="dbus-property" generated="True" extra-ref="CPUWeight"/>
<variablelist class="dbus-property" generated="True" extra-ref="StartupCPUWeight"/>
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly s DelegateSubgroup = '...';
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
- readonly b CPUAccounting = ...;
- @org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t CPUWeight = ...;
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t StartupCPUWeight = ...;
<!--property DelegateControllers is not documented!-->
- <!--property CPUAccounting is not documented!-->
-
<!--property CPUWeight is not documented!-->
<!--property StartupCPUWeight is not documented!-->
<variablelist class="dbus-property" generated="True" extra-ref="DelegateSubgroup"/>
- <variablelist class="dbus-property" generated="True" extra-ref="CPUAccounting"/>
-
<variablelist class="dbus-property" generated="True" extra-ref="CPUWeight"/>
<variablelist class="dbus-property" generated="True" extra-ref="StartupCPUWeight"/>
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly s DelegateSubgroup = '...';
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
- readonly b CPUAccounting = ...;
- @org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t CPUWeight = ...;
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t StartupCPUWeight = ...;
<!--property DelegateControllers is not documented!-->
- <!--property CPUAccounting is not documented!-->
-
<!--property CPUWeight is not documented!-->
<!--property StartupCPUWeight is not documented!-->
<variablelist class="dbus-property" generated="True" extra-ref="DelegateSubgroup"/>
- <variablelist class="dbus-property" generated="True" extra-ref="CPUAccounting"/>
-
<variablelist class="dbus-property" generated="True" extra-ref="CPUWeight"/>
<variablelist class="dbus-property" generated="True" extra-ref="StartupCPUWeight"/>
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly s DelegateSubgroup = '...';
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
- readonly b CPUAccounting = ...;
- @org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t CPUWeight = ...;
@org.freedesktop.DBus.Property.EmitsChangedSignal("false")
readonly t StartupCPUWeight = ...;
<!--property DelegateControllers is not documented!-->
- <!--property CPUAccounting is not documented!-->
-
<!--property CPUWeight is not documented!-->
<!--property StartupCPUWeight is not documented!-->
<variablelist class="dbus-property" generated="True" extra-ref="DelegateSubgroup"/>
- <variablelist class="dbus-property" generated="True" extra-ref="CPUAccounting"/>
-
<variablelist class="dbus-property" generated="True" extra-ref="CPUWeight"/>
<variablelist class="dbus-property" generated="True" extra-ref="StartupCPUWeight"/>
given, is honored. This mode is suitable for scripting.</para>
<para>Resource usage is only accounted for control groups with the appropriate controllers turned on:
- <literal>cpu</literal> controller for CPU usage, <literal>memory</literal> controller for memory usage,
- and <literal>io</literal> controller for disk I/O consumption. If resource monitoring for these resources
- is required, it is recommended to add the <varname>CPUAccounting=1</varname>,
- <varname>MemoryAccounting=1</varname> and <varname>IOAccounting=1</varname> settings in the unit files in
- question. See
+ <literal>memory</literal> controller for memory usage and <literal>io</literal> controller for disk I/O consumption.
+ If resource monitoring for these resources is required, it is recommended to add the <varname>MemoryAccounting=1</varname>
+ and <varname>IOAccounting=1</varname> settings in the unit files in question. See
<citerefentry><refentrytitle>systemd.resource-control</refentrytitle><manvolnum>5</manvolnum></citerefentry>
for details.</para>
the CPU load value is going to be between 0% and 800%. The number of
processors can be found in <literal>/proc/cpuinfo</literal>.</para>
- <para>To emphasize: unless <literal>CPUAccounting=1</literal>, <literal>MemoryAccounting=1</literal>, and
- <literal>IOAccounting=1</literal> are enabled for the services in question, no resource accounting will
- be available for system services and the data shown by <command>systemd-cgtop</command> will be
- incomplete.</para>
+ <para>To emphasize: unless <literal>MemoryAccounting=1</literal> and <literal>IOAccounting=1</literal>
+ are enabled for the services in question, no resource accounting will be available for system services
+ and the data shown by <command>systemd-cgtop</command> will be incomplete.</para>
</refsect1>
<refsect1>
</varlistentry>
<varlistentry>
- <term><varname>DefaultCPUAccounting=</varname></term>
<term><varname>DefaultMemoryAccounting=</varname></term>
<term><varname>DefaultTasksAccounting=</varname></term>
<term><varname>DefaultIOAccounting=</varname></term>
<listitem>
<para>Configure the default resource accounting settings, as configured per-unit by
- <varname>CPUAccounting=</varname>, <varname>MemoryAccounting=</varname>,
- <varname>TasksAccounting=</varname>, <varname>IOAccounting=</varname> and
- <varname>IPAccounting=</varname>. See
+ <varname>MemoryAccounting=</varname>, <varname>TasksAccounting=</varname>, <varname>IOAccounting=</varname>,
+ and <varname>IPAccounting=</varname>. See
<citerefentry><refentrytitle>systemd.resource-control</refentrytitle><manvolnum>5</manvolnum></citerefentry>
for details on the per-unit settings.</para>
- <para><varname>DefaultCPUAccounting=</varname> defaults to yes when running on kernel ≥4.15, and no on older versions.
- <varname>DefaultMemoryAccounting=</varname> defaults to &MEMORY_ACCOUNTING_DEFAULT;.
+ <para><varname>DefaultMemoryAccounting=</varname> defaults to &MEMORY_ACCOUNTING_DEFAULT;.
<varname>DefaultTasksAccounting=</varname> defaults to yes.
The other settings default to no.</para>
to the unified cgroup hierarchy.</para></listitem>
</varlistentry>
</variablelist>
+
+ <variablelist>
+ <varlistentry>
+ <term>systemd 258</term>
+
+ <listitem><para><varname>DefaultCPUAccounting=</varname> setting is deprecated, because CPU accounting
+ is always available on the unified cgroup hierarchy and such setting has no effect.</para></listitem>
+ </varlistentry>
+ </variablelist>
</refsect1>
<refsect1>
<para>Units of the types listed above can have settings for resource control configuration:</para>
- <refsect2><title>CPU Accounting and Control</title>
+ <refsect2><title>CPU Control</title>
<variablelist class='unit-directives'>
- <varlistentry>
- <term><varname>CPUAccounting=</varname></term>
-
- <listitem>
- <para>Turn on CPU usage accounting for this unit. Takes a
- boolean argument. Note that turning on CPU accounting for
- one unit will also implicitly turn it on for all units
- contained in the same slice and for all its parent slices
- and the units contained therein. The system default for this
- setting may be controlled with
- <varname>DefaultCPUAccounting=</varname> in
- <citerefentry><refentrytitle>systemd-system.conf</refentrytitle><manvolnum>5</manvolnum></citerefentry>.</para>
-
- <para>Under the unified cgroup hierarchy, CPU accounting is available for all units and this
- setting has no effect.</para>
-
- <xi:include href="version-info.xml" xpointer="v208"/>
- </listitem>
- </varlistentry>
-
<varlistentry>
<term><varname>CPUWeight=<replaceable>weight</replaceable></varname></term>
<term><varname>StartupCPUWeight=<replaceable>weight</replaceable></varname></term>
Please switch to the unified cgroup hierarchy.</para></listitem>
</varlistentry>
</variablelist>
+
+ <variablelist>
+ <varlistentry>
+ <term>systemd 258</term>
+
+ <listitem><para><varname>CPUAccounting=</varname> setting is deprecated, because it is always available
+ on the unified cgroup hierarchy and such setting has no effect.</para></listitem>
+ </varlistentry>
+ </variablelist>
</refsect1>
<refsect1>
DEFINE_STRING_TABLE_LOOKUP(cgroup_controller, CGroupController);
-CGroupMask get_cpu_accounting_mask(void) {
- static CGroupMask needed_mask = (CGroupMask) -1;
-
- /* On kernel ≥4.15 with unified hierarchy, cpu.stat's usage_usec is
- * provided externally from the CPU controller, which means we don't
- * need to enable the CPU controller just to get metrics. This is good,
- * because enabling the CPU controller comes at a minor performance
- * hit, especially when it's propagated deep into large hierarchies.
- * There's also no separate CPU accounting controller available within
- * a unified hierarchy.
- *
- * This combination of factors results in the desired cgroup mask to
- * enable for CPU accounting varying as follows:
- *
- * ╔═════════════════════╤═════════════════════╗
- * ║ Linux ≥4.15 │ Linux <4.15 ║
- * ╔═══════════════╬═════════════════════╪═════════════════════╣
- * ║ Unified ║ nothing │ CGROUP_MASK_CPU ║
- * ╟───────────────╫─────────────────────┼─────────────────────╢
- * ║ Hybrid/Legacy ║ CGROUP_MASK_CPUACCT │ CGROUP_MASK_CPUACCT ║
- * ╚═══════════════╩═════════════════════╧═════════════════════╝
- *
- * We check kernel version here instead of manually checking whether
- * cpu.stat is present for every cgroup, as that check in itself would
- * already be fairly expensive.
- *
- * Kernels where this patch has been backported will therefore have the
- * CPU controller enabled unnecessarily. This is more expensive than
- * necessary, but harmless. ☺️
- */
-
- if (needed_mask == (CGroupMask) -1) {
- if (cg_all_unified()) {
- struct utsname u;
- assert_se(uname(&u) >= 0);
-
- if (strverscmp_improved(u.release, "4.15") < 0)
- needed_mask = CGROUP_MASK_CPU;
- else
- needed_mask = 0;
- } else
- needed_mask = CGROUP_MASK_CPUACCT;
- }
-
- return needed_mask;
-}
-
-bool cpu_accounting_is_cheap(void) {
- return get_cpu_accounting_mask() == 0;
-}
-
static const char* const managed_oom_mode_table[_MANAGED_OOM_MODE_MAX] = {
[MANAGED_OOM_AUTO] = "auto",
[MANAGED_OOM_KILL] = "kill",
return mask;
}
-CGroupMask get_cpu_accounting_mask(void);
-bool cpu_accounting_is_cheap(void);
-
/* Special values for all weight knobs on unified hierarchy */
#define CGROUP_WEIGHT_INVALID UINT64_MAX
#define CGROUP_WEIGHT_IDLE UINT64_C(0)
startup_cpuset_mems = cpu_set_to_range_string(&c->startup_cpuset_mems);
fprintf(f,
- "%sCPUAccounting: %s\n"
"%sIOAccounting: %s\n"
"%sMemoryAccounting: %s\n"
"%sTasksAccounting: %s\n"
"%sManagedOOMPreference: %s\n"
"%sMemoryPressureWatch: %s\n"
"%sCoredumpReceive: %s\n",
- prefix, yes_no(c->cpu_accounting),
prefix, yes_no(c->io_accounting),
prefix, yes_no(c->memory_accounting),
prefix, yes_no(c->tasks_accounting),
/* Figure out which controllers we need, based on the cgroup context object */
- if (c->cpu_accounting)
- mask |= get_cpu_accounting_mask();
-
if (cgroup_context_has_cpu_weight(c) ||
c->cpu_quota_per_sec_usec != USEC_INFINITY)
mask |= CGROUP_MASK_CPU;
if (unit_has_host_root_cgroup(u))
return procfs_cpu_get_usage(ret);
- /* Requisite controllers for CPU accounting are not enabled */
- if ((get_cpu_accounting_mask() & ~crt->cgroup_realized_mask) != 0)
- return -ENODATA;
-
_cleanup_free_ char *val = NULL;
uint64_t us;
* started. If the cgroup has been removed already, returns the last cached value. To cache the value, simply
* call this function with a NULL return value. */
- if (!UNIT_CGROUP_BOOL(u, cpu_accounting))
- return -ENODATA;
-
CGroupRuntime *crt = unit_get_cgroup_runtime(u);
if (!crt)
return -ENODATA;
* manager is running (except for an occasional SetProperty() configuration change), outside of reload
* cycles. */
struct CGroupContext {
- bool cpu_accounting;
bool io_accounting;
bool memory_accounting;
bool tasks_accounting;
SD_BUS_PROPERTY("Delegate", "b", bus_property_get_bool, offsetof(CGroupContext, delegate), 0),
SD_BUS_PROPERTY("DelegateControllers", "as", property_get_delegate_controllers, 0, 0),
SD_BUS_PROPERTY("DelegateSubgroup", "s", NULL, offsetof(CGroupContext, delegate_subgroup), 0),
- SD_BUS_PROPERTY("CPUAccounting", "b", bus_property_get_bool, offsetof(CGroupContext, cpu_accounting), 0),
SD_BUS_PROPERTY("CPUWeight", "t", NULL, offsetof(CGroupContext, cpu_weight), 0),
SD_BUS_PROPERTY("StartupCPUWeight", "t", NULL, offsetof(CGroupContext, startup_cpu_weight), 0),
SD_BUS_PROPERTY("CPUQuotaPerSecUSec", "t", bus_property_get_usec, offsetof(CGroupContext, cpu_quota_per_sec_usec), 0),
SD_BUS_PROPERTY("MemoryPressureThresholdUSec", "t", bus_property_get_usec, offsetof(CGroupContext, memory_pressure_threshold_usec), 0),
SD_BUS_PROPERTY("NFTSet", "a(iiss)", property_get_cgroup_nft_set, 0, 0),
SD_BUS_PROPERTY("CoredumpReceive", "b", bus_property_get_bool, offsetof(CGroupContext, coredump_receive), 0),
+
/* deprecated cgroup v1 properties */
SD_BUS_PROPERTY("MemoryLimit", "t", bus_property_get_uint64_max, 0, SD_BUS_VTABLE_DEPRECATED|SD_BUS_VTABLE_HIDDEN),
SD_BUS_PROPERTY("CPUShares", "t", bus_property_get_uint64_max, 0, SD_BUS_VTABLE_DEPRECATED|SD_BUS_VTABLE_HIDDEN),
SD_BUS_PROPERTY("BlockIODeviceWeight", "a(st)", property_get_blockio_ast, 0, SD_BUS_VTABLE_DEPRECATED|SD_BUS_VTABLE_HIDDEN),
SD_BUS_PROPERTY("BlockIOReadBandwidth", "a(st)", property_get_blockio_ast, 0, SD_BUS_VTABLE_DEPRECATED|SD_BUS_VTABLE_HIDDEN),
SD_BUS_PROPERTY("BlockIOWriteBandwidth", "a(st)", property_get_blockio_ast, 0, SD_BUS_VTABLE_DEPRECATED|SD_BUS_VTABLE_HIDDEN),
+ /* since kernel v4.15 CPU accounting requires no controller, i.e. is available everywhere */
+ SD_BUS_PROPERTY("CPUAccounting", "b", bus_property_get_bool_true, 0, SD_BUS_VTABLE_DEPRECATED|SD_BUS_VTABLE_HIDDEN),
+
SD_BUS_VTABLE_END
};
flags |= UNIT_PRIVATE;
- if (streq(name, "CPUAccounting"))
- return bus_cgroup_set_boolean(u, name, &c->cpu_accounting, get_cpu_accounting_mask(), message, flags, error);
-
if (streq(name, "CPUWeight"))
return bus_cgroup_set_cpu_weight(u, name, &c->cpu_weight, message, flags, error);
"StartupBlockIOWeight",
"BlockIODeviceWeight",
"BlockIOReadBandwidth",
- "BlockIOWriteBandwidth")) {
+ "BlockIOWriteBandwidth",
+ "CPUAccounting")) { /* see comment in bus_cgroup_vtable */
r = sd_bus_message_skip(message, NULL);
if (r < 0)
SD_BUS_PROPERTY("DefaultStartLimitIntervalSec", "t", bus_property_get_usec, offsetof(Manager, defaults.start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
SD_BUS_PROPERTY("DefaultStartLimitInterval", "t", bus_property_get_usec, offsetof(Manager, defaults.start_limit.interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned, offsetof(Manager, defaults.start_limit.burst), SD_BUS_VTABLE_PROPERTY_CONST),
- SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.cpu_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("DefaultIOAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.io_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("DefaultIPAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.ip_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.memory_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("DefaultOOMScoreAdjust", "i", property_get_oom_score_adjust, 0, SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("CtrlAltDelBurstAction", "s", bus_property_get_emergency_action, offsetof(Manager, cad_burst_action), SD_BUS_VTABLE_PROPERTY_CONST),
SD_BUS_PROPERTY("SoftRebootsCount", "u", bus_property_get_unsigned, offsetof(Manager, soft_reboots_count), SD_BUS_VTABLE_PROPERTY_CONST),
+
/* deprecated cgroup v1 property */
SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool_false, 0, SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_DEPRECATED|SD_BUS_VTABLE_HIDDEN),
+ /* see comment in bus_cgroup_vtable */
+ SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool_true, 0, SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_DEPRECATED|SD_BUS_VTABLE_HIDDEN),
SD_BUS_METHOD_WITH_ARGS("GetUnit",
SD_BUS_ARGS("s", name),
if (!c)
return 0;
- r = serialize_bool_elide(f, "exec-cgroup-context-cpu-accounting", c->cpu_accounting);
- if (r < 0)
- return r;
-
r = serialize_bool_elide(f, "exec-cgroup-context-io-accounting", c->io_accounting);
if (r < 0)
return r;
if (r == 0) /* eof or end marker */
break;
- if ((val = startswith(l, "exec-cgroup-context-cpu-accounting="))) {
- r = parse_boolean(val);
- if (r < 0)
- return r;
- c->cpu_accounting = r;
- } else if ((val = startswith(l, "exec-cgroup-context-io-accounting="))) {
+ if ((val = startswith(l, "exec-cgroup-context-io-accounting="))) {
r = parse_boolean(val);
if (r < 0)
return r;
{{type}}.StartupAllowedCPUs, config_parse_allowed_cpuset, 0, offsetof({{type}}, cgroup_context.startup_cpuset_cpus)
{{type}}.AllowedMemoryNodes, config_parse_allowed_cpuset, 0, offsetof({{type}}, cgroup_context.cpuset_mems)
{{type}}.StartupAllowedMemoryNodes, config_parse_allowed_cpuset, 0, offsetof({{type}}, cgroup_context.startup_cpuset_mems)
-{{type}}.CPUAccounting, config_parse_bool, 0, offsetof({{type}}, cgroup_context.cpu_accounting)
+{{type}}.CPUAccounting, config_parse_warn_compat, DISABLED_LEGACY, 0
{{type}}.CPUWeight, config_parse_cg_cpu_weight, 0, offsetof({{type}}, cgroup_context.cpu_weight)
{{type}}.StartupCPUWeight, config_parse_cg_cpu_weight, 0, offsetof({{type}}, cgroup_context.startup_cpu_weight)
{{type}}.CPUShares, config_parse_warn_compat, DISABLED_LEGACY, 0
{ "Manager", "DefaultLimitNICE", config_parse_rlimit, RLIMIT_NICE, arg_defaults.rlimit },
{ "Manager", "DefaultLimitRTPRIO", config_parse_rlimit, RLIMIT_RTPRIO, arg_defaults.rlimit },
{ "Manager", "DefaultLimitRTTIME", config_parse_rlimit, RLIMIT_RTTIME, arg_defaults.rlimit },
- { "Manager", "DefaultCPUAccounting", config_parse_bool, 0, &arg_defaults.cpu_accounting },
+ { "Manager", "DefaultCPUAccounting", config_parse_warn_compat, DISABLED_LEGACY, NULL },
{ "Manager", "DefaultIOAccounting", config_parse_bool, 0, &arg_defaults.io_accounting },
{ "Manager", "DefaultIPAccounting", config_parse_bool, 0, &arg_defaults.ip_accounting },
{ "Manager", "DefaultBlockIOAccounting", config_parse_warn_compat, DISABLED_LEGACY, NULL },
JSON_BUILD_PAIR_FINITE_USEC("DefaultDeviceTimeoutUSec", m->defaults.device_timeout_usec),
JSON_BUILD_PAIR_FINITE_USEC("DefaultRestartUSec", m->defaults.restart_usec),
JSON_BUILD_PAIR_RATELIMIT("DefaultStartLimit", &m->defaults.start_limit),
- SD_JSON_BUILD_PAIR_BOOLEAN("DefaultCPUAccounting", m->defaults.cpu_accounting),
SD_JSON_BUILD_PAIR_BOOLEAN("DefaultIOAccounting", m->defaults.io_accounting),
SD_JSON_BUILD_PAIR_BOOLEAN("DefaultIPAccounting", m->defaults.ip_accounting),
SD_JSON_BUILD_PAIR_BOOLEAN("DefaultMemoryAccounting", m->defaults.memory_accounting),
m->defaults.start_limit = defaults->start_limit;
- m->defaults.cpu_accounting = defaults->cpu_accounting;
m->defaults.memory_accounting = defaults->memory_accounting;
m->defaults.io_accounting = defaults->io_accounting;
m->defaults.tasks_accounting = defaults->tasks_accounting;
.device_timeout_usec = manager_default_timeout(scope),
.start_limit = { DEFAULT_START_LIMIT_INTERVAL, DEFAULT_START_LIMIT_BURST },
- /* On 4.15+ with unified hierarchy, CPU accounting is essentially free as it doesn't require the CPU
- * controller to be enabled, so the default is to enable it unless we got told otherwise. */
- .cpu_accounting = cpu_accounting_is_cheap(),
.memory_accounting = MEMORY_ACCOUNTING_DEFAULT,
.io_accounting = false,
.tasks_accounting = true,
RateLimit start_limit;
- bool cpu_accounting;
bool memory_accounting;
bool io_accounting;
bool tasks_accounting;
* means the kernel will track CPU/tasks/memory for us anyway, and it is all available in /proc. Let's
* hence turn accounting on here, so that our APIs to query this data are available. */
- s->cgroup_context.cpu_accounting = true;
s->cgroup_context.tasks_accounting = true;
s->cgroup_context.memory_accounting = true;
}
#DefaultStartLimitIntervalSec=10s
#DefaultStartLimitBurst=5
#DefaultEnvironment=
-#DefaultCPUAccounting=yes
#DefaultIOAccounting=no
#DefaultIPAccounting=no
#DefaultMemoryAccounting={{ 'yes' if MEMORY_ACCOUNTING_DEFAULT else 'no' }}
* context, _before_ the rest of the settings have
* been initialized */
- cc->cpu_accounting = u->manager->defaults.cpu_accounting;
cc->io_accounting = u->manager->defaults.io_accounting;
cc->memory_accounting = u->manager->defaults.memory_accounting;
cc->tasks_accounting = u->manager->defaults.tasks_accounting;
#include "string-util.h"
BUS_DEFINE_PROPERTY_GET_GLOBAL(bus_property_get_bool_false, "b", 0);
+BUS_DEFINE_PROPERTY_GET_GLOBAL(bus_property_get_bool_true, "b", 1);
BUS_DEFINE_PROPERTY_GET_GLOBAL(bus_property_get_uint64_max, "t", UINT64_MAX);
int bus_property_get_bool(
#include "macro.h"
-/* For deprecated properties. */
-int bus_property_get_bool_false(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
-int bus_property_get_uint64_max(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
-
int bus_property_get_bool(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
int bus_property_set_bool(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *value, void *userdata, sd_bus_error *error);
int bus_property_get_tristate(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
#define BUS_PROPERTY_DUAL_TIMESTAMP(name, offset, flags) \
SD_BUS_PROPERTY(name, "t", bus_property_get_usec, (offset) + offsetof(struct dual_timestamp, realtime), (flags)), \
SD_BUS_PROPERTY(name "Monotonic", "t", bus_property_get_usec, (offset) + offsetof(struct dual_timestamp, monotonic), (flags))
+
+/* For deprecated properties. */
+int bus_property_get_bool_false(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
+int bus_property_get_bool_true(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
+int bus_property_get_uint64_max(sd_bus *bus, const char *path, const char *interface, const char *property, sd_bus_message *reply, void *userdata, sd_bus_error *error);
SD_VARLINK_DEFINE_FIELD(DefaultRestartUSec, SD_VARLINK_INT, 0),
SD_VARLINK_FIELD_COMMENT("https://www.freedesktop.org/software/systemd/man/"PROJECT_VERSION_STR"/systemd-system.conf.html#DefaultStartLimit="),
SD_VARLINK_DEFINE_FIELD_BY_TYPE(DefaultStartLimit, RateLimit, SD_VARLINK_NULLABLE),
- SD_VARLINK_FIELD_COMMENT("https://www.freedesktop.org/software/systemd/man/"PROJECT_VERSION_STR"/systemd-system.conf.html#DefaultCPUAccounting="),
- SD_VARLINK_DEFINE_FIELD(DefaultCPUAccounting, SD_VARLINK_BOOL, 0),
SD_VARLINK_FIELD_COMMENT("https://www.freedesktop.org/software/systemd/man/"PROJECT_VERSION_STR"/systemd-system.conf.html#DefaultIOAccounting="),
SD_VARLINK_DEFINE_FIELD(DefaultIOAccounting, SD_VARLINK_BOOL, 0),
SD_VARLINK_FIELD_COMMENT("https://www.freedesktop.org/software/systemd/man/"PROJECT_VERSION_STR"/systemd-system.conf.html#DefaultIPAccounting="),
_cleanup_(manager_freep) Manager *m = NULL;
Unit *son, *daughter, *parent, *root, *grandchild, *parent_deep, *nomem_parent, *nomem_leaf;
int r;
- CGroupMask cpu_accounting_mask = get_cpu_accounting_mask();
r = enter_cgroup_subroot(NULL);
if (r == -ENOMEDIUM)
/* Turn off all kinds of default accounting, so that we can
* verify the masks resulting of our configuration and nothing
* else. */
- m->defaults.cpu_accounting =
- m->defaults.memory_accounting =
+ m->defaults.memory_accounting =
m->defaults.io_accounting =
m->defaults.tasks_accounting = false;
m->defaults.tasks_max = CGROUP_TASKS_MAX_UNSET;
/* Verify per-unit cgroups settings. */
ASSERT_CGROUP_MASK_JOINED(unit_get_own_mask(son), CGROUP_MASK_CPU);
- ASSERT_CGROUP_MASK_JOINED(unit_get_own_mask(daughter), cpu_accounting_mask);
ASSERT_CGROUP_MASK_JOINED(unit_get_own_mask(grandchild), 0);
ASSERT_CGROUP_MASK_JOINED(unit_get_own_mask(parent_deep), CGROUP_MASK_MEMORY);
ASSERT_CGROUP_MASK_JOINED(unit_get_own_mask(parent), (CGROUP_MASK_IO | CGROUP_MASK_BLKIO));
ASSERT_CGROUP_MASK_JOINED(unit_get_members_mask(daughter), 0);
ASSERT_CGROUP_MASK_JOINED(unit_get_members_mask(grandchild), 0);
ASSERT_CGROUP_MASK_JOINED(unit_get_members_mask(parent_deep), 0);
- ASSERT_CGROUP_MASK_JOINED(unit_get_members_mask(parent), (CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_MEMORY));
+ ASSERT_CGROUP_MASK_JOINED(unit_get_members_mask(parent), (CGROUP_MASK_CPU | CGROUP_MASK_MEMORY));
ASSERT_CGROUP_MASK_JOINED(unit_get_members_mask(nomem_parent), (CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY));
ASSERT_CGROUP_MASK_JOINED(unit_get_members_mask(nomem_leaf), 0);
- ASSERT_CGROUP_MASK_JOINED(unit_get_members_mask(root), (CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY));
+ ASSERT_CGROUP_MASK_JOINED(unit_get_members_mask(root), (CGROUP_MASK_CPU | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY));
/* Verify aggregation of sibling masks. */
- ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(son), (CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_MEMORY));
- ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(daughter), (CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_MEMORY));
+ ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(son), (CGROUP_MASK_CPU | CGROUP_MASK_MEMORY));
+ ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(daughter), (CGROUP_MASK_CPU | CGROUP_MASK_MEMORY));
ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(grandchild), 0);
- ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(parent_deep), (CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_MEMORY));
- ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(parent), (CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY));
+ ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(parent_deep), (CGROUP_MASK_CPU | CGROUP_MASK_MEMORY));
+ ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(parent), (CGROUP_MASK_CPU | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY));
ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(nomem_parent), (CGROUP_MASK_CPU | CGROUP_MASK_CPUACCT | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY));
ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(nomem_leaf), (CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY));
- ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(root), (CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY));
+ ASSERT_CGROUP_MASK_JOINED(unit_get_siblings_mask(root), (CGROUP_MASK_CPU | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY));
/* Verify aggregation of target masks. */
- ASSERT_CGROUP_MASK(unit_get_target_mask(son), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_MEMORY) & m->cgroup_supported));
- ASSERT_CGROUP_MASK(unit_get_target_mask(daughter), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_MEMORY) & m->cgroup_supported));
+ ASSERT_CGROUP_MASK(unit_get_target_mask(son), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | CGROUP_MASK_MEMORY) & m->cgroup_supported));
+ ASSERT_CGROUP_MASK(unit_get_target_mask(daughter), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | CGROUP_MASK_MEMORY) & m->cgroup_supported));
ASSERT_CGROUP_MASK(unit_get_target_mask(grandchild), 0);
- ASSERT_CGROUP_MASK(unit_get_target_mask(parent_deep), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_MEMORY) & m->cgroup_supported));
- ASSERT_CGROUP_MASK(unit_get_target_mask(parent), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY) & m->cgroup_supported));
+ ASSERT_CGROUP_MASK(unit_get_target_mask(parent_deep), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | CGROUP_MASK_MEMORY) & m->cgroup_supported));
+ ASSERT_CGROUP_MASK(unit_get_target_mask(parent), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY) & m->cgroup_supported));
ASSERT_CGROUP_MASK(unit_get_target_mask(nomem_parent), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | CGROUP_MASK_CPUACCT | CGROUP_MASK_IO | CGROUP_MASK_BLKIO) & m->cgroup_supported));
ASSERT_CGROUP_MASK(unit_get_target_mask(nomem_leaf), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_IO | CGROUP_MASK_BLKIO) & m->cgroup_supported));
- ASSERT_CGROUP_MASK(unit_get_target_mask(root), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY) & m->cgroup_supported));
+ ASSERT_CGROUP_MASK(unit_get_target_mask(root), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY) & m->cgroup_supported));
/* Verify aggregation of enable masks. */
ASSERT_CGROUP_MASK(unit_get_enable_mask(son), 0);
ASSERT_CGROUP_MASK(unit_get_enable_mask(daughter), 0);
ASSERT_CGROUP_MASK(unit_get_enable_mask(grandchild), 0);
ASSERT_CGROUP_MASK(unit_get_enable_mask(parent_deep), 0);
- ASSERT_CGROUP_MASK(unit_get_enable_mask(parent), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_MEMORY) & m->cgroup_supported));
+ ASSERT_CGROUP_MASK(unit_get_enable_mask(parent), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | CGROUP_MASK_MEMORY) & m->cgroup_supported));
ASSERT_CGROUP_MASK(unit_get_enable_mask(nomem_parent), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_IO | CGROUP_MASK_BLKIO) & m->cgroup_supported));
ASSERT_CGROUP_MASK(unit_get_enable_mask(nomem_leaf), 0);
- ASSERT_CGROUP_MASK(unit_get_enable_mask(root), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | cpu_accounting_mask | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY) & m->cgroup_supported));
+ ASSERT_CGROUP_MASK(unit_get_enable_mask(root), (CGROUP_MASK_EXTEND_JOINED(CGROUP_MASK_CPU | CGROUP_MASK_IO | CGROUP_MASK_BLKIO | CGROUP_MASK_MEMORY) & m->cgroup_supported));
return 0;
}
(! grep -r "IPAccounting=" "/etc/systemd/system.control/${UNIT_NAME}.d/")
(! grep -r "MemoryMax=" "/etc/systemd/system.control/${UNIT_NAME}.d/")
# Same stuff, but with --runtime, which should use /run
-systemctl set-property --runtime "$UNIT_NAME" CPUAccounting=no CPUQuota=10%
+systemctl set-property --runtime "$UNIT_NAME" IOAccounting=no CPUQuota=10%
systemctl cat "$UNIT_NAME"
-grep -r "CPUAccounting=no" "/run/systemd/system.control/${UNIT_NAME}.d/"
+grep -r "IOAccounting=no" "/run/systemd/system.control/${UNIT_NAME}.d/"
grep -r "CPUQuota=10.00%" "/run/systemd/system.control/${UNIT_NAME}.d/"
systemctl revert "$UNIT_NAME"
-(! grep -r "CPUAccounting=" "/run/systemd/system.control/${UNIT_NAME}.d/")
+(! grep -r "IOAccounting=" "/run/systemd/system.control/${UNIT_NAME}.d/")
(! grep -r "CPUQuota=" "/run/systemd/system.control/${UNIT_NAME}.d/")
# Failed-unit related tests
Description=Test slice for memory pressure kills
[Slice]
-CPUAccounting=true
MemoryAccounting=true
IOAccounting=true
TasksAccounting=true
Slice=parent.slice
Type=oneshot
ExecStart=true
-CPUAccounting=true
projects / thirdparty / systemd.git / commitdiff
