Merge pull request #10894 from poettering/root-cgroup-fix

A multitude of cgroup fixes

update TODO

tests: add a fuzzer for the udev rules parser (#10929)

Merge pull request #10926 from AsciiWolf/copyright

Drop my copyright

mkosi: drop my copyright

po: drop my copyright (cs.po)

hwdb: Add ACCEL_MOUNT_MATRIX for Trekstor T13B tablet

units: order systemd-rfkill.socket after /var/lib/systemd/rfkill (#10904)

Otherwise we might install the socket unit early, but the service
backing it late, and then end up in strange loops when we enter rescue
mode, because we saw an event on /dev/rfkill but really can't dispatch
it nor flush it.

Fixes: #9171

tests: skip test-execute on TravisCI under ASan

Unfortunately, f5f9a580dd4a3cf487b didn't help much and now
the next subtest gets stuck from time to time. Let's skip
test-execute altogether so as not to bother anybody with
spurious failures.

https://github.com/systemd/systemd/issues/10696 is still open.
Everybody is welcome to share ideas :-)

Fix a few docs typos (#10907)

Found with [codespell](https://github.com/codespell-project/codespell)

Fix typo in hacking guide: "no possible" -> "not possible" (#10905)

analyze: Fix build without seccomp (#10899)

tests: add a fuzzer for server_process_native_file

dhcp6-client: handle IAID with value zero

config_parse_iaid(), dhcp_identifier_set_iaid() and sd_dhcp6_client_set_iaid() all
allow for the IAID to be zero. Also, RFC 3315 makes no mention that zero
would be invalid.

However, client_ensure_iaid() would take an IAID of zero as a sign that
the values was unset. Fix that by keeping track whether IAID is
initialized.

Merge pull request #10887 from poettering/run-love

systemd-run: modernizations, some new switches and let's set $INVOCATION_ID

Merge pull request #10893 from keszybz/udev-cleanup-followup

Udev cleanup follow-ups

test: extend testcase to ensure controller membership doesn't regress

cgroup: when we unload a unit, also update all its parent's members mask

This way we can corectly ensure that when a unit that requires some
controller goes away, we propagate the removal of it all the way up, so
that the controller is turned off in all the parents too.

cgroup: drastically simplify caching of cgroups members mask

Previously we tried to be smart: when a new unit appeared and it only
added controllers to the cgroup mask we'd update the cached members mask
in all parents by ORing in the controller flags in their cached values.
Unfortunately this was quite broken, as we missed some conditions when
this cache had to be reset (for example, when a unit got unloaded),
moreover the optimization doesn't work when a controller is removed
anyway (as in that case there's no other way for the parent to iterate
though all children if any other, remaining child unit still needs it).
Hence, let's simplify the logic substantially: instead of updating the
cache on the right events (which we didn't get right), let's simply
invalidate the cache, and generate it lazily when we encounter it later.
This should actually result in better behaviour as we don't have to
calculate the new members mask for a whole subtree whever we have the
suspicion something changed, but can delay it to the point where we
actually need the members mask.

This allows us to simplify things quite a bit, which is good, since
validating this cache for correctness is hard enough.

Fixes: #9512

cgroup: extend comment on what unit_release_cgroup() is for

cgroup: extend reasons when we realize the enable mask

After creating a cgroup we need to initialize its
"cgroup.subtree_control" file with the controllers its children want to
use. Currently we do so whenever the mkdir() on the cgroup succeeded,
i.e. when we know the cgroup is "fresh". Let's update the condition
slightly that we also do so when internally we assume a cgroup doesn't
exist yet, even if it already does (maybe left-over from a previous
run).

This shouldn't change anything IRL but make things a bit more robust.

cgroup: tighten call that detects whether we need to realize a unit's cgroup a bit, and comment why

cgroup: document what the various masks variables are used for

cgroup: extend cg_mask_supported() comment a bit

cgroup: simplify check whether it makes sense to realize a cgroup

cgroup: in unit_invalidate_cgroup() actually modify invalidation mask

Previously this would manipulate the realization mask for invalidating
the realization. This is a bit ugly though as the realization mask's
primary purpose to is to reflect in which hierarchies a cgroup currently
exists, and it's probably a good idea to keep that in sync with
realities.

We nowadays have the an explicit fields for invalidating cgroup
controller information, the "cgroup_invalidated_mask", let's use this
one instead.

The effect is pretty much the same, as the main consumer of these masks
(unit_has_mask_realize()) checks both anyway.

cgroup: be more careful with which controllers we can enable/disable on a cgroup

This changes cg_enable_everywhere() to return which controllers are
enabled for the specified cgroup. This information is then used to
correctly track the enablement mask currently in effect for a unit.
Moreover, when we try to turn off a controller, and this works, then
this is indicates that the parent unit might succesfully turn it off
now, too as our unit might have kept it busy.

So far, when realizing cgroups, i.e. when syncing up the kernel
representation of relevant cgroups with our own idea we would strictly
work from the root to the leaves. This is generally a good approach, as
when controllers are enabled this has to happen in root-to-leaves order.
However, when controllers are disabled this has to happen in the
opposite order: in leaves-to-root order (this is because controllers can
only be enabled in a child if it is already enabled in the parent, and
if it shall be disabled in the parent then it has to be disabled in the
child first, otherwise it is considered busy when it is attempted to
remove it in the parent).

To make things complicated when invalidating a unit's cgroup membershup
systemd can actually turn off some controllers previously turned on at
the very same time as it turns on other controllers previously turned
off. In such a case we have to work up leaves-to-root *and*
root-to-leaves right after each other. With this patch this is
implemented: we still generally operate root-to-leaves, but as soon as
we noticed we successfully turned off a controller previously turned on
for a cgroup we'll re-enqueue the cgroup realization for all parents of
a unit, thus implementing leaves-to-root where necessary.

pid1,sd-device: use PATH_STARTSWITH_SET more

basic/path-util: add missing header

PATH_STARTSWITH_SET uses STRV_FOREACH...

run: set $INVOCATION_ID for scope units

Services invoked by PID1 have $INVOCATION_ID initialized, hence let's do
that for scope units (where the payload process is invoked by us on the
client side) too, to minimize needless differences.

Fixes: #8082

run: port to static destructors

run: port to DEFINE_MAIN_FUNCTION()

run: add new --shell switch for spawning a shell as service

I keep running "systemd-run -t /bin/bash" to quickly get a shell running
in service context. I suspect I am not the only one, hence let's add a
shortcut for it. While we are at it, let's make it smarter, and
automatically inherit the $SHELL of the invoking user as well as the
working directory, and let's imply --pty. --shell (or -S) is hence
equivalent to "-t -d $SHELL".

run: add a switch for specifiying the working directory of a service

I find myself testing service management quite often with "systemd-run
-t /bin/bash". For that it is handy if the invoked shell would use the
working directory I am currently in. Hence introduce a shorthand for
that:

        $ systemd-run -dt /bin/bash

This will automatically insert a WorkingDirectory= property into the
transient service, pointing to the working directory of the caller.

cgroup: tweak log message, so that it doesn't claim we always enable controllers when we actually disable them

cgroup: propagate errors when we cannot open cgroup.subtree_control

cgroup: add explanatory comment

cgroup: units that aren't loaded properly should not result in cgroup controllers being pulled in

This shouldn't make much difference in real life, but is a bit cleaner.

cgroup: dump delegation mask too

cgroup: make unit_get_needs_bpf_firewall() static too

cgroup: make some functions static

cgroup: fine tune when to apply cgroup attributes to the root cgroup

Let's tweak when precisely to apply cgroup attributes on the root
cgroup.

With this we now follow the following rules:

1. On cgroupsv2 we never apply any regular cgroups to the host root,
   since the attributes generally do not exist there.

2. On cgroupsv1 we do not apply any "weight" or "shares" style
   attributes to the host root cgroup, since they don't make much sense
   on the top level where there's only one group, hence no need to
   compare weights against each other. The other attributes are applied
   to the host root cgroup however.

3. In any case we don't apply attributes to the root of container
   environments (and --user roots), under the assumption that this is
   managed by the manager further up. (Note that on cgroupsv2 this is
   even enforced by the kernel)

4. BPF pseudo-attributes are applied in all cases (since we can have as
   many of them as we want)

cgroup: append \n to static strings we write to cgroup attributes

This is a bit cleaner since we when we format numeric limits we append
it. And this way write_string_file() doesn't have to append it.

cgroup: tighten manager_owns_host_root_cgroup() a bit

This tightening is not strictly necessary (as the m->cgroup_root check
further down does the same), but let's make this explicit.

cgroup: rename {manager_owns|unit_has}_root_cgroup() → .._host_root_cgroup()

Let's emphasize that this function checks for the host root cgroup, i.e.
returns false for the root cgroup when we run in a container where
CLONE_NEWCGROUP is used. There has been some confusion around this
already, for example cgroup_context_apply() uses the function
incorrectly (which we'll fix in a later commit).

Just some refactoring, not change in behaviour.

cgroup: add a common routine for writing to attributes, and logging about it

We can use this at quite a few places, and this allows us to shorten our
code quite a bit.

cgroup: add a new macro for determining log level for cgroup attr write failures

For now, let's use it only at one place, but a follow-up commit will
make more use of it.

cgroup: ignore EPERM for a couple of more attribute writes

cgroup: add comment explaining why we ignore EINVAL at two places

These are just copies from further down.

cgroup: suffix settings with "=" in log messages where appropriate

cgroup: only install cgroup release agent when we own the root cgroup

If we run in a container we shouldn't patch around this, and most likely
we can't anyway, and there's not much point in complaining about this.
Hence let's strictly say: the agent is private property of the host's
system instance, nothing else.

cgroup: use structured initialization

libudev: drop unnecessary check

sd_device_get_subsystem returns -ENOENT if subsystem is not set.

Merge pull request #10861 from yuwata/udev-list-cleanups

libudev: several cleanups for udev-list

Merge pull request #10886 from yuwata/sd-device-monitor-fix-filter

sd-device: fix subsystem filter

unit: minor optimization, use stack over heap, when we can

70-mouse.hwdb: Set DPI for MS Classic IntelliMouse

It defaults to 3200 DPI and 1000 Hz. Note the ?? is required to
match the multibyte UTF-8 character '®'.

Merge pull request #10891 from yuwata/use-main-macro-2

tree-wide: use recently introduced macros

unit: drop an unused fields from Unit struct

test: add more tests for subsystem filter

core: add two minor comments (#10890)

locale: define main through macro

locale: store polkit_registry in Context

locale: rename context_free() to context_clear()

resolvectl: use static destructor and define main through macro

rfkill: define main through macro

rfkill: store write queue and rfkill fd in struct Context

socket-proxy: define main through macro

sysusers: use ordered_hashmap_steal_first_key_and_value()

time-wait: define main through macro

timedate: define main through macro

update-done: quit earlier on failure

update-utmp: use _cleanup_ attribute to finalize process

veritysetup-generator: use static destructors and define main through macro

veritysetup-generator: make arg_dest const

veritysetup: use static destructors and define main through macro

This also changes the return value when crypt_init_by_name() fails in 'detach'.

tests: add a fuzzer for catalog_import_file

man: update description of Description=

The way this is used drifted a bit from the original intent. Let's update
the description and add some examples to inspire people to texts that look
less bad during initial boot.

Merge pull request #10884 from yuwata/udev-debug

meson: add more debug options

sd-device-monitor: fix subsystem filter

This fixes a bug introduced by 759d9f3f8d07af2940bb3783acc3985ee47adfa5.

Fixes #10882.

udev-rules: update log messages

meson: also add option for debugging siphash

meson: add option for debugging udev

udev-rules: trivial coding style cleanups

udev: rename udev_rules_unref() to udev_rules_free()

As udev_rules do not have a reference counter.

libudev: do not ignore error in udev_list_entry_add()

libudev: introduce return_with_errno() and use it where applicable

test: add tests for libudev-list

libudev-list: drop unused udev argument from udev_list_init()

libudev-list: drop unused private functions

Merge pull request #10871 from keszybz/more-cleanup-2

Allow "synthetic" errno to be used in log calls

sysctl: when debug logging about sysctl changes, truncate trailing newline

basic/log: add note about operator precendence

CODING_STYLE: describe log & return operations

Also drop a few more unnecessary uses of synthethic errno

coccinelle: also mark previous synthetic errnos as such

coccinelle: make use of SYNTHETIC_ERRNO

Ideally, coccinelle would strip unnecessary braces too. But I do not see any
option in coccinelle for this, so instead, I edited the patch text using
search&replace to remove the braces. Unfortunately this is not fully automatic,
in particular it didn't deal well with if-else-if-else blocks and ifdefs, so
there is an increased likelikehood be some bugs in such spots.

I also removed part of the patch that coccinelle generated for udev, where we
returns -1 for failure. This should be fixed independently.

basic/log: add concept of "synthethic errnos"

Synthetic errnos are processed like normal, and may be used in %m and become
the return value from log_*(), but they are not logged in the journal.

vconsole: Don't skip udev call for dummy device

Kernel 4.19 supports deferred console takeover [0], i.e., fbcon will
take over the console only when the first text is displayed on the
console. Before that event, only the dummy console is active. Our
currently udev rules call systemd-vconsole on every vtcon except for
dummy consoles. Thus the exception for dummy consoles prevents a call
to systemd-vconsole when no text is displayed on the console, and as a
consequence, the keymap will not be set in that case. This is wrong and
leads to issues when keyboard input is expected without text on the
console, e.g., when a graphical password prompt is used in the boot
process.

This reverts commit 6b169c13ecf645a0a341f49b9dc2afb312a74206,
which introduced the exception for dummy devices to save unnecessary
udev calls.

Fixes #10826.

[0] https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=83d83bebf40132e2d55ec58af666713cc76f9764

basic/user-util: properly protect use of gshadow

Commit 100d5f6ee6 (user-util: add new wrappers for [...] database
files), ammended by commit 4f07ffa8f5 (Use #if instead of #ifdef for
ENABLE_GSHADOW) moved code from sysuser to basic/user-util.

In doing so, the combination of both commits properly propagated the
ENABLE_GSHADOW conditions around the function manipulating gshadow, but
they forgot to protect the inclusion of the gshadow.h header.

Fix that to be able to build on C libraries that do not provide gshadow
(e.g. uClibc-ng, where it does not exist.)