Add link to constellation mkosi blog post

Add link to "Building USIs with mkosi" blog post

Update NEWS

Use $PACKAGEDIR when building mkosi rpm

Cache depmod again

Let's run depmod before we cache our images so that we can skip it
when doing incremental builds for kernels installed with the package
manager. depmod is noticeably slow so this speeds up kernel builds a
bit.

Fix shim signing bug

sign_efi_binary() expects the full output path.

Merge pull request #2291 from DaanDeMeyer/stuff

kernel-install: Build microcode initrd

kernel-install: Build microcode initrd

Let's make sure we build a microcode initrd as well in the
kernel-install plugin. It's a bit too complicated to reuse
the build_microcode_initrd() function we have already due to
sandboxing so we opt to duplicate it instead.

Make archive.py independent of Context

Let's make these functions slightly more generic by passing in a
tools directory and a sandbox instead of the full Context object.

Make sure we open Packages output location in binary mode

Use stdin/stdout for cpio/tar

Let's reduce the amount of stuff we have to mount in the sandbox
by making use of stdin/stdout when invoking cpio/tar.

Merge pull request #2289 from DaanDeMeyer/news

Update NEWS

Don't include root password in /usr/lib/credstore

Update NEWS

Merge pull request #2287 from DaanDeMeyer/stuff

Package manager improvements

Add PackageDirectories=

Let's make it possible to serve local packages as a local repository
so that users don't have to put local paths in their Packages= setting.
We'll also allow adding more packages to this local repository in the
build script so that these can be installed in the initrd when we build
it or in a postinst or finalize script.

Mount package manager caches to their canonical locations

Let's reduce the amount of configuration by mounting package
manager caches to their canonical locations.

Replace flatten() with format string

Use context.pkgmngr in one more place

Mount package manager cache directories when running scripts

When running package managers in host scripts we want the cache
to be available as well;

Put --mirror in cache manifest

Fix --mirror for CentOS and Fedora

Let's unify the interface for --mirror and only require users to
specify a url and add the entire path ourselves in mkosi. This is
required to use EPEL repositories with --mirror= as the epel
repositories are mirrored under <url>/fedora/epel whereas the CentOS
Stream repositories are under <url>/centos-stream

ci: Enable Arch Linux tools tree CI again

The required qemu fix was backported to the qemu package.

Generate more strict regexes from loaded modules

Let's only match actual modules ending in .ko.

fedora: Don't download filelists

Fixes a bug introduced in c1bef56eafb6809a91816c3c17e57050c1724fc4.

Merge pull request #2285 from DaanDeMeyer/tmpfiles

Run systemd-tmpfiles as part of the build

Run systemd-tmpfiles as part of the build

Let's make sure we take user provided tmpfiles snippets into account
as well. Since systemd now mounts the initramfs read-only by default,
we need to make sure all tmpfiles snippets that copy to /etc have
already been processed during the image build itself as they won't be
able to run during the initramfs stage.

Use 1. for ordered list

The actual number used doesn't matter, so just use 1. everywhere.

Skip normalize_mtime() if the directory does not exist

Merge pull request #2283 from DaanDeMeyer/arch

Make sure /etc/mtab exists in sandbox

Make sure /etc/mtab exists in sandbox

Required for pacman's CheckSpace option. To avoid messing with the
package manager tree /etc too much, we bind mount individual
subdirectories of it instead of the entire directory.

Merge pull request #2279 from DaanDeMeyer/rpm-build

Drop rpm-build from 30-rpm default image config

Make sure we don't build the same tools tree more than once

We can do this by simply checking if the output path already exists
instead of relying on needs_build(). This allows us to refactor
needs_build() to needs_clean(). We also move some prechecks into
run_build() and run_clean() so as to not duplicate them and improve
the logging messages in run_clean().

Fixes #2280

Be more careful with mounting /etc/alternatives in relaxed mode

Otherwise we might end up trying to create a mountpoint in the host's
/etc.

Add BuildSources=. to the default image configuration

If we enable the rpm build, we set BuildSources= which means we
override the default build sources. However we still want the source
directory to be used as BuildSources= as well, so configure it explicitly.

Simplify run_prepare_scripts()

Make it look more like the other script functions.

Use finalize_ephemeral_source_mounts() for package managers as well

Otherwise we'll still  create mountpoints in the actual source
directories when using nested build sources.

Drop rpm-build from 30-rpm default image config

We already install it unconditionally these days.

Release 20.1

Add note on BuildSources= being required to install local packages.

Verify that output path is not a symlink in needs_build()

Otherwise if we first build a disk image and then try to run
"mkosi -t directory qemu" we won't actually rebuild the image as it
will think the output already exists and we'll try to boot a disk
image as a directory.

Update NEWS

Merge pull request #2275 from DaanDeMeyer/selinux

Improve SELinux binary policy selection

Add debug log when we don't add microcode initrd

Allow gpg access to /run/pscsd/pscsd.comm on the host if it exists

This is required for gpg to communicate with pscsd for interaction
with smartcards so let's mount it in if it exists.

Improve SELinux binary policy selection

Let's deal with the possibility that there might be more than one
policy in the binary policy directory. Let's also make sure that we
consider other files in the directory that might not be policies.

Populate only using the archlinux keyring

Otherwise on Debian and Ubuntu we end up adding the Debian/Ubuntu
keyrings as well which is useless and slows down builds.

Merge pull request #2271 from DaanDeMeyer/fix

Two fixes

Use grub binaries from tools tree instead of from image

Let's give this another try and use grub tools from the tools tree
instead of from the image.

We also hardcode the grub prefix per distribution because if we use
grub binaries from the tools tree there might not be any installed
in the image itself which means we can't derive the prefix from the
binaries in the image.

Use default_factory for tools tree options defaults

Silence mkfs.erofs in CI

It prints a line for each file included in the image when connected
to a pipe which is extremely noisy so silence it.

Prefer qemu-system-xxx binaries

The qemu and qemu-kvm binaries are just shorthands for specific configs.
Let's prefer the actual binaries over the shorthands.

Log before going into debug shell

Fixes #2269

Check for all required setfiles inputs in want_selinux_relabel()

On Debian when policycoreutils is installed a policy is configured
without a matching binary policy being installed, so we have to
check that all parts are there.

Skip caching if Overlay= is enabled

When Overlay= is enabled we can't do Incremental= caching so skip
save_cache() if Overlay= is enabled.

Copy nspawn settings to the output directory again

machinectl pull-tar looks for a settings file so let's make sure
the output directory can be used directly for this purpose by copying
the nspawn settings file to the output directory again.

Merge pull request #2263 from DaanDeMeyer/fix

Fix invoked_as_root initialization

Actually call configure_extension_release()

Fix invoked_as_root check

Merge pull request #2262 from DaanDeMeyer/sources

Mount BuildSources= when executing package managers

Use the directory mkosi was invoked in as the default for BuildSources=

While parsing config, we use chdir(). Also, when a BuildSources=
match is found, BuildSources= is initialized to its default value
which is Path.cwd(). However, we want the default value to be the
top level directory that mkosi was invoked in, not the current working
directory that we happen to be in while parsing configuration. Let's
fix this by using the directory mkosi was invoked in instead of Path.cwd().

Mount in local mirror if it is provided.

Mount BuildSources= when executing package managers

Users might have local packages which need to be mounted into the
sandbox as well. Let's make this possible by using BuildSources=.

NEWS: reword a sentence and add punctuation

Fix typos in manpage

Release 20

Make sure SYSTEMD_REPART_MKFS_OPTIONS_<fs> always applies

Let's make sure we always use the extra mkfs options configured in
these environment variables.

We also stop filtering the environment we pass to systemd-repart.

Only run mount --make-rslave / if we didn't unshare a user namespace

When unsharing a mount namespace in a different user namespace than
the parent mount namespace, all mounts are marked as slave by default
so we don't need to explicitly mark all of them as slave mounts.

Merge pull request #2258 from DaanDeMeyer/policycoreutils

Add policycoreutils to tools trees

Add policycoreutils to tools trees

This package provides setfiles which is required for selinux
relabeling.

Add Ubuntu to tools trees docs packages list

Merge pull request #2255 from DaanDeMeyer/simplify

Simplify apivfs_cmd() and chroot_cmd()

Unshare IPC namespace when not in relaxed mode

Otherwise tests in the sandbox will think they have access to IPC
stuff when they actually don't.

Fixes #2256

Only set --security-label if the filesystem was relabeled

Otherwise we run into virtiofsd errors when operating on non relabeled
directories with --security-label enabled.

Simplify apivfs_cmd() and chroot_cmd()

We move the setpgid logic to run(), avoiding the need to pass a tools
argument to chroot_cmd() and apivfs_cmd().

We also try to remove as much logic from these functions as possible.
Since we can't really assume that any logic we execute during the
function will still hold true in the sandbox, so it's best to delay
any logic execution until we're already in the sandbox (using the
--ro-bind-try options of bubblewrap).

We also rework the /etc/resolv.conf handling to simply make sure that
/run/systemd/resolve exists in the chroot since if /etc/resolv.conf
points to /run it'll almost certainly be to
/run/systemd/resolv/stub-resolv.conf.

Bind mount /work into chroot instead of individual files/directories

Same effect with less code.

Merge pull request #2253 from DaanDeMeyer/fix

More sandboxing fixes

Use /work for host scripts as well

Now that everything runs sandboxed, /work is free to use for host
scripts as well. At the same time, let's stop unconditionally
mounting the current working directory when running build scripts.

To keep things working smoothly, we'll make mounting the current
working directory the default value for BuildSources= instead.

Reset default values when assigning the empty string to list setting

For list based settings, it makes more sense for the empty string
to get rid of any default value as well.

Change directory to the root directory in Mkosi.default()

Let's make sure subsequent invocations of Mkosi.default() return
the same value even if we default some settings to the current
working directory.

debian: Use ?exact-name() instead of ?name()

Always use /var/tmp in apivfs_cmd()

apivfs_cmd() is always executed from within a sandbox so we can
just reuse the sandboxes /var/tmp.

Don't use host's /var/tmp in sandbox

Instead, use a subdirectory of the host's /var/tmp. Because we want
to limit the lifetime of this directory to the lifetime of the sandbox,
we use a shell command to create and remove the directory.

Put tmpfs on /tmp in sandbox when not in relaxed mode

Let's sandbox more by not using the host's /tmp but instead putting
a fresh tmpfs on /tmp. We used the host's /tmp before because the
definitions could potentially be in the host's /tmp but now that we
mount everything in explicitly that isn't a problem anymore.

Mount cache directory before all other mounts

The cache directory could potentially be /var so to avoid overriding
other mounts we have to mount it first.

Only mount package manager specific directories into sandbox

Don't rely on /tmp being mounted into the sandbox

Let's not rely on /tmp implicitly being mounted in the sandbox.

Merge pull request #2252 from DaanDeMeyer/ci

ci: Enable Debian builds with tools trees again

Fix grub sandboxing

Remove a few TODOs and FIXMEs

debian: Use testing again instead of unstable for default image

systemd v255 is now in testing so let's use testing again instead
of unstable.

ci: Enable Debian builds with tools trees again

The required fix in systemd is now in Debian so let's try enabling
these again.

Mount certificate directories into curl sandbox

curl needs access to certificates to do its job so mount them in.

Merge pull request #2250 from DaanDeMeyer/fix

sandbox: Only mount host dirs that exist

Start virtiofsd with --security-label

This makes sure selinux relabeling works as expected when booting
off virtiofs

Mount /sys, /run and /dev in relaxed mode as well

Only mount /etc/resolv.conf into sandbox if not in relaxed mode

In relaxed mode we already mount /etc so no need to mount resolv.conf
separately.

sandbox: Only mount host dirs that exist

Update NEWS

Use bubblewrap to set up the tools tree instead of doing it ourselves

The problem with overmounting the host's /usr (in a private mount
namespace) is that we have no control over the symlinks in the root
directory (/lib, /bin, /lib64) and if these symlinks don't match
between the host distribution and the tools tree distribution, all
kinds of weird breakage starts happening. For example, using Fedora
tools trees on Arch Linux is currently broken because /lib64 on Arch
Linux points to /usr/lib whereas on Fedora it points to /usr/lib64.

Because we can't (and shouldn't) modify the symlinks of the host's
root filesystem, we need to set up the tools tree in a sandbox that
we chroot into, so that we have full control over the rootfs of the
sandbox and can make sure the symlinks are correct. Luckily, we
already do just that with bubblewrap, except that currently we mount
the tools tree over /usr ourselves and then just carry that over into
the bubblewrap sandbox.

Instead, we stop mounting over the host's /usr ourselves and have
bubblewrap pick the right /usr itself. We also copy the symlinks from
the tools tree or the host if there is no tools tree.

Because we don't mount over the host's /usr anymore, we have to run
every tool that should come from the tools tree with bubblewrap now.
The side effect of this is that almost all of our tools now run
sandboxed. We also have to make use of find_binary() everywhere
instead of shutil.which() to make sure we look for binaries in the
tools tree when required. Various other codepaths that look into /usr
also have to be modified to look into the tools tree when needed.

Also, because we don't unshare the user namespace in the main mkosi
process anymore now, we can get rid of a lot of chown()'s in qemu.py
and opening the qemu device file descriptors can be moved into
run_qemu() itself.

We also don't have to make sure all python modules are loaded anymore
as the host's /usr is never overmounted so the required python modules
will be available for the entire runtime of the mkosi process.

Because virtiofsd is now executed with bubblewrap, we use bubblewrap
to set up the required uidmap instead of relying on virtiofsd to do it
with newuidmap/newgidmap. Note that this breaks RuntimeTrees= as
virtiofsd unconditionally tries to drop groups with setgroups() which
fails with EPERM in an unprivileged user namespace set up by bubblewrap.
This is fixed by https://gitlab.com/virtio-fs/virtiofsd/-/merge_requests/207
which is still awaiting review.

To make this work codewise, this commit renames the bwrap() function
to sandbox_cmd() (similar to chroot_cmd() and apivfs_cmd()) which now
returns a command line instead of executing the command itself. run()
is modified to take an extra "sandbox" arguments which is simply the
part of the full command that sets up the sandbox. Context and Config
both learn new sandbox() methods which set up the sandbox for each
object respectively (mostly by adding extra bind mounts).

Because almost every call to run() now takes a sandbox, this gives us
a lot of control over the individual environment for each tool we run.
We make use of this to restrict each tool we run to the minimal possible
sandbox that that tool needs to run. By specifically mounting in the
required paths for each tool we run, we also make sure these are always
available instead of relying that somewhere we mount a path that has the
input in it.

Because we allow passing arbitrary options to mkosi qemu, mkosi boot and
various other verbs, we run these verbs with a relaxed sandbox, where we
mount in most directories from the host. This means that whatever
directories users specify will be available.

In terms of CI, the extra sandboxing means that our previous approach of
building various systemd binaries from source and symlinking them to
/usr/bin doesn't work anymore. Instead, we opt to always use tools trees
and drop the host builds from the testing matrix. This also simplifies
and speeds up the github action as we don't have to compile systemd and
xfsprogs from source and we have to install fewer packages.