glibc bump followup (#36609)

src/basic/locale-util.c

@@ -17,8 +17,8 @@
 #include "fileio.h"
 #include "hashmap.h"
 #include "locale-util.h"
-#include "missing_syscall.h"
 #include "path-util.h"
+#include "process-util.h"
 #include "set.h"
 #include "string-table.h"
 #include "string-util.h"
@@ -283,64 +283,48 @@ int locale_is_installed(const char *name) {
         return true;
 }
 
-bool is_locale_utf8(void) {
-        static int cached_answer = -1;
+static bool is_locale_utf8_impl(void) {
         const char *set;
         int r;
 
-        /* Note that we default to 'true' here, since today UTF8 is
-         * pretty much supported everywhere. */
-
-        if (cached_answer >= 0)
-                goto out;
+        /* Note that we default to 'true' here, since today UTF8 is pretty much supported everywhere. */
 
         r = secure_getenv_bool("SYSTEMD_UTF8");
-        if (r >= 0) {
-                cached_answer = r;
-                goto out;
-        } else if (r != -ENXIO)
+        if (r >= 0)
+                return r;
+        if (r != -ENXIO)
                 log_debug_errno(r, "Failed to parse $SYSTEMD_UTF8, ignoring: %m");
 
         /* This function may be called from libsystemd, and setlocale() is not thread safe. Assuming yes. */
-        if (gettid() != raw_getpid()) {
-                cached_answer = true;
-                goto out;
-        }
+        if (!is_main_thread())
+                return true;
 
-        if (!setlocale(LC_ALL, "")) {
-                cached_answer = true;
-                goto out;
-        }
+        if (!setlocale(LC_ALL, ""))
+                return true;
 
         set = nl_langinfo(CODESET);
-        if (!set) {
-                cached_answer = true;
-                goto out;
-        }
+        if (!set || streq(set, "UTF-8"))
+                return true;
 
-        if (streq(set, "UTF-8")) {
-                cached_answer = true;
-                goto out;
-        }
-
-        /* For LC_CTYPE=="C" return true, because CTYPE is effectively
-         * unset and everything can do to UTF-8 nowadays. */
         set = setlocale(LC_CTYPE, NULL);
-        if (!set) {
-                cached_answer = true;
-                goto out;
-        }
+        if (!set)
+                return true;
 
-        /* Check result, but ignore the result if C was set
-         * explicitly. */
-        cached_answer =
-                STR_IN_SET(set, "C", "POSIX") &&
+        /* Unless LC_CTYPE is explicitly overridden, return true. Because here CTYPE is effectively unset
+         * and everything can do to UTF-8 nowadays. */
+        return STR_IN_SET(set, "C", "POSIX") &&
                 !getenv("LC_ALL") &&
                 !getenv("LC_CTYPE") &&
                 !getenv("LANG");
+}
 
-out:
-        return (bool) cached_answer;
+bool is_locale_utf8(void) {
+        static int cached = -1;
+
+        if (cached < 0)
+                cached = is_locale_utf8_impl();
+
+        return cached;
 }
 
 void locale_variables_free(char *l[_VARIABLE_LC_MAX]) {

src/basic/missing_fs.h

@@ -50,14 +50,7 @@ assert_cc(RWF_DONTCACHE == __RWF_DONTCACHE_SAVED__);
 #define EXT4_IOC_RESIZE_FS _IOW('f', 16, __u64)
 #endif
 
-/* linux/fscrypt.h */
-#ifndef FS_KEY_DESCRIPTOR_SIZE
-#  define FS_KEY_DESCRIPTOR_SIZE 8
-#else
-assert_cc(FS_KEY_DESCRIPTOR_SIZE == 8);
-#endif
-
-/* linux/exportfs.h */
+/* linux/exportfs.h (33c5ac9175195c36a0b7005aaf503a2e81f117a1, 5.5) */
 #ifndef FILEID_KERNFS
 #define FILEID_KERNFS 0xfe
 #endif

src/basic/missing_syscall.h

@@ -63,16 +63,6 @@ static inline int missing_ioprio_set(int which, int who, int ioprio) {
 
 /* ======================================================================= */
 
-static inline pid_t raw_getpid(void) {
-#if defined(__alpha__)
-        return (pid_t) syscall(__NR_getxpid);
-#else
-        return (pid_t) syscall(__NR_getpid);
-#endif
-}
-
-/* ======================================================================= */
-
 #if !HAVE_KCMP
 static inline int missing_kcmp(pid_t pid1, pid_t pid2, int type, unsigned long idx1, unsigned long idx2) {
         return syscall(__NR_kcmp, pid1, pid2, type, idx1, idx2);

src/basic/process-util.c

@@ -1441,7 +1441,7 @@ pid_t getpid_cached(void) {
         case CACHED_PID_UNSET: { /* Not initialized yet, then do so now */
                 pid_t new_pid;
 
-                new_pid = raw_getpid();
+                new_pid = getpid();
 
                 if (!installed) {
                         /* __register_atfork() either returns 0 or -ENOMEM, in its glibc implementation. Since it's
@@ -1462,7 +1462,7 @@ pid_t getpid_cached(void) {
         }
 
         case CACHED_PID_BUSY: /* Somebody else is currently initializing */
-                return raw_getpid();
+                return getpid();
 
         default: /* Properly initialized */
                 return current_value;

src/basic/signal-util.c

@@ -280,13 +280,13 @@ void propagate_signal(int sig, siginfo_t *siginfo) {
 
         /* To be called from a signal handler. Will raise the same signal again, in our process + in our threads.
          *
-         * Note that we use raw_getpid() instead of getpid_cached(). We might have forked with raw_clone()
+         * Note that we use getpid() instead of getpid_cached(). We might have forked with raw_clone()
          * earlier (see PID 1), and hence let's go to the raw syscall here. In particular as this is not
          * performance sensitive code.
          *
          * Note that we use kill() rather than raise() as fallback, for similar reasons. */
 
-        p = raw_getpid();
+        p = getpid();
 
         if (rt_tgsigqueueinfo(p, gettid(), sig, siginfo) < 0)
                 assert_se(kill(p, sig) >= 0);

src/basic/sys/mount.h

@@ -2,8 +2,8 @@
 #pragma once
 
 #include <features.h>
-#include <stdint.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <sys/ioctl.h>
 #include <sys/syscall.h>
 #include <unistd.h>

src/libsystemd/sd-journal/journal-send.c

@@ -88,7 +88,7 @@ void close_journal_fd(void) {
         if (!RUNNING_ON_VALGRIND)
                 return;
 
-        if (getpid_cached() != gettid())
+        if (!is_main_thread())
                 return;
 
         if (fd_plus_one <= 0)

src/test/test-process-util.c

@@ -581,7 +581,7 @@ TEST(getpid_cached) {
         siginfo_t si;
         pid_t a, b, c, d, e, f, child;
 
-        a = raw_getpid();
+        a = getpid();
         b = getpid_cached();
         c = getpid();
 
@@ -593,7 +593,7 @@ TEST(getpid_cached) {
 
         if (child == 0) {
                 /* In child */
-                a = raw_getpid();
+                a = getpid();
                 b = getpid_cached();
                 c = getpid();
 
@@ -602,7 +602,7 @@ TEST(getpid_cached) {
                 _exit(EXIT_SUCCESS);
         }
 
-        d = raw_getpid();
+        d = getpid();
         e = getpid_cached();
         f = getpid();
 

src/test/test-raw-clone.c

@@ -14,13 +14,13 @@ TEST(raw_clone) {
 
         parent = getpid();
         log_info("before clone: getpid()→"PID_FMT, parent);
-        assert_se(raw_getpid() == parent);
+        assert_se(getpid() == parent);
 
         pid = raw_clone(0);
         assert_se(pid >= 0);
 
-        pid2 = raw_getpid();
-        log_info("raw_clone: "PID_FMT" getpid()→"PID_FMT" raw_getpid()→"PID_FMT,
+        pid2 = getpid();
+        log_info("raw_clone: "PID_FMT" getpid()→"PID_FMT" getpid()→"PID_FMT,
                  pid, getpid(), pid2);
         if (pid == 0) {
                 assert_se(pid2 != parent);