diff --git a/SOURCES/0802-core-when-restarting-services-don-t-close-fds.patch b/SOURCES/0802-core-when-restarting-services-don-t-close-fds.patch
new file mode 100644
index 0000000..91ef314
--- /dev/null
+++ b/SOURCES/0802-core-when-restarting-services-don-t-close-fds.patch
@@ -0,0 +1,112 @@
+From 017d1bc2a34946336dbafcc1c9c390ea45a2a3bd Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Zbigniew=20J=C4=99drzejewski-Szmek?= <zbyszek@in.waw.pl>
+Date: Sat, 22 Oct 2016 22:16:02 -0400
+Subject: [PATCH] core: when restarting services, don't close fds
+
+We would close all the stored fds in service_release_resources(), which of
+course broke the whole concept of storing fds over service restart.
+
+Fixes #4408.
+
+(cherry picked from commit f0bfbfac43b7faa68ef1bb2ad659c191b9ec85d2)
+(cherry picked from commit 4c271437cd695c31e76adb191013009689a7797c)
+Resolves: #1803802
+---
+ src/core/service.c | 22 +++++++++++++++-------
+ src/core/unit.c | 6 ++++--
+ src/core/unit.h | 2 +-
+ 3 files changed, 20 insertions(+), 10 deletions(-)
+
+diff --git a/src/core/service.c b/src/core/service.c
+index e538280bad..3c2f69a003 100644
+--- a/src/core/service.c
++++ b/src/core/service.c
+@@ -258,7 +258,17 @@ static void service_fd_store_unlink(ServiceFDStore *fs) {
+ free(fs);
+ }
+
+-static void service_release_resources(Unit *u) {
++static void service_release_fd_store(Service *s) {
++ assert(s);
++
++ log_unit_debug(UNIT(s)->id, "Releasing all stored fds");
++ while (s->fd_store)
++ service_fd_store_unlink(s->fd_store);
++
++ assert(s->n_fd_store == 0);
++}
++
++static void service_release_resources(Unit *u, bool inactive) {
+ Service *s = SERVICE(u);
+
+ assert(s);
+@@ -266,12 +276,10 @@ static void service_release_resources(Unit *u) {
+ if (!s->fd_store)
+ return;
+
+- log_debug("Releasing all resources for %s", u->id);
+-
+- while (s->fd_store)
+- service_fd_store_unlink(s->fd_store);
++ log_unit_debug(u->id, "Releasing resources.");
+
+- assert(s->n_fd_store == 0);
++ if (inactive)
++ service_release_fd_store(s);
+ }
+
+ static void service_done(Unit *u) {
+@@ -319,7 +327,7 @@ static void service_done(Unit *u) {
+
+ s->timer_event_source = sd_event_source_unref(s->timer_event_source);
+
+- service_release_resources(u);
++ service_release_resources(u, true);
+ }
+
+ static int on_fd_store_io(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
+diff --git a/src/core/unit.c b/src/core/unit.c
+index 0dc66203a4..22e31a76b3 100644
+--- a/src/core/unit.c
++++ b/src/core/unit.c
+@@ -285,6 +285,7 @@ int unit_set_description(Unit *u, const char *description) {
+
+ bool unit_may_gc(Unit *u) {
+ UnitActiveState state;
++ bool inactive;
+ assert(u);
+
+ /* Checks whether the unit is ready to be unloaded for garbage collection.
+@@ -302,16 +303,17 @@ bool unit_may_gc(Unit *u) {
+ return false;
+
+ state = unit_active_state(u);
++ inactive = state == UNIT_INACTIVE;
+
+ /* If the unit is inactive and failed and no job is queued for
+ * it, then release its runtime resources */
+ if (UNIT_IS_INACTIVE_OR_FAILED(state) &&
+ UNIT_VTABLE(u)->release_resources)
+- UNIT_VTABLE(u)->release_resources(u);
++ UNIT_VTABLE(u)->release_resources(u, inactive);
+
+ /* But we keep the unit object around for longer when it is
+ * referenced or configured to not be gc'ed */
+- if (state != UNIT_INACTIVE)
++ if (!inactive)
+ return false;
+
+ if (UNIT_VTABLE(u)->no_gc)
+diff --git a/src/core/unit.h b/src/core/unit.h
+index 719fc95260..232be8164f 100644
+--- a/src/core/unit.h
++++ b/src/core/unit.h
+@@ -360,7 +360,7 @@ struct UnitVTable {
+
+ /* When the unit is not running and no job for it queued we
+ * shall release its runtime resources */
+- void (*release_resources)(Unit *u);
++ void (*release_resources)(Unit *u, bool inactive);
+
+ /* Return true when this unit is suitable for snapshotting */
+ bool (*check_snapshot)(Unit *u);
diff --git a/SOURCES/0803-unit-rework-a-bit-how-we-keep-the-service-fdstore-fr.patch b/SOURCES/0803-unit-rework-a-bit-how-we-keep-the-service-fdstore-fr.patch
new file mode 100644
index 0000000..3dc70e2
--- /dev/null
+++ b/SOURCES/0803-unit-rework-a-bit-how-we-keep-the-service-fdstore-fr.patch
@@ -0,0 +1,170 @@
+From 9684908410868cb590ad74f4747bdbf9b5790abb Mon Sep 17 00:00:00 2001
+From: Lennart Poettering <lennart@poettering.net>
+Date: Mon, 13 Nov 2017 15:08:49 +0100
+Subject: [PATCH] unit: rework a bit how we keep the service fdstore from being
+ destroyed during service restart
+
+When preparing for a restart we quickly go through the DEAD/INACTIVE
+service state before entering AUTO_RESTART. When doing this, we need to
+make sure we don't destroy the FD store. Previously this was done by
+checking the failure state of the unit, and keeping the FD store around
+when the unit failed, under the assumption that the restart logic will
+then get into action.
+
+This is not entirely correct howver, as there might be failure states
+that will no result in restarts.
+
+With this commit we slightly alter the logic: a ref counter for the fd
+store is added, that is increased right before we handle the restart
+logic, and decreased again right-after.
+
+This should ensure that the fdstore lives exactly as long as it needs.
+
+Follow-up for f0bfbfac43b7faa68ef1bb2ad659c191b9ec85d2.
+
+(cherry picked from commit 7eb2a8a1259043e107ebec94e30ed160a93f40a7)
+(cherry picked from commit e2636bde0f07319d0d35262dac6ff2638ba4e598)
+Resolves: #1803802
+---
+ src/core/service.c | 23 ++++++++++++++++++-----
+ src/core/service.h | 1 +
+ src/core/unit.c | 12 ++++--------
+ src/core/unit.h | 5 ++---
+ 4 files changed, 25 insertions(+), 16 deletions(-)
+
+diff --git a/src/core/service.c b/src/core/service.c
+index 3c2f69a003..e32cdf4594 100644
+--- a/src/core/service.c
++++ b/src/core/service.c
+@@ -261,6 +261,9 @@ static void service_fd_store_unlink(ServiceFDStore *fs) {
+ static void service_release_fd_store(Service *s) {
+ assert(s);
+
++ if (s->n_keep_fd_store > 0)
++ return;
++
+ log_unit_debug(UNIT(s)->id, "Releasing all stored fds");
+ while (s->fd_store)
+ service_fd_store_unlink(s->fd_store);
+@@ -268,7 +271,7 @@ static void service_release_fd_store(Service *s) {
+ assert(s->n_fd_store == 0);
+ }
+
+-static void service_release_resources(Unit *u, bool inactive) {
++static void service_release_resources(Unit *u) {
+ Service *s = SERVICE(u);
+
+ assert(s);
+@@ -278,8 +281,7 @@ static void service_release_resources(Unit *u, bool inactive) {
+
+ log_unit_debug(u->id, "Releasing resources.");
+
+- if (inactive)
+- service_release_fd_store(s);
++ service_release_fd_store(s);
+ }
+
+ static void service_done(Unit *u) {
+@@ -327,7 +329,7 @@ static void service_done(Unit *u) {
+
+ s->timer_event_source = sd_event_source_unref(s->timer_event_source);
+
+- service_release_resources(u, true);
++ service_release_resources(u);
+ }
+
+ static int on_fd_store_io(sd_event_source *e, int fd, uint32_t revents, void *userdata) {
+@@ -1330,6 +1332,10 @@ static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart)
+ if (f != SERVICE_SUCCESS)
+ s->result = f;
+
++ /* Make sure service_release_resources() doesn't destroy our FD store, while we are changing through
++ * SERVICE_FAILED/SERVICE_DEAD before entering into SERVICE_AUTO_RESTART. */
++ s->n_keep_fd_store++;
++
+ service_set_state(s, s->result != SERVICE_SUCCESS ? SERVICE_FAILED : SERVICE_DEAD);
+
+ if (s->result != SERVICE_SUCCESS) {
+@@ -1351,12 +1357,19 @@ static void service_enter_dead(Service *s, ServiceResult f, bool allow_restart)
+ (!IN_SET(s->main_exec_status.code, CLD_KILLED, CLD_DUMPED) || !set_contains(s->restart_prevent_status.signal, INT_TO_PTR(s->main_exec_status.status)))) {
+
+ r = service_arm_timer(s, s->restart_usec);
+- if (r < 0)
++ if (r < 0) {
++ s->n_keep_fd_store--;
+ goto fail;
++ }
+
+ service_set_state(s, SERVICE_AUTO_RESTART);
+ }
+
++ /* The new state is in effect, let's decrease the fd store ref counter again. Let's also readd us to the GC
++ * queue, so that the fd store is possibly gc'ed again */
++ s->n_keep_fd_store--;
++ unit_add_to_gc_queue(UNIT(s));
++
+ s->forbid_restart = false;
+
+ /* We want fresh tmpdirs in case service is started again immediately */
+diff --git a/src/core/service.h b/src/core/service.h
+index 82938a1fc4..e5753f1f4c 100644
+--- a/src/core/service.h
++++ b/src/core/service.h
+@@ -215,6 +215,7 @@ struct Service {
+ ServiceFDStore *fd_store;
+ unsigned n_fd_store;
+ unsigned n_fd_store_max;
++ unsigned n_keep_fd_store;
+ };
+
+ extern const UnitVTable service_vtable;
+diff --git a/src/core/unit.c b/src/core/unit.c
+index 22e31a76b3..eff9fdbe70 100644
+--- a/src/core/unit.c
++++ b/src/core/unit.c
+@@ -285,7 +285,6 @@ int unit_set_description(Unit *u, const char *description) {
+
+ bool unit_may_gc(Unit *u) {
+ UnitActiveState state;
+- bool inactive;
+ assert(u);
+
+ /* Checks whether the unit is ready to be unloaded for garbage collection.
+@@ -303,17 +302,14 @@ bool unit_may_gc(Unit *u) {
+ return false;
+
+ state = unit_active_state(u);
+- inactive = state == UNIT_INACTIVE;
+
+- /* If the unit is inactive and failed and no job is queued for
+- * it, then release its runtime resources */
++ /* If the unit is inactive and failed and no job is queued for it, then release its runtime resources */
+ if (UNIT_IS_INACTIVE_OR_FAILED(state) &&
+ UNIT_VTABLE(u)->release_resources)
+- UNIT_VTABLE(u)->release_resources(u, inactive);
++ UNIT_VTABLE(u)->release_resources(u);
+
+- /* But we keep the unit object around for longer when it is
+- * referenced or configured to not be gc'ed */
+- if (!inactive)
++ /* But we keep the unit object around for longer when it is referenced or configured to not be gc'ed */
++ if (state != UNIT_INACTIVE)
+ return false;
+
+ if (UNIT_VTABLE(u)->no_gc)
+diff --git a/src/core/unit.h b/src/core/unit.h
+index 232be8164f..3b0fd8d9df 100644
+--- a/src/core/unit.h
++++ b/src/core/unit.h
+@@ -358,9 +358,8 @@ struct UnitVTable {
+ * even though nothing references it and it isn't active in any way. */
+ bool (*may_gc)(Unit *u);
+
+- /* When the unit is not running and no job for it queued we
+- * shall release its runtime resources */
+- void (*release_resources)(Unit *u, bool inactive);
++ /* When the unit is not running and no job for it queued we shall release its runtime resources */
++ void (*release_resources)(Unit *u);
+
+ /* Return true when this unit is suitable for snapshotting */
+ bool (*check_snapshot)(Unit *u);
diff --git a/SOURCES/0804-tests-add-basic-journal-test.patch b/SOURCES/0804-tests-add-basic-journal-test.patch
new file mode 100644
index 0000000..1455a61
--- /dev/null
+++ b/SOURCES/0804-tests-add-basic-journal-test.patch
@@ -0,0 +1,145 @@
+From c53791854050661d34417f12755837abd74d213a Mon Sep 17 00:00:00 2001
+From: Evgeny Vereshchagin <evvers@ya.ru>
+Date: Tue, 17 Nov 2015 11:21:23 +0000
+Subject: [PATCH] tests: add basic journal test
+
+(cherry picked from commit 1c36b4a73b876258fbe01fbe9bc9b750b7dcc9ce)
+(cherry picked from commit e974b9915ccc7bf56d23fd6fc67631990d893c89)
+Resolves: #1803802
+---
+ test/TEST-04-JOURNAL/Makefile | 1 +
+ test/TEST-04-JOURNAL/test-journal.sh | 18 +++++++
+ test/TEST-04-JOURNAL/test.sh | 76 ++++++++++++++++++++++++++++
+ test/test-functions | 2 +-
+ 4 files changed, 96 insertions(+), 1 deletion(-)
+ create mode 120000 test/TEST-04-JOURNAL/Makefile
+ create mode 100755 test/TEST-04-JOURNAL/test-journal.sh
+ create mode 100755 test/TEST-04-JOURNAL/test.sh
+
+diff --git a/test/TEST-04-JOURNAL/Makefile b/test/TEST-04-JOURNAL/Makefile
+new file mode 120000
+index 0000000000..e9f93b1104
+--- /dev/null
++++ b/test/TEST-04-JOURNAL/Makefile
+@@ -0,0 +1 @@
++../TEST-01-BASIC/Makefile
+\ No newline at end of file
+diff --git a/test/TEST-04-JOURNAL/test-journal.sh b/test/TEST-04-JOURNAL/test-journal.sh
+new file mode 100755
+index 0000000000..c75f396ceb
+--- /dev/null
++++ b/test/TEST-04-JOURNAL/test-journal.sh
+@@ -0,0 +1,18 @@
++#!/bin/bash
++
++set -x
++set -e
++set -o pipefail
++
++# Test stdout stream
++
++# Skip empty lines
++ID=$(journalctl --new-id128 | sed -n 2p)
++>/expected
++printf $'\n\n\n' | systemd-cat -t "$ID" --level-prefix false
++journalctl --flush
++journalctl -b -o cat -t "$ID" >/output
++cmp /expected /output
++
++touch /testok
++exit 0
+diff --git a/test/TEST-04-JOURNAL/test.sh b/test/TEST-04-JOURNAL/test.sh
+new file mode 100755
+index 0000000000..e37cb7d412
+--- /dev/null
++++ b/test/TEST-04-JOURNAL/test.sh
+@@ -0,0 +1,76 @@
++#!/bin/bash
++# -*- mode: shell-script; indent-tabs-mode: nil; sh-basic-offset: 4; -*-
++# ex: ts=8 sw=4 sts=4 et filetype=sh
++TEST_DESCRIPTION="Journal-related tests"
++
++. $TEST_BASE_DIR/test-functions
++
++check_result_qemu() {
++ ret=1
++ mkdir -p $TESTDIR/root
++ mount ${LOOPDEV}p1 $TESTDIR/root
++ [[ -e $TESTDIR/root/testok ]] && ret=0
++ [[ -f $TESTDIR/root/failed ]] && cp -a $TESTDIR/root/failed $TESTDIR
++ cp -a $TESTDIR/root/var/log/journal $TESTDIR
++ umount $TESTDIR/root
++ [[ -f $TESTDIR/failed ]] && cat $TESTDIR/failed
++ ls -l $TESTDIR/journal/*/*.journal
++ test -s $TESTDIR/failed && ret=$(($ret+1))
++ return $ret
++}
++
++test_run() {
++ if run_qemu; then
++ check_result_qemu || return 1
++ else
++ dwarn "can't run QEMU, skipping"
++ fi
++ if check_nspawn; then
++ run_nspawn
++ check_result_nspawn || return 1
++ else
++ dwarn "can't run systemd-nspawn, skipping"
++ fi
++ return 0
++}
++
++test_setup() {
++ create_empty_image
++ mkdir -p $TESTDIR/root
++ mount ${LOOPDEV}p1 $TESTDIR/root
++
++ # Create what will eventually be our root filesystem onto an overlay
++ (
++ LOG_LEVEL=5
++ eval $(udevadm info --export --query=env --name=${LOOPDEV}p2)
++
++ setup_basic_environment
++
++ # setup the testsuite service
++ cat >$initdir/etc/systemd/system/testsuite.service <<EOF
++[Unit]
++Description=Testsuite service
++After=multi-user.target
++
++[Service]
++ExecStart=/test-journal.sh
++Type=oneshot
++EOF
++
++ cp test-journal.sh $initdir/
++
++ setup_testsuite
++ )
++ setup_nspawn_root
++
++ ddebug "umount $TESTDIR/root"
++ umount $TESTDIR/root
++}
++
++test_cleanup() {
++ umount $TESTDIR/root 2>/dev/null
++ [[ $LOOPDEV ]] && losetup -d $LOOPDEV
++ return 0
++}
++
++do_test "$@"
+diff --git a/test/test-functions b/test/test-functions
+index e50ce556fd..d5e9650903 100644
+--- a/test/test-functions
++++ b/test/test-functions
+@@ -12,7 +12,7 @@ if ! ROOTLIBDIR=$(pkg-config --variable=systemdutildir systemd); then
+ ROOTLIBDIR=/usr/lib/systemd
+ fi
+
+-BASICTOOLS="test sh bash setsid loadkeys setfont login sulogin gzip sleep echo mount umount cryptsetup date dmsetup modprobe chmod chown ln"
++BASICTOOLS="test sh bash setsid loadkeys setfont login sulogin gzip sleep echo mount umount cryptsetup date dmsetup modprobe chmod chown ln sed cmp tee"
+ DEBUGTOOLS="df free ls stty cat ps ln ip route dmesg dhclient mkdir cp ping dhclient strace less grep id tty touch du sort hostname"
+
+ function find_qemu_bin() {
diff --git a/SOURCES/0805-tests-add-regression-test-for-systemctl-restart-syst.patch b/SOURCES/0805-tests-add-regression-test-for-systemctl-restart-syst.patch
new file mode 100644
index 0000000..725665c
--- /dev/null
+++ b/SOURCES/0805-tests-add-regression-test-for-systemctl-restart-syst.patch
@@ -0,0 +1,54 @@
+From e3468af46bd16e3550c25a0770f47f0bf21780f3 Mon Sep 17 00:00:00 2001
+From: Evgeny Vereshchagin <evvers@ya.ru>
+Date: Wed, 30 Dec 2015 03:33:43 +0000
+Subject: [PATCH] tests: add regression test for `systemctl restart
+ systemd-journald`
+
+See https://github.com/systemd/systemd/issues/2236
+
+(cherry picked from commit 3889613ec6bc54b9e02955f62b9d5c5b571c3d4b)
+(cherry picked from commit 4dc893c03fe9c56a3d3070fb8583f5584014aa49)
+Resolves: #1803802
+---
+ test/TEST-04-JOURNAL/test-journal.sh | 8 ++++++++
+ test/TEST-04-JOURNAL/test.sh | 9 +++++++++
+ 2 files changed, 17 insertions(+)
+
+diff --git a/test/TEST-04-JOURNAL/test-journal.sh b/test/TEST-04-JOURNAL/test-journal.sh
+index c75f396ceb..701b0cf724 100755
+--- a/test/TEST-04-JOURNAL/test-journal.sh
++++ b/test/TEST-04-JOURNAL/test-journal.sh
+@@ -14,5 +14,13 @@ journalctl --flush
+ journalctl -b -o cat -t "$ID" >/output
+ cmp /expected /output
+
++# Don't lose streams on restart
++systemctl start forever-print-hola
++sleep 3
++systemctl restart systemd-journald
++sleep 3
++systemctl stop forever-print-hola
++[[ ! -f "/i-lose-my-logs" ]]
++
+ touch /testok
+ exit 0
+diff --git a/test/TEST-04-JOURNAL/test.sh b/test/TEST-04-JOURNAL/test.sh
+index e37cb7d412..6aea67ba4e 100755
+--- a/test/TEST-04-JOURNAL/test.sh
++++ b/test/TEST-04-JOURNAL/test.sh
+@@ -55,6 +55,15 @@ After=multi-user.target
+ [Service]
+ ExecStart=/test-journal.sh
+ Type=oneshot
++EOF
++
++ cat >$initdir/etc/systemd/system/forever-print-hola.service <<EOF
++[Unit]
++Description=ForeverPrintHola service
++
++[Service]
++Type=simple
++ExecStart=/bin/sh -x -c 'while :; do printf "Hola\n" || touch /i-lose-my-logs; sleep 1; done'
+ EOF
+
+ cp test-journal.sh $initdir/
diff --git a/SOURCES/0806-tests-add-test-that-journald-keeps-fds-over-terminat.patch b/SOURCES/0806-tests-add-test-that-journald-keeps-fds-over-terminat.patch
new file mode 100644
index 0000000..a19853b
--- /dev/null
+++ b/SOURCES/0806-tests-add-test-that-journald-keeps-fds-over-terminat.patch
@@ -0,0 +1,33 @@
+From 39ab4de70c6f2b35ec735195803f4bd1eb5892c1 Mon Sep 17 00:00:00 2001
+From: Evgeny Vereshchagin <evvers@ya.ru>
+Date: Thu, 20 Oct 2016 13:18:12 +0000
+Subject: [PATCH] tests: add test that journald keeps fds over termination by
+ signal
+
+This test fails before previous commit, and passes with it.
+
+(cherry picked from commit bff653e3970bb79832568ae86b095ee530b62302)
+(cherry picked from commit ee8f69ae5ddac6f05c56ea7dbcb76fbbb2e355ee)
+Resolves: #1803802
+---
+ test/TEST-04-JOURNAL/test-journal.sh | 8 ++++++++
+ 1 file changed, 8 insertions(+)
+
+diff --git a/test/TEST-04-JOURNAL/test-journal.sh b/test/TEST-04-JOURNAL/test-journal.sh
+index 701b0cf724..d0b05c46d6 100755
+--- a/test/TEST-04-JOURNAL/test-journal.sh
++++ b/test/TEST-04-JOURNAL/test-journal.sh
+@@ -22,5 +22,13 @@ sleep 3
+ systemctl stop forever-print-hola
+ [[ ! -f "/i-lose-my-logs" ]]
+
++# https://github.com/systemd/systemd/issues/4408
++rm -f /i-lose-my-logs
++systemctl start forever-print-hola
++sleep 3
++systemctl kill --signal=SIGKILL systemd-journald
++sleep 3
++[[ ! -f "/i-lose-my-logs" ]]
++
+ touch /testok
+ exit 0
diff --git a/SOURCES/0807-journal-do-not-trigger-assertion-when-journal_file_c.patch b/SOURCES/0807-journal-do-not-trigger-assertion-when-journal_file_c.patch
new file mode 100644
index 0000000..0910c9f
--- /dev/null
+++ b/SOURCES/0807-journal-do-not-trigger-assertion-when-journal_file_c.patch
@@ -0,0 +1,50 @@
+From d8c33d7a4e0d9b4375159776913f5c3fd2905c21 Mon Sep 17 00:00:00 2001
+From: Jan Synacek <jsynacek@redhat.com>
+Date: Tue, 7 Jan 2020 11:22:26 +0100
+Subject: [PATCH] journal: do not trigger assertion when journal_file_close()
+ get NULL
+
+We generally expect destructors to not complain if a NULL argument is passed.
+
+Closes #12400.
+
+(cherry picked from commit c377a6f3ad3d9bed4ce7e873e8e9ec6b1650c57d)
+(cherry picked from commit 248925c68092bab7ce0231449176db153f55d818)
+Resolves: #1807798
+---
+ src/journal/journal-file.c | 3 ++-
+ src/journal/journald-server.c | 7 ++-----
+ 2 files changed, 4 insertions(+), 6 deletions(-)
+
+diff --git a/src/journal/journal-file.c b/src/journal/journal-file.c
+index 586f620e21..cf8dad3fcd 100644
+--- a/src/journal/journal-file.c
++++ b/src/journal/journal-file.c
+@@ -129,7 +129,8 @@ int journal_file_set_offline(JournalFile *f) {
+ }
+
+ void journal_file_close(JournalFile *f) {
+- assert(f);
++ if (!f)
++ return;
+
+ #ifdef HAVE_GCRYPT
+ /* Write the final tag */
+diff --git a/src/journal/journald-server.c b/src/journal/journald-server.c
+index aaabb2f7ab..ffe2daa7be 100644
+--- a/src/journal/journald-server.c
++++ b/src/journal/journald-server.c
+@@ -1933,11 +1933,8 @@ void server_done(Server *s) {
+ while (s->stdout_streams)
+ stdout_stream_free(s->stdout_streams);
+
+- if (s->system_journal)
+- journal_file_close(s->system_journal);
+-
+- if (s->runtime_journal)
+- journal_file_close(s->runtime_journal);
++ (void) journal_file_close(s->system_journal);
++ (void) journal_file_close(s->runtime_journal);
+
+ while ((f = ordered_hashmap_steal_first(s->user_journals)))
+ journal_file_close(f);
diff --git a/SOURCES/0808-mount-don-t-propagate-errors-from-mount_setup_unit-f.patch b/SOURCES/0808-mount-don-t-propagate-errors-from-mount_setup_unit-f.patch
new file mode 100644
index 0000000..a8de335
--- /dev/null
+++ b/SOURCES/0808-mount-don-t-propagate-errors-from-mount_setup_unit-f.patch
@@ -0,0 +1,53 @@
+From 5b7b538fcd268288cea8d8b7f16f839afbf74f39 Mon Sep 17 00:00:00 2001
+From: Lennart Poettering <lennart@poettering.net>
+Date: Wed, 28 Nov 2018 12:41:44 +0100
+Subject: [PATCH] mount: don't propagate errors from mount_setup_unit() further
+ up
+
+If we can't process a specific line in /proc/self/mountinfo we should
+log about it (which we do), but this should not affect other lines, nor
+further processing of mount units. Let's keep these failures local.
+
+Fixes: #10874
+(cherry picked from commit ba0d56f55f2073164799be714b5bd1aad94d059a)
+Resolves: #1809159
+---
+ src/core/mount.c | 9 +++------
+ 1 file changed, 3 insertions(+), 6 deletions(-)
+
+diff --git a/src/core/mount.c b/src/core/mount.c
+index 3167bd6bb1..126038c27f 100644
+--- a/src/core/mount.c
++++ b/src/core/mount.c
+@@ -1571,7 +1571,7 @@ fail:
+ static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
+ _cleanup_(mnt_free_tablep) struct libmnt_table *t = NULL;
+ _cleanup_(mnt_free_iterp) struct libmnt_iter *i = NULL;
+- int r = 0;
++ int r;
+
+ assert(m);
+
+@@ -1587,7 +1587,6 @@ static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
+ if (r < 0)
+ return log_error_errno(r, "Failed to parse /proc/self/mountinfo: %m");
+
+- r = 0;
+ for (;;) {
+ const char *device, *path, *options, *fstype;
+ _cleanup_free_ const char *d = NULL, *p = NULL;
+@@ -1615,12 +1614,10 @@ static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
+
+ (void) device_found_node(m, d, true, DEVICE_FOUND_MOUNT, set_flags);
+
+- k = mount_setup_unit(m, d, p, options, fstype, set_flags);
+- if (r == 0 && k < 0)
+- r = k;
++ (void) mount_setup_unit(m, d, p, options, fstype, set_flags);
+ }
+
+- return r;
++ return 0;
+ }
+
+ static void mount_shutdown(Manager *m) {
diff --git a/SOURCES/0809-mount-when-allocating-a-Mount-object-based-on-proc-s.patch b/SOURCES/0809-mount-when-allocating-a-Mount-object-based-on-proc-s.patch
new file mode 100644
index 0000000..d689d1a
--- /dev/null
+++ b/SOURCES/0809-mount-when-allocating-a-Mount-object-based-on-proc-s.patch
@@ -0,0 +1,35 @@
+From 58407f55ccfc83eef2bd14e672d13213ef93069d Mon Sep 17 00:00:00 2001
+From: Lennart Poettering <lennart@poettering.net>
+Date: Wed, 28 Nov 2018 14:51:04 +0100
+Subject: [PATCH] mount: when allocating a Mount object based on
+ /proc/self/mountinfo mark it so
+
+Let's set 'from_proc_self_mountinfo' right away, since we know its from
+there. This is important so that when the load queue is dispatched (and
+thus mount_load() called) this
+fact is already known.
+
+(cherry picked from commit 6d7e89b07065b8c49af47aaf1ccc336d017fc3a2)
+Related: #1809159
+---
+ src/core/mount.c | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/src/core/mount.c b/src/core/mount.c
+index 126038c27f..34c4b548ad 100644
+--- a/src/core/mount.c
++++ b/src/core/mount.c
+@@ -1480,6 +1480,13 @@ static int mount_setup_unit(
+ }
+ }
+
++ /* This unit was generated because /proc/self/mountinfo reported it. Remember this, so that by the time we load
++ * the unit file for it (and thus add in extra deps right after) we know what source to attributes the deps
++ * to.*/
++ MOUNT(u)->from_proc_self_mountinfo = true;
++
++ /* We have only allocated the stub now, let's enqueue this unit for loading now, so that everything else is
++ * loaded in now. */
+ unit_add_to_load_queue(u);
+ changed = true;
+ } else {
diff --git a/SOURCES/0810-core-enforce-a-ratelimiter-when-stopping-units-due-t.patch b/SOURCES/0810-core-enforce-a-ratelimiter-when-stopping-units-due-t.patch
new file mode 100644
index 0000000..3d94ec4
--- /dev/null
+++ b/SOURCES/0810-core-enforce-a-ratelimiter-when-stopping-units-due-t.patch
@@ -0,0 +1,60 @@
+From f57ee0c7862260f3c7054b224f360cdef5140685 Mon Sep 17 00:00:00 2001
+From: Lennart Poettering <lennart@poettering.net>
+Date: Tue, 19 May 2015 16:00:24 +0200
+Subject: [PATCH] core: enforce a ratelimiter when stopping units due to
+ StopWhenUnneeded=1
+
+Otherwise we might end up in an endless stop loop.
+
+http://lists.freedesktop.org/archives/systemd-devel/2015-April/030224.html
+(cherry picked from commit bea355dac94e82697aa98e25d80ee4248263bf92)
+(cherry picked from commit 6c72a575c7c61e17c8e96b23042f7b4a5ac39339)
+
+Related: #1810576
+---
+ src/core/unit.c | 10 ++++++++++
+ src/core/unit.h | 3 +++
+ 2 files changed, 13 insertions(+)
+
+diff --git a/src/core/unit.c b/src/core/unit.c
+index eff9fdbe70..583b9fae28 100644
+--- a/src/core/unit.c
++++ b/src/core/unit.c
+@@ -97,6 +97,8 @@ Unit *unit_new(Manager *m, size_t size) {
+ u->on_failure_job_mode = JOB_REPLACE;
+ u->sigchldgen = 0;
+
++ RATELIMIT_INIT(u->check_unneeded_ratelimit, 10 * USEC_PER_SEC, 16);
++
+ return u;
+ }
+
+@@ -1594,6 +1596,14 @@ static void unit_check_unneeded(Unit *u) {
+ if (unit_active_or_pending(other))
+ return;
+
++ /* If stopping a unit fails continously we might enter a stop
++ * loop here, hence stop acting on the service being
++ * unnecessary after a while. */
++ if (!ratelimit_test(&u->check_unneeded_ratelimit)) {
++ log_unit_warning(u->id, "Unit not needed anymore, but not stopping since we tried this too often recently.");
++ return;
++ }
++
+ log_unit_info(u->id, "Unit %s is not needed anymore. Stopping.", u->id);
+
+ /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
+diff --git a/src/core/unit.h b/src/core/unit.h
+index 3b0fd8d9df..29353ea81c 100644
+--- a/src/core/unit.h
++++ b/src/core/unit.h
+@@ -185,6 +185,9 @@ struct Unit {
+ /* Error code when we didn't manage to load the unit (negative) */
+ int load_error;
+
++ /* Make sure we never enter endless loops with the check unneeded logic */
++ RateLimit check_unneeded_ratelimit;
++
+ /* Cached unit file state and preset */
+ UnitFileState unit_file_state;
+ int unit_file_preset;
diff --git a/SOURCES/0811-core-rework-StopWhenUnneeded-logic.patch b/SOURCES/0811-core-rework-StopWhenUnneeded-logic.patch
new file mode 100644
index 0000000..cc78e66
--- /dev/null
+++ b/SOURCES/0811-core-rework-StopWhenUnneeded-logic.patch
@@ -0,0 +1,343 @@
+From c7c8a7648623a25c00dc585bd42b9037a20396c8 Mon Sep 17 00:00:00 2001
+From: Lennart Poettering <lennart@poettering.net>
+Date: Thu, 9 Aug 2018 16:26:27 +0200
+Subject: [PATCH] core: rework StopWhenUnneeded= logic
+
+Previously, we'd act immediately on StopWhenUnneeded= when a unit state
+changes. With this rework we'll maintain a queue instead: whenever
+there's the chance that StopWhenUneeded= might have an effect we enqueue
+the unit, and process it later when we have nothing better to do.
+
+This should make the implementation a bit more reliable, as the unit notify event
+cannot immediately enqueue tons of side-effect jobs that might
+contradict each other, but we do so only in a strictly ordered fashion,
+from the main event loop.
+
+This slightly changes the check when to consider a unit "unneeded".
+Previously, we'd assume that a unit in "deactivating" state could also
+be cleaned up. With this new logic we'll only consider units unneeded
+that are fully up and have no job queued. This means that whenever
+there's something pending for a unit we won't clean it up.
+
+(cherry picked from commit a3c1168ac293f16d9343d248795bb4c246aaff4a)
+(cherry picked from commit 65ebf5e453846e29ab5894670a83b5d8b942c858)
+
+Resolves: #1810576
+---
+ src/core/manager.c | 43 +++++++++++++++
+ src/core/manager.h | 3 ++
+ src/core/unit.c | 132 ++++++++++++++++++++++++---------------------
+ src/core/unit.h | 7 +++
+ 4 files changed, 124 insertions(+), 61 deletions(-)
+
+diff --git a/src/core/manager.c b/src/core/manager.c
+index 4c87ad8a2f..f0553b4df9 100644
+--- a/src/core/manager.c
++++ b/src/core/manager.c
+@@ -961,6 +961,45 @@ static unsigned manager_dispatch_gc_queue(Manager *m) {
+ return n;
+ }
+
++static unsigned manager_dispatch_stop_when_unneeded_queue(Manager *m) {
++ unsigned n = 0;
++ Unit *u;
++ int r;
++
++ assert(m);
++
++ while ((u = m->stop_when_unneeded_queue)) {
++ _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
++ assert(m->stop_when_unneeded_queue);
++
++ assert(u->in_stop_when_unneeded_queue);
++ LIST_REMOVE(stop_when_unneeded_queue, m->stop_when_unneeded_queue, u);
++ u->in_stop_when_unneeded_queue = false;
++
++ n++;
++
++ if (!unit_is_unneeded(u))
++ continue;
++
++ log_unit_debug(u->id, "Unit is not needed anymore.");
++
++ /* If stopping a unit fails continuously we might enter a stop loop here, hence stop acting on the
++ * service being unnecessary after a while. */
++
++ if (!ratelimit_test(&u->check_unneeded_ratelimit)) {
++ log_unit_warning(u->id, "Unit not needed anymore, but not stopping since we tried this too often recently.");
++ continue;
++ }
++
++ /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
++ r = manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, &error, NULL);
++ if (r < 0)
++ log_unit_warning_errno(u->id, r, "Failed to enqueue stop job, ignoring: %s", bus_error_message(&error, r));
++ }
++
++ return n;
++}
++
+ static void manager_clear_jobs_and_units(Manager *m) {
+ Unit *u;
+
+@@ -977,6 +1016,7 @@ static void manager_clear_jobs_and_units(Manager *m) {
+ assert(!m->dbus_job_queue);
+ assert(!m->cleanup_queue);
+ assert(!m->gc_queue);
++ assert(!m->stop_when_unneeded_queue);
+
+ assert(hashmap_isempty(m->jobs));
+ assert(hashmap_isempty(m->units));
+@@ -2259,6 +2299,9 @@ int manager_loop(Manager *m) {
+ if (manager_dispatch_cgroup_queue(m) > 0)
+ continue;
+
++ if (manager_dispatch_stop_when_unneeded_queue(m) > 0)
++ continue;
++
+ if (manager_dispatch_dbus_queue(m) > 0)
+ continue;
+
+diff --git a/src/core/manager.h b/src/core/manager.h
+index cfc564dfb6..f9280956e9 100644
+--- a/src/core/manager.h
++++ b/src/core/manager.h
+@@ -117,6 +117,9 @@ struct Manager {
+ /* Target units whose default target dependencies haven't been set yet */
+ LIST_HEAD(Unit, target_deps_queue);
+
++ /* Units that might be subject to StopWhenUnneeded= clean-up */
++ LIST_HEAD(Unit, stop_when_unneeded_queue);
++
+ sd_event *event;
+
+ /* We use two hash tables here, since the same PID might be
+diff --git a/src/core/unit.c b/src/core/unit.c
+index 583b9fae28..dc2df4c89c 100644
+--- a/src/core/unit.c
++++ b/src/core/unit.c
+@@ -380,6 +380,22 @@ void unit_add_to_dbus_queue(Unit *u) {
+ u->in_dbus_queue = true;
+ }
+
++void unit_add_to_stop_when_unneeded_queue(Unit *u) {
++ assert(u);
++
++ if (u->in_stop_when_unneeded_queue)
++ return;
++
++ if (!u->stop_when_unneeded)
++ return;
++
++ if (!UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
++ return;
++
++ LIST_PREPEND(stop_when_unneeded_queue, u->manager->stop_when_unneeded_queue, u);
++ u->in_stop_when_unneeded_queue = true;
++}
++
+ static void bidi_set_free(Unit *u, Set *s) {
+ Iterator i;
+ Unit *other;
+@@ -544,6 +560,9 @@ void unit_free(Unit *u) {
+ u->manager->n_in_gc_queue--;
+ }
+
++ if (u->in_stop_when_unneeded_queue)
++ LIST_REMOVE(stop_when_unneeded_queue, u->manager->stop_when_unneeded_queue, u);
++
+ if (u->on_console)
+ manager_unref_console(u->manager);
+
+@@ -1565,49 +1584,68 @@ bool unit_can_reload(Unit *u) {
+ return UNIT_VTABLE(u)->can_reload(u);
+ }
+
+-static void unit_check_unneeded(Unit *u) {
+- Iterator i;
+- Unit *other;
++bool unit_is_unneeded(Unit *u) {
++ static const UnitDependency deps[] = {
++ UNIT_REQUIRED_BY,
++ UNIT_REQUIRED_BY_OVERRIDABLE,
++ UNIT_WANTED_BY,
++ UNIT_BOUND_BY,
++ };
++ size_t j;
+
+ assert(u);
+
+- /* If this service shall be shut down when unneeded then do
+- * so. */
+-
+ if (!u->stop_when_unneeded)
+- return;
++ return false;
+
+- if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
+- return;
++ /* Don't clean up while the unit is transitioning or is even inactive. */
++ if (!UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
++ return false;
++ if (u->job)
++ return false;
+
+- SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
+- if (unit_active_or_pending(other))
+- return;
++ for (j = 0; j < ELEMENTSOF(deps); j++) {
++ Unit *other;
++ Iterator i;
+
+- SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
+- if (unit_active_or_pending(other))
+- return;
++ /* If a dependending unit has a job queued, or is active (or in transitioning), or is marked for
++ * restart, then don't clean this one up. */
+
+- SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
+- if (unit_active_or_pending(other))
+- return;
++ SET_FOREACH(other, u->dependencies[deps[j]], i) {
++ if (u->job)
++ return false;
+
+- SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
+- if (unit_active_or_pending(other))
+- return;
+-
+- /* If stopping a unit fails continously we might enter a stop
+- * loop here, hence stop acting on the service being
+- * unnecessary after a while. */
+- if (!ratelimit_test(&u->check_unneeded_ratelimit)) {
+- log_unit_warning(u->id, "Unit not needed anymore, but not stopping since we tried this too often recently.");
+- return;
++ if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
++ return false;
++ }
+ }
+
+- log_unit_info(u->id, "Unit %s is not needed anymore. Stopping.", u->id);
++ return true;
++}
+
+- /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
+- manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
++static void check_unneeded_dependencies(Unit *u) {
++
++ static const UnitDependency deps[] = {
++ UNIT_REQUIRES,
++ UNIT_REQUIRES_OVERRIDABLE,
++ UNIT_REQUISITE,
++ UNIT_REQUISITE_OVERRIDABLE,
++ UNIT_WANTS,
++ UNIT_BINDS_TO,
++ };
++ size_t j;
++
++ assert(u);
++
++ /* Add all units this unit depends on to the queue that processes StopWhenUnneeded= behaviour. */
++
++ for (j = 0; j < ELEMENTSOF(deps); j++) {
++ Unit *other;
++ Iterator i;
++
++ SET_FOREACH(other, u->dependencies[deps[j]], i)
++ unit_add_to_stop_when_unneeded_queue(other);
++ }
+ }
+
+ static void unit_check_binds_to(Unit *u) {
+@@ -1693,34 +1731,6 @@ static void retroactively_stop_dependencies(Unit *u) {
+ manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
+ }
+
+-static void check_unneeded_dependencies(Unit *u) {
+- Iterator i;
+- Unit *other;
+-
+- assert(u);
+- assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
+-
+- /* Garbage collect services that might not be needed anymore, if enabled */
+- SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
+- if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+- unit_check_unneeded(other);
+- SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
+- if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+- unit_check_unneeded(other);
+- SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
+- if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+- unit_check_unneeded(other);
+- SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
+- if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+- unit_check_unneeded(other);
+- SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
+- if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+- unit_check_unneeded(other);
+- SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
+- if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
+- unit_check_unneeded(other);
+-}
+-
+ void unit_start_on_failure(Unit *u) {
+ Unit *other;
+ Iterator i;
+@@ -1898,7 +1908,7 @@ void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_su
+ }
+
+ /* stop unneeded units regardless if going down was expected or not */
+- if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
++ if (UNIT_IS_INACTIVE_OR_FAILED(ns))
+ check_unneeded_dependencies(u);
+
+ if (ns != os && ns == UNIT_FAILED) {
+@@ -1959,7 +1969,7 @@ void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_su
+ if (u->manager->n_reloading <= 0) {
+ /* Maybe we finished startup and are now ready for
+ * being stopped because unneeded? */
+- unit_check_unneeded(u);
++ unit_add_to_stop_when_unneeded_queue(u);
+
+ /* Maybe we finished startup, but something we needed
+ * has vanished? Let's die then. (This happens when
+diff --git a/src/core/unit.h b/src/core/unit.h
+index 29353ea81c..38c97397ee 100644
+--- a/src/core/unit.h
++++ b/src/core/unit.h
+@@ -165,6 +165,9 @@ struct Unit {
+ /* Target dependencies queue */
+ LIST_FIELDS(Unit, target_deps_queue);
+
++ /* Queue of units with StopWhenUnneeded set that shell be checked for clean-up. */
++ LIST_FIELDS(Unit, stop_when_unneeded_queue);
++
+ /* PIDs we keep an eye on. Note that a unit might have many
+ * more, but these are the ones we care enough about to
+ * process SIGCHLD for */
+@@ -235,6 +238,7 @@ struct Unit {
+ bool in_gc_queue:1;
+ bool in_cgroup_queue:1;
+ bool in_target_deps_queue:1;
++ bool in_stop_when_unneeded_queue:1;
+
+ bool sent_dbus_new_signal:1;
+
+@@ -508,6 +512,7 @@ void unit_add_to_dbus_queue(Unit *u);
+ void unit_add_to_cleanup_queue(Unit *u);
+ void unit_add_to_gc_queue(Unit *u);
+ void unit_add_to_target_deps_queue(Unit *u);
++void unit_add_to_stop_when_unneeded_queue(Unit *u);
+
+ int unit_merge(Unit *u, Unit *other);
+ int unit_merge_by_name(Unit *u, const char *other);
+@@ -627,6 +632,8 @@ int unit_make_transient(Unit *u);
+
+ int unit_require_mounts_for(Unit *u, const char *path);
+
++bool unit_is_unneeded(Unit *u);
++
+ pid_t unit_control_pid(Unit *u);
+ pid_t unit_main_pid(Unit *u);
+
diff --git a/SOURCES/0812-fix-the-fix-for-1691511.patch b/SOURCES/0812-fix-the-fix-for-1691511.patch
new file mode 100644
index 0000000..95f38e7
--- /dev/null
+++ b/SOURCES/0812-fix-the-fix-for-1691511.patch
@@ -0,0 +1,53 @@
+From 659b97b93d93ad05732831f6f097cf6f2a9c6410 Mon Sep 17 00:00:00 2001
+From: David Tardon <dtardon@redhat.com>
+Date: Mon, 16 Mar 2020 09:37:22 +0100
+Subject: [PATCH] fix the fix for #1691511
+
+The fix for #1691511 should have been used only for existing mounts
+(mount_setup_existing_unit() in current master).
+
+(cherry picked from commit 4584818bea998d257a166c238b829025b6138e55)
+
+Related: #1809159
+---
+ src/core/mount.c | 6 +++++-
+ 1 file changed, 5 insertions(+), 1 deletion(-)
+
+diff --git a/src/core/mount.c b/src/core/mount.c
+index 34c4b548ad..56fda1b73f 100644
+--- a/src/core/mount.c
++++ b/src/core/mount.c
+@@ -1416,6 +1416,7 @@ static int mount_setup_unit(
+ bool load_extras = false;
+ MountParameters *p;
+ bool delete, changed = false;
++ bool just_mounted;
+ Unit *u;
+ int r;
+
+@@ -1489,6 +1490,7 @@ static int mount_setup_unit(
+ * loaded in now. */
+ unit_add_to_load_queue(u);
+ changed = true;
++ just_mounted = true;
+ } else {
+ delete = false;
+
+@@ -1518,6 +1520,8 @@ static int mount_setup_unit(
+ load_extras = true;
+ changed = true;
+ }
++
++ just_mounted = !MOUNT(u)->from_proc_self_mountinfo || MOUNT(u)->just_mounted;
+ }
+
+ w = strdup(what);
+@@ -1537,7 +1541,7 @@ static int mount_setup_unit(
+
+ if (set_flags) {
+ MOUNT(u)->is_mounted = true;
+- MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo || MOUNT(u)->just_mounted;
++ MOUNT(u)->just_mounted = just_mounted;
+ MOUNT(u)->just_changed = changed;
+ }
+
diff --git a/SPECS/systemd.spec b/SPECS/systemd.spec
index fbe65dd..46894de 100644
--- a/SPECS/systemd.spec
+++ b/SPECS/systemd.spec
@@ -7,7 +7,7 @@
Name: systemd
Url: http://www.freedesktop.org/wiki/Software/systemd
Version: 219
-Release: 73%{?dist}.1
+Release: 73%{?dist}.5
# For a breakdown of the licensing, see README
License: LGPLv2+ and MIT and GPLv2+
Summary: A System and Service Manager
@@ -840,6 +840,17 @@ Patch0798: 0798-Call-getgroups-to-know-size-of-supplementary-groups-.patch
Patch0799: 0799-udev-introduce-CONST-key-name.patch
Patch0800: 0800-path-stop-watching-path-specs-once-we-triggered-the-.patch
Patch0801: 0801-unit-fix-potential-use-of-cgroup_path-after-free-whe.patch
+Patch0802: 0802-core-when-restarting-services-don-t-close-fds.patch
+Patch0803: 0803-unit-rework-a-bit-how-we-keep-the-service-fdstore-fr.patch
+Patch0804: 0804-tests-add-basic-journal-test.patch
+Patch0805: 0805-tests-add-regression-test-for-systemctl-restart-syst.patch
+Patch0806: 0806-tests-add-test-that-journald-keeps-fds-over-terminat.patch
+Patch0807: 0807-journal-do-not-trigger-assertion-when-journal_file_c.patch
+Patch0808: 0808-mount-don-t-propagate-errors-from-mount_setup_unit-f.patch
+Patch0809: 0809-mount-when-allocating-a-Mount-object-based-on-proc-s.patch
+Patch0810: 0810-core-enforce-a-ratelimiter-when-stopping-units-due-t.patch
+Patch0811: 0811-core-rework-StopWhenUnneeded-logic.patch
+Patch0812: 0812-fix-the-fix-for-1691511.patch
%global num_patches %{lua: c=0; for i,p in ipairs(patches) do c=c+1; end; print(c);}
@@ -1817,6 +1828,25 @@ fi
%{_mandir}/man8/systemd-resolved.*
%changelog
+* Tue Mar 17 2020 systemd maintenance team <systemd-maint@redhat.com> - 219-73.5
+- core: enforce a ratelimiter when stopping units due to StopWhenUnneeded=1 (#1810576)
+- core: rework StopWhenUnneeded= logic (#1810576)
+- fix the fix for #1691511 (#1809159)
+
+* Thu Mar 12 2020 systemd maintenance team <systemd-maint@redhat.com> - 219-73.4
+- mount: don't propagate errors from mount_setup_unit() further up (#1809159)
+- mount: when allocating a Mount object based on /proc/self/mountinfo mark it so (#1809159)
+
+* Thu Mar 05 2020 systemd maintenance team <systemd-maint@redhat.com> - 219-73.3
+- journal: do not trigger assertion when journal_file_close() get NULL (#1807798)
+
+* Tue Feb 18 2020 systemd maintenance team <systemd-maint@redhat.com> - 219-73.2
+- core: when restarting services, don't close fds (#1803802)
+- unit: rework a bit how we keep the service fdstore from being destroyed during service restart (#1803802)
+- tests: add basic journal test (#1803802)
+- tests: add regression test for `systemctl restart systemd-journald` (#1803802)
+- tests: add test that journald keeps fds over termination by signal (#1803802)
+
* Fri Nov 29 2019 Lukas Nykryn <lnykryn@redhat.com> - 219-73.1
- unit: fix potential use of cgroup_path after free() when freeing unit (#1760149)