po: Translated using Weblate (Slovenian)

Currently translated at 100.0% (264 of 264 strings)

Co-authored-by: Martin Srebotnjak <miles@filmsi.net>
Translate-URL: https://translate.fedoraproject.org/projects/systemd/main/sl/
Translation: systemd/main

po/sl.po

@@ -1,13 +1,13 @@
 # SPDX-License-Identifier: LGPL-2.1-or-later
 #
-# Martin Srebotnjak <miles@filmsi.net>, 2024.
+# Martin Srebotnjak <miles@filmsi.net>, 2024, 2025.
 # Weblate Translation Memory <noreply-mt-weblate-translation-memory@weblate.org>, 2024.
 msgid ""
 msgstr ""
 "Project-Id-Version: systemd\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2025-07-23 15:38+0100\n"
-"PO-Revision-Date: 2024-12-04 02:38+0000\n"
+"PO-Revision-Date: 2025-07-25 00:08+0000\n"
 "Last-Translator: Martin Srebotnjak <miles@filmsi.net>\n"
 "Language-Team: Slovenian <https://translate.fedoraproject.org/projects/"
 "systemd/main/sl/>\n"
@@ -17,7 +17,7 @@ msgstr ""
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=4; plural=n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || "
 "n%100==4 ? 2 : 3;\n"
-"X-Generator: Weblate 5.8.2\n"
+"X-Generator: Weblate 5.12.2\n"
 
 #: src/core/org.freedesktop.systemd1.policy.in:22
 msgid "Send passphrase back to system"
@@ -166,15 +166,13 @@ msgstr ""
 
 #: src/home/org.freedesktop.home1.policy:93
 msgid "Manage Home Directory Signing Keys"
-msgstr ""
+msgstr "Upravljaj podpisne ključe domače mape"
 
 #: src/home/org.freedesktop.home1.policy:94
-#, fuzzy
-#| msgid "Authentication is required to manage system services or other units."
 msgid "Authentication is required to manage signing keys for home directories."
 msgstr ""
-"Preverjanje pristnosti je potrebno za upravljanje sistemskih storitev ali "
+"Preverjanje pristnosti je potrebno za upravljanje podpisnih ključev za "
-"drugih enot."
+"domače mape."
 
 #: src/home/pam_systemd_home.c:336
 #, c-format
@@ -929,19 +927,14 @@ msgstr ""
 "računalnikov in vsebnikov."
 
 #: src/machine/org.freedesktop.machine1.policy:106
-#, fuzzy
-#| msgid "Create a local virtual machine or container"
 msgid "Register a local virtual machine or container"
-msgstr "Ustvari krajevni navidezni računalnik ali vsebnik"
+msgstr "Registriraj krajevni navidezni računalnik ali vsebnik"
 
 #: src/machine/org.freedesktop.machine1.policy:107
-#, fuzzy
-#| msgid ""
-#| "Authentication is required to create a local virtual machine or container."
 msgid ""
 "Authentication is required to register a local virtual machine or container."
 msgstr ""
-"Preverjanje pristnosti je potrebno za ustvarjanje krajevnih navideznih "
+"Preverjanje pristnosti je potrebno za registracijo krajevnih navideznih "
 "računalnikov in vsebnikov."
 
 #: src/machine/org.freedesktop.machine1.policy:116
@@ -1187,14 +1180,11 @@ msgstr ""
 
 #: src/resolve/org.freedesktop.resolve1.policy:154
 msgid "Subscribe to DNS configuration"
-msgstr ""
+msgstr "Naroči se na prilagoditev DNS"
 
 #: src/resolve/org.freedesktop.resolve1.policy:155
-#, fuzzy
-#| msgid "Authentication is required to subscribe query results."
 msgid "Authentication is required to subscribe to DNS configuration."
-msgstr ""
+msgstr "Za naročanje na prilagoditev DNS je potrebno preverjanje pristnosti."
-"Za naročanje na rezultate poizvedbe je potrebno preverjanje pristnosti."
 
 #: src/resolve/org.freedesktop.resolve1.policy:165
 msgid "Dump cache"
@@ -1343,16 +1333,12 @@ msgstr ""
 "»$(unit)«."
 
 #: src/core/dbus-unit.c:620
-#, fuzzy
-#| msgid ""
-#| "Authentication is required to send a UNIX signal to the processes of "
-#| "'$(unit)'."
 msgid ""
 "Authentication is required to send a UNIX signal to the processes of "
 "subgroup of '$(unit)'."
 msgstr ""
 "Preverjanje pristnosti je potrebno za pošiljanje signala UNIX procesom "
-"»$(unit)«."
+"podenote »$(unit)«."
 
 #: src/core/dbus-unit.c:648
 msgid "Authentication is required to reset the \"failed\" state of '$(unit)'."

src/core/dbus-manager.c

@@ -765,6 +765,7 @@ static int method_generic_unit_operation(
                 sd_bus_message *message,
                 Manager *m,
                 sd_bus_error *error,
+                UnitType type,
                 sd_bus_message_handler_t handler,
                 GenericUnitOperationFlags flags) {
 
@@ -790,6 +791,11 @@ static int method_generic_unit_operation(
         if (r < 0)
                 return r;
 
+        if (type != _UNIT_TYPE_INVALID && u->type != type)
+                return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
+                                         "%s operation is not supported for unit type '%s'",
+                                         sd_bus_message_get_member(message), unit_type_to_string(u->type));
+
         if (FLAGS_SET(flags, GENERIC_UNIT_VALIDATE_LOADED)) {
                 r = bus_unit_validate_load_state(u, error);
                 if (r < 0)
@@ -801,7 +807,7 @@ static int method_generic_unit_operation(
 
 static int method_enqueue_unit_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* We don't bother with GENERIC_UNIT_VALIDATE_LOADED here, as the job logic validates that anyway */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_enqueue_job, GENERIC_UNIT_LOAD);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_enqueue_job, GENERIC_UNIT_LOAD);
 }
 
 static int method_start_unit_replace(sd_bus_message *message, void *userdata, sd_bus_error *error) {
@@ -828,61 +834,61 @@ static int method_start_unit_replace(sd_bus_message *message, void *userdata, sd
 static int method_kill_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* We don't bother with GENERIC_UNIT_LOAD or GENERIC_UNIT_VALIDATE_LOADED here, as it shouldn't
          * matter whether a unit is loaded for killing any processes in the unit's cgroup. */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_kill, 0);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_kill, /* flags = */ 0);
 }
 
 static int method_kill_unit_subgroup(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* We don't bother with GENERIC_UNIT_LOAD or GENERIC_UNIT_VALIDATE_LOADED here, as it shouldn't
          * matter whether a unit is loaded for killing any processes in the unit's cgroup. */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_kill_subgroup, 0);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_kill_subgroup, /* flags = */ 0);
 }
 
 static int method_clean_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* Load the unit if necessary, in order to load it, and insist on the unit being loaded to be
          * cleaned */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_clean, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_clean, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
 }
 
 static int method_freeze_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* Only active units can be frozen, which must be properly loaded already */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_freeze, GENERIC_UNIT_VALIDATE_LOADED);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_freeze, GENERIC_UNIT_VALIDATE_LOADED);
 }
 
 static int method_thaw_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* Same as freeze above */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_thaw, GENERIC_UNIT_VALIDATE_LOADED);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_thaw, GENERIC_UNIT_VALIDATE_LOADED);
 }
 
 static int method_reset_failed_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* Don't load the unit (because unloaded units can't be in failed state), and don't insist on the
          * unit to be loaded properly (since a failed unit might have its unit file disappeared) */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_reset_failed, 0);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_reset_failed, /* flags = */ 0);
 }
 
 static int method_set_unit_properties(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* Only change properties on fully loaded units, and load them in order to set properties */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_set_properties, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_set_properties, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
 }
 
 static int method_bind_mount_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* Only add mounts on fully loaded units */
-        return method_generic_unit_operation(message, userdata, error, bus_service_method_bind_mount, GENERIC_UNIT_VALIDATE_LOADED);
+        return method_generic_unit_operation(message, userdata, error, UNIT_SERVICE, bus_service_method_bind_mount, GENERIC_UNIT_VALIDATE_LOADED);
 }
 
 static int method_mount_image_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* Only add mounts on fully loaded units */
-        return method_generic_unit_operation(message, userdata, error, bus_service_method_mount_image, GENERIC_UNIT_VALIDATE_LOADED);
+        return method_generic_unit_operation(message, userdata, error, UNIT_SERVICE, bus_service_method_mount_image, GENERIC_UNIT_VALIDATE_LOADED);
 }
 
 static int method_ref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* Only allow reffing of fully loaded units, and make sure reffing a unit loads it. */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_ref, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_ref, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
 }
 
 static int method_unref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* Dropping a ref OTOH should not require the unit to still be loaded. And since a reffed unit is a
          * loaded unit there's no need to load the unit for unreffing it. */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_unref, 0);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_unref, /* flags = */ 0);
 }
 
 static int reply_unit_info(sd_bus_message *reply, Unit *u) {
@@ -961,20 +967,20 @@ static int method_get_unit_processes(sd_bus_message *message, void *userdata, sd
         /* Don't load a unit actively (since it won't have any processes if it's not loaded), but don't
          * insist on the unit being loaded either (because even improperly loaded units might still have
          * processes around). */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_get_processes, /* flags = */ 0);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_get_processes, /* flags = */ 0);
 }
 
 static int method_attach_processes_to_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* Don't allow attaching new processes to units that aren't loaded. Don't bother with loading a unit
          * for this purpose though, as an unloaded unit is a stopped unit, and we don't allow attaching
          * processes to stopped units anyway. */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_attach_processes, GENERIC_UNIT_VALIDATE_LOADED);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_attach_processes, GENERIC_UNIT_VALIDATE_LOADED);
 }
 
 static int method_remove_subgroup_from_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         /* Don't allow removal of subgroups from units that aren't loaded. But allow loading the unit, since
          * this is clean-up work, that is OK to do when the unit is stopped already. */
-        return method_generic_unit_operation(message, userdata, error, bus_unit_method_remove_subgroup, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
+        return method_generic_unit_operation(message, userdata, error, _UNIT_TYPE_INVALID, bus_unit_method_remove_subgroup, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
 }
 
 static int transient_unit_from_message(
@@ -2821,7 +2827,7 @@ static int method_set_show_status(sd_bus_message *message, void *userdata, sd_bu
 }
 
 static int method_dump_unit_descriptor_store(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        return method_generic_unit_operation(message, userdata, error, bus_service_method_dump_file_descriptor_store, 0);
+        return method_generic_unit_operation(message, userdata, error, UNIT_SERVICE, bus_service_method_dump_file_descriptor_store, GENERIC_UNIT_VALIDATE_LOADED);
 }
 
 static int method_start_aux_scope(sd_bus_message *message, void *userdata, sd_bus_error *error) {

src/journal/journald-manager.c

@@ -2290,6 +2290,8 @@ void manager_reopen_journals(Manager *m, const JournalConfig *old) {
         (void) manager_system_journal_open(m, /* flush_requested = */ false, /* relinquish_requested = */ false);
 
         /* To make the storage related settings applied, vacuum the storage. */
+        cache_space_invalidate(&m->system_storage.space);
+        cache_space_invalidate(&m->runtime_storage.space);
         manager_vacuum(m, /* verbose = */ false);
 }
 

test/integration-tests/TEST-04-JOURNAL/TEST-04-JOURNAL.units/logs-filtering.service

@@ -5,6 +5,6 @@ Description=Log filtering unit
 Type=oneshot
 # If the service finishes extremely fast, journald cannot find the source of the
 # stream. Hence, we need to call 'journalctl --sync' before service finishes.
-ExecStart=sh -c 'echo "Logging from the service, and ~more~ foo bar"; journalctl --sync'
+ExecStart=bash -c 'echo "Logging from the service, and ~more~ foo bar"; journalctl --sync'
 SyslogLevel=notice
 LogLevelMax=info

test/units/TEST-04-JOURNAL.journal-reload.sh

@@ -1,316 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-License-Identifier: LGPL-2.1-or-later
-# shellcheck disable=SC2016
-set -eux
-set -o pipefail
-
-MACHINE_ID="$(</etc/machine-id)"
-TEST_MSG_PREFIX="JOURNAL-RELOAD TEST"
-SYSLOG_ID="$(systemd-id128 new)"
-
-write_to_journal() {
-    local rand_val
-
-    rand_val=$(head /dev/urandom | tr -dc A-Za-z0-9 | head -c 14)
-    echo "$TEST_MSG_PREFIX $rand_val" | systemd-cat -t "$SYSLOG_ID"
-    journalctl --sync
-
-    echo "$rand_val"
-}
-
-verify_archived_journals() {
-    local msg="$1"
-    local journal_path_prefix="$2"
-    local journal_dir="/$journal_path_prefix/log/journal/$MACHINE_ID"
-
-    for journal_file in "$journal_dir"/*; do
-        filename=$(basename -- "$journal_file")
-        if [[ "$filename" != "system.journal" ]]; then
-            if journalctl --file="$journal_file" | grep -q "$msg"; then
-                echo "Message present in archived journal: $filename"
-                exit 0
-            fi
-        fi
-    done
-
-    exit 1
-}
-
-# shellcheck disable=SC2317
-verify_journal() {
-    local msg="$1"
-    local entry_expected="$2"
-    local test_name="$3"
-    local journal_path_prefix="$4"
-
-    local path="/$journal_path_prefix/log/journal/$MACHINE_ID/system.journal"
-
-    if [ ! -e "$path" ] || ! grep -Fxq "MESSAGE=$TEST_MSG_PREFIX $msg" "$path"; then
-        if [ "$entry_expected" == true ]; then
-            echo "$test_name ERROR: Message not present in $journal_path_prefix journal. Checking archived journals..."
-            if ! verify_archived_journals "$msg" "$journal_path_prefix"; then
-                echo "$test_name ERROR: Message also not present in archived journals"
-                cleanup
-                exit 1
-            fi
-
-        fi
-    else
-        if [ "$entry_expected" == false ]; then
-            echo "$test_name ERROR: Message present in $journal_path_prefix journal"
-            cleanup
-            exit 1
-        fi
-    fi
-}
-
-verify_journals() {
-    local msg="$1"
-    local runtime_expected="$2"
-    local system_expected="$3"
-    local test_name="$4"
-
-    local failed=false
-
-    if ! verify_journal "$msg" "$runtime_expected" "$test_name" "run"; then
-        failed=true
-    fi
-
-    if ! verify_journal "$msg" "$system_expected" "$test_name" "var"; then
-        failed=true
-    fi
-
-    if [ "$failed" == true ]; then
-        cleanup
-        exit 1
-    fi
-}
-
-get_num_archived_journals() {
-    local journal_path_prefix="$1"
-
-    local journal_dir="/$journal_path_prefix/log/journal/$MACHINE_ID/"
-    num_journal_files=$(find "$journal_dir" -type f -name "*.journal" ! -name "system.journal" | wc -l)
-
-    echo "$num_journal_files"
-}
-
-cleanup() {
-    rm /run/systemd/journald.conf.d/reload.conf
-    journalctl --vacuum-size=1M
-    systemctl daemon-reload
-    systemctl reload systemd-journald.service
-}
-
-# Start clean slate.
-mkdir -p /run/systemd/journald.conf.d
-cat <<EOF >/run/systemd/journald.conf.d/reload.conf
-[Journal]
-Storage=persistent
-EOF
-
-systemctl daemon-reload
-systemctl restart systemd-journald.service
-
-# Add entries in system.
-journalctl --flush
-rand_val1=$(write_to_journal)
-verify_journals "$rand_val1" false true "Confirming test setup after flush."
-
-# Reload journald (persistent->persistent)
-systemctl reload systemd-journald.service
-
-# Reload should persist persistent journal.
-verify_journals "$rand_val1" false true "Persistent->Persistent System Reload: "
-
-rand_val1=$(write_to_journal)
-verify_journals "$rand_val1" false true "Persistent->Persistent System Post-Reload: "
-
-# Add entries in runtime
-journalctl --relinquish
-rand_val2=$(write_to_journal)
-verify_journals "$rand_val2" true false "Confirming test setup after relinquish."
-
-# Reload journald (persistent->persistent)
-systemctl reload systemd-journald.service
-
-# System journal entries should stay in system journal, runtime in runtime.
-verify_journals "$rand_val1" false true "Persistent->Persistent Runtime Reload 1: "
-verify_journals "$rand_val2" true false "Persistent->Persistent Runtime Reload 2: "
-
-# Write new message and confirm it's written to runtime.
-rand_val=$(write_to_journal)
-verify_journals "$rand_val" true false "Persistent->Persistent New Message After Reload: "
-
-# Flush and confirm that messages are written to system.
-journalctl --flush
-rand_val=$(write_to_journal)
-verify_journals "$rand_val" false true "Persistent->Volatile New Message Before Reload: "
-
-# Test persistent->volatile
-cat <<EOF >/run/systemd/journald.conf.d/reload.conf
-[Journal]
-Storage=volatile
-EOF
-
-# Confirm old message exists where it was written to (storage->storage).
-systemctl reload systemd-journald.service
-verify_journals "$rand_val" false true "Persistent->Volatile Reload: "
-
-# Confirm that messages are written to only runtime journal.
-rand_val=$(write_to_journal)
-verify_journals "$rand_val" true false "Persistent->Volatile New Message After Reload: "
-
-# Test volatile works and logs are NOT getting written to system journal despite flush.
-journalctl --flush
-rand_val=$(write_to_journal)
-verify_journals "$rand_val" true false "Persistent->Volatile New Message After Flush: "
-
-# Test that the new limits (e.g., RuntimeMaxUse) take effect on reload.
-# Write 1M of data to runtime journal
-max_size=1048656 # (1 * 1024 * 1024) = 1048576, but centos has a different minimum value for some reason.
-set +x
-dd if=/dev/urandom bs=1M count=5 | base64 | systemd-cat -t "$SYSLOG_ID"
-set -x
-journalctl --vacuum-size=2M
-
-total_size=$(du -sb "/run/log/journal/$MACHINE_ID" | cut -f1)
-if [ "$total_size" -lt "$max_size" ]; then
-    echo "ERROR: Journal size does not exceed RuntimeMaxUse limit"
-    cleanup
-    exit 1
-fi
-
-# Reload with RuntimeMaxUse=1M.
-cat <<EOF >/run/systemd/journald.conf.d/reload.conf
-[Journal]
-Storage=volatile
-RuntimeMaxUse=1M
-EOF
-
-# systemctl daemon-reload
-systemctl reload systemd-journald.service
-
-sleep 15 # Wait for RuntimeMaxUse change to take effect.
-
-# Confirm that runtime journal size shrunk to <=1M.
-total_size=$(du -sb "/run/log/journal/$MACHINE_ID" | cut -f1)
-if [ "$total_size" -gt "$max_size" ]; then
-    echo "ERROR: Journal size exceeds RuntimeMaxUse limit"
-    cleanup
-    exit 1
-fi
-
-# Prepare for volatile->persistent by getting rid of runtime limit. Otherwise, it will not write.
-cat <<EOF >/run/systemd/journald.conf.d/reload.conf
-[Journal]
-Storage=volatile
-EOF
-systemctl daemon-reload
-systemctl reload systemd-journald.service
-sleep 15 # Wait for RuntimeMaxUse change to take effect.
-
-journalctl --vacuum-size=1M
-sleep 5
-
-rand_val=$(write_to_journal)
-verify_journals "$rand_val" true false "Volatile->Persistent New Message Before Reload: "
-
-# Reload volatile->persistent
-cat <<EOF >/run/systemd/journald.conf.d/reload.conf
-[Journal]
-Storage=persistent
-EOF
-
-systemctl reload systemd-journald.service
-
-# Confirm that previous message is still in runtime journal.
-verify_journals "$rand_val" true false "Volatile->Persistent Reload: "
-
-# Confirm that new messages are written to runtime journal.
-rand_val=$(write_to_journal)
-verify_journals "$rand_val" true false "Volatile->Persistent New Message After Reload: "
-
-# Confirm that flushing writes to system journal.
-journalctl --flush
-verify_journals "$rand_val" false true "Volatile->Persistent New Message After Flush: "
-
-set +x
-dd if=/dev/urandom bs=1M count=5 | base64 | systemd-cat -t "$SYSLOG_ID"
-set -x
-
-max_size=$((2 * 1024 * 1024))
-total_size=$(du -sb "/var/log/journal/$MACHINE_ID" | cut -f1)
-if [ "$total_size" -lt "$max_size" ]; then
-    echo "ERROR: Journal size does not exceed SystemMaxUse limit"
-    cleanup
-    exit 1
-fi
-
-# Ensure reloading without limit does not interfere with SystemMaxUse test.
-systemctl reload systemd-journald.service
-total_size=$(du -sb "/var/log/journal/$MACHINE_ID" | cut -f1)
-if [ "$total_size" -lt "$max_size" ]; then
-    echo "ERROR: Journal size does not exceed SystemMaxUse limit"
-    cleanup
-    exit 1
-fi
-
-# Write to storage to prepare for SystemMaxFiles test.
-journalctl --flush
-
-num_var_journals=$(get_num_archived_journals "var")
-limit_var_journals=3
-if [ "$num_var_journals" -lt "$limit_var_journals" ]; then
-    echo "Creating archive files."
-    for (( i=0; i<=num_var_journals; i++ ))
-    do
-        echo "$TEST_MSG_PREFIX" | systemd-cat -t "$SYSLOG_ID"
-        journalctl --rotate
-    done
-
-    num_var_journals=$(get_num_archived_journals "var")
-    if [ "$num_var_journals" -lt "$limit_var_journals" ]; then
-        echo "ERROR: Number of journal files in /var/log/journal/$MACHINE_ID/ is less than $limit_var_journals"
-        cleanup
-        exit 1
-    fi
-fi
-
-# Reload with less SystemMaxUse and SystemMaxFiles.
-cat <<EOF >/run/systemd/journald.conf.d/reload.conf
-[Journal]
-Storage=persistent
-RuntimeMaxUse=2M
-SystemMaxUse=2M
-SystemMaxFiles=3
-EOF
-
-systemctl daemon-reload
-systemctl reload systemd-journald.service
-
-# New system journal needs to be created with the new configuration for change to take effect.
-journalctl --flush
-
-# Check SystemMaxFiles
-num_var_journals=$(get_num_archived_journals "var")
-if [ "$num_var_journals" -gt "$limit_var_journals" ]; then
-    echo "ERROR: Number of journal files in /var/log/journal/$MACHINE_ID/ is greater than $limit_var_journals"
-    cleanup
-    exit 1
-fi
-
-sleep 15
-
-# Check SystemMaxUse
-total_size=$(du -sb "/var/log/journal/$MACHINE_ID" | cut -f1)
-if [ "$total_size" -gt "$max_size" ]; then
-    echo "ERROR: Journal size exceeds SystemMaxUse limit"
-    cleanup
-    exit 1
-fi
-
-rm /run/systemd/journald.conf.d/reload.conf
-journalctl --vacuum-size=1M
-systemctl daemon-reload
-systemctl reload systemd-journald.service

test/units/TEST-04-JOURNAL.reload.sh

@@ -0,0 +1,236 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: LGPL-2.1-or-later
+# shellcheck disable=SC2016
+set -eux
+set -o pipefail
+
+# shellcheck source=test/units/util.sh
+. "$(dirname "$0")"/util.sh
+
+MACHINE_ID="$(</etc/machine-id)"
+SYSLOG_ID="$(systemd-id128 new)"
+
+write_to_journal() {
+    local service="test-${RANDOM}.service"
+
+    systemd-run -q --wait -u "$service" bash -c "echo service=$service invocation=\$INVOCATION_ID; journalctl --sync"
+    echo "$service"
+}
+
+verify_journals() {
+    local service="${1:?}"
+    local expected_storage="${2:?}"
+
+    local run_expected var_expected
+    if [[ "$expected_storage" == runtime ]]; then
+        run_expected=0
+        var_expected=1
+    elif [[ "$expected_storage" == persistent ]]; then
+        run_expected=1
+        var_expected=0
+    else
+        echo "unexpected storage: $expected_storage"
+        exit 1
+    fi
+
+    assert_rc "$run_expected" journalctl -q -D "/run/log/journal/$MACHINE_ID/" -u "$service" --grep "service=$service"
+    assert_rc "$var_expected" journalctl -q -D "/var/log/journal/$MACHINE_ID/" -u "$service" --grep "service=$service"
+}
+
+get_num_archived_journals() {
+    local prefix=${1:?}
+
+    find "/$prefix/log/journal/$MACHINE_ID/" -type f -name "system@*.journal" | wc -l
+}
+
+cleanup() {
+    set +e
+    rm -rf /run/systemd/journald.conf.d
+    systemctl reload systemd-journald.service
+}
+
+trap cleanup EXIT ERR INT TERM
+
+mkdir -p /run/systemd/journald.conf.d
+cat <<EOF >/run/systemd/journald.conf.d/reload.conf
+[Journal]
+Storage=persistent
+EOF
+systemctl restart systemd-journald.service
+
+: "Add entries in system."
+journalctl --flush
+VAL1=$(write_to_journal)
+verify_journals "$VAL1" persistent
+
+: "Reload journald (persistent->persistent)"
+systemctl reload systemd-journald.service
+
+: "Reload should persist persistent journal."
+verify_journals "$VAL1" persistent
+
+: "Add entries in runtime"
+journalctl --relinquish
+VAL2=$(write_to_journal)
+verify_journals "$VAL2" runtime
+
+: "Reload journald after relinquish (persistent->persistent)"
+systemctl reload systemd-journald.service
+
+: "System journal entries should stay in system journal, runtime in runtime."
+verify_journals "$VAL1" persistent
+verify_journals "$VAL2" runtime
+
+: "Write new message and confirm it's written to runtime."
+VAL=$(write_to_journal)
+verify_journals "$VAL" runtime
+
+: "Flush and confirm that messages are written to system."
+journalctl --flush
+VAL=$(write_to_journal)
+verify_journals "$VAL" persistent
+
+# Test persistent->volatile
+cat <<EOF >/run/systemd/journald.conf.d/reload.conf
+[Journal]
+Storage=volatile
+EOF
+
+: "Confirm old message exists where it was written to persistent journal."
+systemctl reload systemd-journald.service
+verify_journals "$VAL" persistent
+
+: "Confirm that new message is written to runtime journal."
+VAL=$(write_to_journal)
+verify_journals "$VAL" runtime
+
+: "Test volatile works and logs are NOT getting written to system journal despite flush."
+journalctl --flush
+VAL=$(write_to_journal)
+verify_journals "$VAL" runtime
+
+: "Disable compression"
+cat <<EOF >/run/systemd/journald.conf.d/reload.conf
+[Journal]
+Storage=volatile
+Compress=no
+EOF
+systemctl reload systemd-journald.service
+
+: "write 2MB of data to runtime journal"
+set +x
+dd if=/dev/urandom bs=1M count=2 | base64 | systemd-cat -t "$SYSLOG_ID"
+set -x
+journalctl --sync
+journalctl --rotate
+
+ls -l "/run/log/journal/$MACHINE_ID"
+
+max_size=$((1 * 1024 * 1024))
+total_size=$(du -sb "/run/log/journal/$MACHINE_ID" | cut -f1)
+if (( total_size < max_size )); then
+    echo "ERROR: runtime journal size is smaller than 1MB."
+    exit 1
+fi
+
+: "Reload with RuntimeMaxUse=1M."
+cat <<EOF >/run/systemd/journald.conf.d/reload.conf
+[Journal]
+Storage=volatile
+RuntimeMaxUse=1M
+EOF
+systemctl reload systemd-journald.service
+
+ls -l "/run/log/journal/$MACHINE_ID"
+
+: "Confirm that runtime journal size shrunk to <= 1MB."
+total_size=$(du -sb "/run/log/journal/$MACHINE_ID" | cut -f1)
+num_archived_journals=$(get_num_archived_journals run)
+if (( total_size > max_size )) && (( num_archived_journals > 0 )); then
+    echo "ERROR: Journal size exceeds RuntimeMaxUse= limit and exists archived journals."
+    exit 1
+fi
+
+: "Write a message to runtime journal"
+VAL=$(write_to_journal)
+verify_journals "$VAL" runtime
+
+: "Reload volatile->persistent"
+cat <<EOF >/run/systemd/journald.conf.d/reload.conf
+[Journal]
+Storage=persistent
+EOF
+systemctl reload systemd-journald.service
+
+: "Confirm that previous message is still in runtime journal."
+verify_journals "$VAL" runtime
+
+: "Confirm that new messages are written to runtime journal."
+VAL=$(write_to_journal)
+verify_journals "$VAL" runtime
+
+: "Confirm that flushing writes to system journal."
+journalctl --flush
+verify_journals "$VAL" persistent
+
+: "Disable compression"
+cat <<EOF >/run/systemd/journald.conf.d/reload.conf
+[Journal]
+Storage=persistent
+Compress=no
+EOF
+systemctl reload systemd-journald.service
+
+: "Write 2MB of data to volatile journal"
+set +x
+dd if=/dev/urandom bs=1M count=2 | base64 | systemd-cat -t "$SYSLOG_ID"
+set -x
+journalctl --sync
+
+max_size=$((1 * 1024 * 1024))
+total_size=$(du -sb "/var/log/journal/$MACHINE_ID" | cut -f1)
+if (( total_size < max_size )); then
+    echo "ERROR: volatile journal size is smaller than 1MB."
+    exit 1
+fi
+
+: "Creating archive files."
+limit_var_journals=3
+for (( i = 0; i < limit_var_journals; i++ )); do
+    write_to_journal
+    journalctl --rotate
+done
+
+ls -l "/var/log/journal/$MACHINE_ID"
+
+num_archived_journals=$(get_num_archived_journals var)
+if (( num_archived_journals < limit_var_journals )); then
+    echo "ERROR: Number of archived system journal files is ${num_archived_journals} < ${limit_var_journals}."
+    exit 1
+fi
+
+: "Reload with less SystemMaxUse= and SystemMaxFiles=."
+cat <<EOF >/run/systemd/journald.conf.d/reload.conf
+[Journal]
+Storage=persistent
+RuntimeMaxUse=2M
+SystemMaxUse=1M
+SystemMaxFiles=3
+EOF
+systemctl reload systemd-journald.service
+
+ls -l "/var/log/journal/$MACHINE_ID"
+
+: "Check number of the system journal files"
+num_archived_journals=$(get_num_archived_journals var)
+if (( num_archived_journals >= limit_var_journals )); then
+    echo "ERROR: Number of system journal files is ${num_archived_journals} >= ${limit_var_journals}."
+    exit 1
+fi
+
+: "Check the size of the system journal"
+total_size=$(du -sb "/var/log/journal/$MACHINE_ID" | cut -f1)
+if (( total_size > max_size )) && (( num_archived_journals > 0)); then
+    echo "ERROR: Journal size exceeds SystemMaxUse limit and there exist archived journals."
+    exit 1
+fi

test/units/TEST-07-PID1.issue-38320.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: LGPL-2.1-or-later
+set -eux
+set -o pipefail
+
+# shellcheck source=test/units/util.sh
+. "$(dirname "$0")"/util.sh
+
+UNIT_NAME="TEST-07-PID1-issue-38320-$RANDOM"
+
+at_exit() {
+    systemctl stop "$UNIT_NAME".{socket,service}
+    rm -f /run/systemd/system/"$UNIT_NAME".{socket,service}
+}
+
+trap at_exit EXIT
+
+cat >/run/systemd/system/"$UNIT_NAME.socket" <<EOF
+[Socket]
+ListenStream=/tmp/$UNIT_NAME
+EOF
+
+cat >/run/systemd/system/"$UNIT_NAME.service" <<EOF
+[Service]
+ExecStart=true
+EOF
+
+(! systemd-analyze fdstore "$UNIT_NAME.socket")
+
+systemctl restart "$UNIT_NAME.socket"
+(! systemd-analyze fdstore "$UNIT_NAME.socket")
+
+systemctl daemon-reload
+(! systemd-analyze fdstore "$UNIT_NAME.socket")
+
+systemctl is-active "$UNIT_NAME.socket"

test/units/TEST-07-PID1.prefix-shell.sh

@@ -14,9 +14,14 @@ systemd-run --wait --uid=nobody \
 assert_eq "$(cat /tmp/TEST-07-PID1.prefix-shell.flag)" "a"
 rm /tmp/TEST-07-PID1.prefix-shell.flag
 
+# If the service exits too early, journald cannot find the source process of the log message.
+# Hence, we cannot use 'journalctl -u' below. Instead, let's use --since=.
+journalctl --sync
+TS="$(date '+%H:%M:%S')"
+
 systemctl start prefix-shell.service
 assert_eq "$(cat /tmp/TEST-07-PID1.prefix-shell.flag)" "YAY!"
 
 journalctl --sync
-journalctl -b -u prefix-shell.service --grep "with login shell .*: lvl 101"
+journalctl --since "$TS" --grep "with login shell .*: lvl 101"
-journalctl -b -u prefix-shell.service --grep "with normal shell"
+journalctl --since "$TS" --grep "with normal shell"

test/units/delegated_cgroup_filtering_payload.sh

@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/bin/bash
 # SPDX-License-Identifier: LGPL-2.1-or-later
 
 mkdir /sys/fs/cgroup/system.slice/delegated-cgroup-filtering.service/the_child