From: Daan De Meyer <daan.j.demeyer@gmail.com>
Date: Mon, 20 Mar 2023 12:26:57 +0000 (+0100)
Subject: core: Settle log target if we're going to be closing all fds
X-Git-Tag: v254-rc1~956
X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=a3b00f91bb985fa10bc33db5c7883e33dbdf83d0;p=thirdparty%2Fsystemd.git

core: Settle log target if we're going to be closing all fds

Whenever we're going to close all file descriptors, we tend to close
the log and set it into open when needed mode. When this is done with
the logging target set to LOG_TARGET_AUTO, we run into issues because
for every logging call, we'll check if stderr is connected to the
journal to determine where to send the logging message. This check
obviously stops working when we close stderr, so we settle the log
target before we do that so that we keep using the same logging
target even after stderr is closed.
---

diff --git a/src/activate/activate.c b/src/activate/activate.c
index ea141c54bdf..4a639703260 100644
--- a/src/activate/activate.c
+++ b/src/activate/activate.c
@@ -81,6 +81,7 @@ static int open_sockets(int *ret_epoll_fd, bool accept) {
 
                 log_close();
                 log_set_open_when_needed(true);
+                log_settle_target();
 
                 r = close_all_fds(except, n);
                 if (r < 0)
diff --git a/src/basic/log.c b/src/basic/log.c
index 8b973f9e0a9..21c6f2a685a 100644
--- a/src/basic/log.c
+++ b/src/basic/log.c
@@ -1264,6 +1264,24 @@ LogTarget log_get_target(void) {
         return log_target;
 }
 
+void log_settle_target(void) {
+
+        /* If we're using LOG_TARGET_AUTO and opening the log again on every single log call, we'll check if
+         * stderr is attached to the journal every single log call. However, if we then close all file
+         * descriptors later, that will stop working because stderr will be closed as well. To avoid that
+         * problem, this function is used to permanently change the log target depending on whether stderr is
+         * connected to the journal or not. */
+
+        LogTarget t = log_get_target();
+
+        if (t != LOG_TARGET_AUTO)
+                return;
+
+        t = getpid_cached() == 1 || stderr_is_journal() ? (prohibit_ipc ? LOG_TARGET_KMSG : LOG_TARGET_JOURNAL_OR_KMSG)
+                                                        : LOG_TARGET_CONSOLE;
+        log_set_target(t);
+}
+
 int log_get_max_level(void) {
         return log_max_level;
 }
diff --git a/src/basic/log.h b/src/basic/log.h
index c4ac73e27bc..226402522cb 100644
--- a/src/basic/log.h
+++ b/src/basic/log.h
@@ -54,6 +54,7 @@ void log_set_target(LogTarget target);
 void log_set_target_and_open(LogTarget target);
 int log_set_target_from_string(const char *e);
 LogTarget log_get_target(void) _pure_;
+void log_settle_target(void);
 
 void log_set_max_level(int level);
 int log_set_max_level_from_string(const char *e);
diff --git a/src/basic/process-util.c b/src/basic/process-util.c
index 5d499a57b4f..2fc2f924509 100644
--- a/src/basic/process-util.c
+++ b/src/basic/process-util.c
@@ -1223,6 +1223,7 @@ int safe_fork_full(
                 /* Close the logs if requested, before we log anything. And make sure we reopen it if needed. */
                 log_close();
                 log_set_open_when_needed(true);
+                log_settle_target();
         }
 
         if (name) {
diff --git a/src/core/execute.c b/src/core/execute.c
index 3f85b5f3cd6..1532833c315 100644
--- a/src/core/execute.c
+++ b/src/core/execute.c
@@ -4488,6 +4488,7 @@ static int exec_child(
 
         log_forget_fds();
         log_set_open_when_needed(true);
+        log_settle_target();
 
         /* In case anything used libc syslog(), close this here, too */
         closelog();
diff --git a/src/nspawn/nspawn.c b/src/nspawn/nspawn.c
index 056fad005d3..f872b2e8f6b 100644
--- a/src/nspawn/nspawn.c
+++ b/src/nspawn/nspawn.c
@@ -3551,6 +3551,7 @@ static int inner_child(
          * it again. Note that the other fds closed here are at least the locking and barrier fds. */
         log_close();
         log_set_open_when_needed(true);
+        log_settle_target();
 
         (void) fdset_close_others(fds);
 
diff --git a/src/test/test-fd-util.c b/src/test/test-fd-util.c
index 1f14f0b6cb4..148694e0295 100644
--- a/src/test/test-fd-util.c
+++ b/src/test/test-fd-util.c
@@ -278,6 +278,7 @@ static void test_close_all_fds_inner(void) {
         /* Close logging fd first, so that we don't confuse it by closing its fd */
         log_close();
         log_set_open_when_needed(true);
+        log_settle_target();
 
         /* Close all but the ones to keep */
         assert_se(close_all_fds(keep, n_keep) >= 0);