Merge 319c8e3189 into 0e445aaa85

Various integration test fixes

mkosi.images/system/mkosi.conf

@@ -57,6 +57,7 @@ Packages=
         opensc
         openssl
         p11-kit
+        pciutils
         python3
         qrencode
         radvd

src/basic/process-util.c

@@ -1457,11 +1457,20 @@ int safe_fork_full(
         sigset_t saved_ss, ss;
         _unused_ _cleanup_(restore_sigsetp) sigset_t *saved_ssp = NULL;
         bool block_signals = false, block_all = false, intermediary = false;
+        _cleanup_free_ char *prefixed_name = NULL;
         int prio, r;
 
         assert(!FLAGS_SET(flags, FORK_DETACH) || !ret_pid);
         assert(!FLAGS_SET(flags, FORK_DETACH|FORK_WAIT));
 
+        if (name && FLAGS_SET(flags, FORK_ARGV00_AT)) {
+                /* Optionally, ensure argv[0][0] is '@', in order to implement https://systemd.io/ROOT_STORAGE_DAEMONS */
+                prefixed_name = strjoin("@", name);
+                if (!prefixed_name)
+                        return -ENOMEM;
+                name = prefixed_name;
+        }
+
         /* A wrapper around fork(), that does a couple of important initializations in addition to mere forking. Always
          * returns the child's PID in *ret_pid. Returns == 0 in the child, and > 0 in the parent. */
 

src/basic/process-util.h

@@ -186,6 +186,7 @@ typedef enum ForkFlags {
         FORK_DETACH             = 1 << 18, /* Double fork if needed to ensure PID1/subreaper is parent */
         FORK_NEW_NETNS          = 1 << 19, /* Run child in its own network namespace                             💣 DO NOT USE IN THREADED PROGRAMS! 💣 */
         FORK_PACK_FDS           = 1 << 20, /* Rearrange the passed FDs to be FD 3,4,5,etc. Updates the array in place (combine with FORK_CLOSE_ALL_FDS!) */
+        FORK_ARGV00_AT          = 1 << 21, /* Prefix supplied name with '@', to exclude child process from final killing spree */
 } ForkFlags;
 
 int safe_fork_full(

src/core/unit.c

@@ -1402,11 +1402,13 @@ int unit_load_fragment_and_dropin(Unit *u, bool fragment_required) {
                 u->load_state = UNIT_LOADED;
         }
 
+        u = unit_follow_merge(u);
+
         /* Load drop-in directory data. If u is an alias, we might be reloading the
          * target unit needlessly. But we cannot be sure which drops-ins have already
          * been loaded and which not, at least without doing complicated book-keeping,
          * so let's always reread all drop-ins. */
-        r = unit_load_dropin(unit_follow_merge(u));
+        r = unit_load_dropin(u);
         if (r < 0)
                 return r;
 

src/partition/repart.c

@@ -2574,8 +2574,10 @@ static int context_load_partition_table(Context *context) {
                         /* If we found the sector size and we're operating on a block device, use it as the file
                          * system sector size as well, as we know its the sector size of the actual block device and
                          * not just the offset at which we found the GPT header. */
-                        if (r > 0 && S_ISBLK(st.st_mode))
+                        if (r > 0 && S_ISBLK(st.st_mode)) {
+                                log_debug("Probed sector size of %s is %" PRIu32 " bytes.", context->node, ssz);
                                 fs_secsz = ssz;
+                        }
                 }
 
                 r = fdisk_save_user_sector_size(c, /* phy= */ 0, ssz);
@@ -2639,7 +2641,7 @@ static int context_load_partition_table(Context *context) {
          * larger */
         grainsz = secsz < 4096 ? 4096 : secsz;
 
-        log_debug("Sector size of device is %lu bytes. Using grain size of %" PRIu64 ".", secsz, grainsz);
+        log_debug("Sector size of device is %lu bytes. Using filesystem sector size of %" PRIu64 " and grain size of %" PRIu64 ".", secsz, fs_secsz, grainsz);
 
         switch (arg_empty) {
 

src/shared/async.c

@@ -6,6 +6,7 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
+#include "argv-util.h"
 #include "async.h"
 #include "errno-util.h"
 #include "fd-util.h"
@@ -22,7 +23,14 @@ int asynchronous_sync(pid_t *ret_pid) {
          * original process ever, and a thread would do that as the process can't exit with threads hanging in blocking
          * syscalls. */
 
-        r = safe_fork("(sd-sync)", FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|(ret_pid ? 0 : FORK_DETACH), ret_pid);
+        /* Note that we set argv[0][0] = '@' here if we are called from PID 1, which tells the
+         * switch-root/soft-reboot/shutdown killing spree to leave this process around. After all the killing
+         * is likely not going to work anyway, and given the limited scope of the child it's really not worth
+         * killing it. */
+
+        r = safe_fork("(sd-sync)",
+                      FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|(ret_pid ? 0 : FORK_DETACH)|(getpid_cached() == 1 ? FORK_ARGV00_AT : 0),
+                      ret_pid);
         if (r < 0)
                 return r;
         if (r == 0) {
@@ -41,12 +49,23 @@ int asynchronous_sync(pid_t *ret_pid) {
 static int close_func(void *p) {
         unsigned v = PTR_TO_UINT(p);
 
-        (void) prctl(PR_SET_NAME, (unsigned long*) "(sd-close)");
-
         /* Note: 💣 This function is invoked in a child process created via glibc's clone() wrapper. In such
          *       children memory allocation is not allowed, since glibc does not release malloc mutexes in
          *       clone() 💣 */
 
+        /* This is a poor man's version of rename_process(). We don't use the real thing to avoid any memory
+         * allocations. We set argv[0][0] to '@' if invoked by PID 1 to exclude us from the
+         * switch-root/soft-reboot/shutdown killing spree, since it would likely fail anyway, and with a
+         * process of such minimal scope is not really worh the effort anyway. */
+        const char *comm;
+        if (getppid() == 1) {
+                if (saved_argc >= 1 && !isempty(saved_argv[0]))
+                        saved_argv[0][0] = '@';
+                comm = "@(sd-close)";
+        } else
+                comm = "(sd-close)";
+        (void) prctl(PR_SET_NAME, comm);
+
         if (v & NEED_DOUBLE_FORK) {
                 pid_t pid;
 
@@ -117,9 +136,15 @@ int asynchronous_rm_rf(const char *p, RemoveFlags flags) {
         assert(p);
 
         /* Forks off a child that destroys the specified path. This will be best effort only, i.e. the child
-         * will attempt to do its thing, but we won't wait for it or check its success. */
+         * will attempt to do its thing, but we won't wait for it or check its success.
+         *
+         * We do set argv[0][0] = '@' here however (if we are invoked as PID 1), to ensure that the this is
+         * excluded from the switch-root/soft-reboot/poweroff killing spree, and can definitely complete it's
+         * job. */
 
-        r = safe_fork("(sd-rmrf)", FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DETACH, NULL);
+        r = safe_fork("(sd-rmrf)",
+                      FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DETACH|(getpid_cached() == 1 ? FORK_ARGV00_AT : 0),
+                      /* ret_pid= */ NULL);
         if (r != 0)
                 return r;
 

test/TEST-06-SELINUX/meson.build

@@ -3,7 +3,7 @@
 integration_tests += [
         integration_test_template + {
                 'name' : fs.name(meson.current_source_dir()),
-                'cmdline' : integration_test_template['cmdline'] + ['selinux=1', 'lsm=selinux'],
+                'cmdline' : integration_test_template['cmdline'] + ['systemd.wants=autorelabel.service', 'selinux=1', 'lsm=selinux'],
                 # FIXME; Figure out why reboot sometimes hangs with 'linux' firmware.
                 # Use 'auto' to automatically fallback on non-uefi architectures.
                 'firmware' : 'auto',

test/TEST-09-REBOOT/meson.build

@@ -4,5 +4,8 @@ integration_tests += [
         integration_test_template + {
                 'name' : fs.name(meson.current_source_dir()),
                 'storage' : 'persistent',
+                # FIXME: Figure out why reboot sometimes hangs with 'linux' firmware.
+                # Use 'auto' to automatically fallback on non-uefi architectures.
+                'firmware' : 'auto',
         },
 ]

test/TEST-18-FAILUREACTION/meson.build

@@ -3,5 +3,8 @@
 integration_tests += [
         integration_test_template + {
                 'name' : fs.name(meson.current_source_dir()),
+                # FIXME: Figure out why reboot sometimes hangs with 'linux' firmware.
+                # Use 'auto' to automatically fallback on non-uefi architectures.
+                'firmware' : 'auto',
         },
 ]

test/TEST-54-CREDS/meson.build

@@ -27,5 +27,6 @@ integration_tests += [
                         '-smbios', 'type=11,value=io.systemd.credential.binary:fstab.extra=aW5qZWN0ZWQgL2luamVjdGVkIHRtcGZzIFgtbW91bnQubWtkaXIgMCAwCg==',
                         '-smbios', 'type=11,value=io.systemd.credential:getty.ttys.container=idontexist',
                 ],
+                'firmware' : 'auto',
         },
 ]

test/TEST-64-UDEV-STORAGE/long_sysfs_path.configure

@@ -23,10 +23,9 @@ config["QemuArgs"] += ["-device", "pci-bridge,id=pci_bridge0,chassis_nr=64"]
 for bridge in range(1, 26):
     config["QemuArgs"] += [
         "-device",
-        f"pci-bridge,id=pci_bridge{bridge},bus=pci_bridge{bridge - 1},"
-        f"chassis_nr={64 + bridge}"
+        f"pci-bridge,id=pci_bridge{bridge},bus=pci_bridge{bridge - 1},chassis_nr={64 + bridge},addr=1",
     ]
 
-config["QemuArgs"] += ["-device", f"virtio-blk-pci,drive=drive0,scsi=off,bus=pci_bridge25"]
+config["QemuArgs"] += ["-device", f"virtio-blk-pci,drive=drive0,scsi=off,bus=pci_bridge25,addr=1"]
 
 json.dump(config, sys.stdout)

test/TEST-64-UDEV-STORAGE/nvme_basic.configure

@@ -9,8 +9,8 @@ import sys
 
 config = json.load(sys.stdin)
 
-qemu = f"qemu-system-{os.environ["QEMU_ARCHITECTURE"]}"
-result = subprocess.run([qemu, '-device', 'help'], check=True, text=True, stdout=subprocess.PIPE)
+qemu = f"qemu-system-{os.environ['QEMU_ARCHITECTURE']}"
+result = subprocess.run([qemu, "-device", "help"], check=True, text=True, stdout=subprocess.PIPE)
 if 'name "nvme"' not in result.stdout:
     print("nvme device driver is not available, skipping test...", file=sys.stderr)
     exit(77)

test/TEST-64-UDEV-STORAGE/nvme_subsystem.configure

@@ -9,8 +9,8 @@ import sys
 
 config = json.load(sys.stdin)
 
-qemu = f"qemu-system-{os.environ["QEMU_ARCHITECTURE"]}"
-result = subprocess.run([qemu, '-device', 'help'], check=True, text=True, stdout=subprocess.PIPE)
+qemu = f"qemu-system-{os.environ['QEMU_ARCHITECTURE']}"
+result = subprocess.run([qemu, "-device", "help"], check=True, text=True, stdout=subprocess.PIPE)
 if 'name "nvme"' not in result.stdout:
     print("nvme device driver is not available, skipping test...", file=sys.stderr)
     exit(77)

test/TEST-64-UDEV-STORAGE/virtio_scsi_identically_named_partitions.configure

@@ -9,8 +9,8 @@ import sys
 
 config = json.load(sys.stdin)
 
-qemu = f"qemu-system-{os.environ["QEMU_ARCHITECTURE"]}"
-result = subprocess.run([qemu, '-device', 'help'], check=True, text=True, stdout=subprocess.PIPE)
+qemu = f"qemu-system-{os.environ['QEMU_ARCHITECTURE']}"
+result = subprocess.run([qemu, "-device", "help"], check=True, text=True, stdout=subprocess.PIPE)
 if 'name "virtio-scsi-pci"' not in result.stdout:
     print("virtio-scsi-pci device driver is not available, skipping test...", file=sys.stderr)
     exit(77)

test/TEST-70-TPM2/meson.build

@@ -8,5 +8,6 @@ integration_tests += [
                         'after' : '@0@ tpm2.target'.format(integration_test_template['configuration']['after']),
                 },
                 'vm' : true,
+                'firmware' : 'auto',
         },
 ]

test/integration-test-wrapper.py

@@ -103,6 +103,12 @@ def main():
         journal_file = (args.meson_build_dir / (f"test/journal/{name}.journal")).absolute()
         journal_file.unlink(missing_ok=True)
     else:
+        dropin += textwrap.dedent(
+            """
+            [Unit]
+            Wants=multi-user.target
+            """
+        )
         journal_file = None
 
     cmd = [

test/units/TEST-45-TIMEDATE.sh

@@ -218,7 +218,7 @@ assert_ntp() {
 assert_timedated_signal() {
     local timestamp="${1:?}"
     local value="${2:?}"
-    local args=(-q -n 1 --since="$timestamp" -p info _SYSTEMD_UNIT="busctl-monitor.service")
+    local args=(-q -n 1 --since="$timestamp" -p info -t busctl)
 
     journalctl --sync
 
@@ -298,7 +298,7 @@ assert_timesyncd_signal() {
     local timestamp="${1:?}"
     local property="${2:?}"
     local value="${3:?}"
-    local args=(-q --since="$timestamp" -p info _SYSTEMD_UNIT="busctl-monitor.service")
+    local args=(-q --since="$timestamp" -p info -t busctl)
 
     journalctl --sync
 

test/units/TEST-64-UDEV-STORAGE.sh

@@ -231,8 +231,8 @@ testcase_nvme_subsystem() {
         /dev/disk/by-id/nvme-QEMU_NVMe_Ctrl_deadbeef_16
         /dev/disk/by-id/nvme-QEMU_NVMe_Ctrl_deadbeef_17
         # Shared namespaces
-        /dev/disk/by-path/pci-*-nvme-16
-        /dev/disk/by-path/pci-*-nvme-17
+        /dev/disk/by-path/*pci*-nvme-16
+        /dev/disk/by-path/*pci*-nvme-17
     )
 
     udevadm wait --settle --timeout=30 "${expected_symlinks[@]}"