Resolve newer libc/syscall wrappers at runtime on Linux

os functions like copy_file_range() are gated on a configure-time
AC_CHECK_FUNCS probe and compiled out when the build libc lacks the
symbol. A redistributable built against an old glibc (the
python-build-standalone builds target glibc 2.17) therefore never
exposes them, even when run on a newer glibc or a capable kernel.

Add Modules/posixshims.h, which on Linux always exposes _Py_<func>(),
resolves the libc symbol once at load time via dlsym(RTLD_DEFAULT) from a
constructor, and falls back to the raw syscall when the running libc
lacks the wrapper. Resolving in a constructor keeps dlsym(), which is not
async-signal-safe, out of signal handlers and the fork()/exec() window.
Off Linux the classic build-time HAVE_* direct calls are kept.

Limit the shims to wrappers newer than the glibc 2.17 baseline, since
anything at or below it is always present in the build libc:

  copy_file_range (glibc 2.27)
  memfd_create    (glibc 2.27)
  pidfd_open      (glibc 2.36)
  pidfd_getfd     (glibc 2.36)

pidfd_open() and pidfd_getfd() previously issued raw syscalls
unconditionally; they now prefer the glibc wrapper when present.

Author: daandemeyer

Modules/clinic/posixmodule.c.h

@@ -46,6 +46,8 @@
 #include <stdio.h>                // ctermid()
 #include <stdlib.h>               // system()
 
+#include "posixshims.h"           // _Py_copy_file_range()
+
 #ifdef HAVE_UNISTD_H
 #  include <unistd.h>             // symlink()
 #endif
@@ -10773,8 +10775,7 @@ os_wait_impl(PyObject *module)
 
 
 // This system call always crashes on older Android versions.
-#if defined(__linux__) && defined(__NR_pidfd_open) && \
-    !(defined(__ANDROID__) && __ANDROID_API__ < 31)
+#ifdef _Py_HAVE_PIDFD_OPEN
 /*[clinic input]
 os.pidfd_open
   pid: pid_t
@@ -10790,7 +10791,7 @@ static PyObject *
 os_pidfd_open_impl(PyObject *module, pid_t pid, unsigned int flags)
 /*[clinic end generated code: output=5c7252698947dc41 input=03058b32c389f874]*/
 {
-    int fd = syscall(__NR_pidfd_open, pid, flags);
+    int fd = _Py_pidfd_open(pid, flags);
     if (fd < 0) {
         return posix_error();
     }
@@ -10799,8 +10800,7 @@ os_pidfd_open_impl(PyObject *module, pid_t pid, unsigned int flags)
 #endif
 
 
-#if defined(__linux__) && defined(__NR_pidfd_getfd) && \
-    !(defined(__ANDROID__) && __ANDROID_API__ < 31)
+#ifdef _Py_HAVE_PIDFD_GETFD
 /*[clinic input]
 os.pidfd_getfd
   pidfd: int
@@ -10819,7 +10819,7 @@ os_pidfd_getfd_impl(PyObject *module, int pidfd, int targetfd,
                     unsigned int flags)
 /*[clinic end generated code: output=e1a1415a13c7137f input=ef6417fb10deb1cc]*/
 {
-    int fd = syscall(__NR_pidfd_getfd, pidfd, targetfd, flags);
+    int fd = _Py_pidfd_getfd(pidfd, targetfd, flags);
     if (fd < 0) {
         return posix_error();
     }
@@ -13018,7 +13018,7 @@ os_pwritev_impl(PyObject *module, int fd, PyObject *buffers, Py_off_t offset,
 }
 #endif /* HAVE_PWRITEV */
 
-#ifdef HAVE_COPY_FILE_RANGE
+#ifdef _Py_HAVE_COPY_FILE_RANGE
 /*[clinic input]
 
 os.copy_file_range
@@ -13070,7 +13070,7 @@ os_copy_file_range_impl(PyObject *module, int src, int dst, Py_ssize_t count,
 
     do {
         Py_BEGIN_ALLOW_THREADS
-        ret = copy_file_range(src, p_offset_src, dst, p_offset_dst, count, flags);
+        ret = _Py_copy_file_range(src, p_offset_src, dst, p_offset_dst, count, flags);
         Py_END_ALLOW_THREADS
     } while (ret < 0 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
 
@@ -13080,7 +13080,7 @@ os_copy_file_range_impl(PyObject *module, int src, int dst, Py_ssize_t count,
 
     return PyLong_FromSsize_t(ret);
 }
-#endif /* HAVE_COPY_FILE_RANGE*/
+#endif /* _Py_HAVE_COPY_FILE_RANGE */
 
 #if (defined(HAVE_SPLICE) && !defined(_AIX))
 /*[clinic input]
@@ -15774,7 +15774,7 @@ os_urandom_impl(PyObject *module, Py_ssize_t size)
     return PyBytesWriter_Finish(writer);
 }
 
-#ifdef HAVE_MEMFD_CREATE
+#ifdef _Py_HAVE_MEMFD_CREATE
 /*[clinic input]
 os.memfd_create
 
@@ -15790,7 +15790,7 @@ os_memfd_create_impl(PyObject *module, PyObject *name, unsigned int flags)
     int fd;
     const char *bytes = PyBytes_AS_STRING(name);
     Py_BEGIN_ALLOW_THREADS
-    fd = memfd_create(bytes, flags);
+    fd = _Py_memfd_create(bytes, flags);
     Py_END_ALLOW_THREADS
     if (fd == -1) {
         return PyErr_SetFromErrno(PyExc_OSError);

Modules/posixmodule.c

@@ -0,0 +1,150 @@
+/* posixshims.h: resolve newer libc/syscall wrappers at runtime, not build time.
+
+   CPython gates functions like copy_file_range() on a configure-time
+   AC_CHECK_FUNCS probe, compiling them out when the build libc lacks the symbol.
+   That permanently disables them in a redistributable built against an old glibc
+   even when it later runs on a newer one.  Instead, on Linux we always expose
+   _Py_<func>(), resolve the libc symbol once at load time via dlsym(RTLD_DEFAULT)
+   from a constructor, and fall back to the raw syscall.  A constructor (vs. lazy
+   resolution) keeps dlsym(), which is not async-signal-safe, out of signal handlers
+   and the fork()/exec() window, and lets the cache skip synchronization.
+
+   Off Linux, each function keeps its classic build-time HAVE_* direct call. */
+
+#ifndef Py_POSIXSHIMS_H
+#define Py_POSIXSHIMS_H
+
+/* Needs ELF constructors, dlsym() and Linux syscall numbers. */
+#if defined(__linux__) && (defined(__GNUC__) || defined(__clang__)) \
+        && defined(HAVE_DLFCN_H) && defined(HAVE_SYS_SYSCALL_H)
+#  define _Py_HAVE_POSIX_SHIMS
+#endif
+
+#ifdef _Py_HAVE_POSIX_SHIMS
+
+#include <dlfcn.h>          // dlsym(), RTLD_DEFAULT
+#include <errno.h>          // ENOSYS, errno
+#include <sys/syscall.h>    // __NR_* syscall numbers
+#include <sys/types.h>      // off_t, ssize_t
+#include <unistd.h>         // syscall()
+
+/* Flat "type1, name1, type2, name2, ..." pair plumbing: _Py_SHIM_DECL emits the
+   declarator "t1 n1, t2 n2, ...", _Py_SHIM_NAME the forwarding list "n1, n2,
+   ...", _Py_SHIM_PAIRS counts pairs (max 8).  GCC/Clang only, so the MSVC
+   __VA_ARGS__ quirks don't apply. */
+
+#define _Py_SHIM_CAT(a, b) _Py_SHIM_CAT_(a, b)
+#define _Py_SHIM_CAT_(a, b) a##b
+
+#define _Py_SHIM_NTH(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, N, ...) N
+#define _Py_SHIM_PAIRS(...) _Py_SHIM_NTH(__VA_ARGS__, 8, 8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0)
+
+#define _Py_SHIM_DECL_1(t, n)      t n
+#define _Py_SHIM_DECL_2(t, n, ...) t n, _Py_SHIM_DECL_1(__VA_ARGS__)
+#define _Py_SHIM_DECL_3(t, n, ...) t n, _Py_SHIM_DECL_2(__VA_ARGS__)
+#define _Py_SHIM_DECL_4(t, n, ...) t n, _Py_SHIM_DECL_3(__VA_ARGS__)
+#define _Py_SHIM_DECL_5(t, n, ...) t n, _Py_SHIM_DECL_4(__VA_ARGS__)
+#define _Py_SHIM_DECL_6(t, n, ...) t n, _Py_SHIM_DECL_5(__VA_ARGS__)
+#define _Py_SHIM_DECL_7(t, n, ...) t n, _Py_SHIM_DECL_6(__VA_ARGS__)
+#define _Py_SHIM_DECL_8(t, n, ...) t n, _Py_SHIM_DECL_7(__VA_ARGS__)
+#define _Py_SHIM_DECL(...) _Py_SHIM_CAT(_Py_SHIM_DECL_, _Py_SHIM_PAIRS(__VA_ARGS__))(__VA_ARGS__)
+
+#define _Py_SHIM_NAME_1(t, n)      n
+#define _Py_SHIM_NAME_2(t, n, ...) n, _Py_SHIM_NAME_1(__VA_ARGS__)
+#define _Py_SHIM_NAME_3(t, n, ...) n, _Py_SHIM_NAME_2(__VA_ARGS__)
+#define _Py_SHIM_NAME_4(t, n, ...) n, _Py_SHIM_NAME_3(__VA_ARGS__)
+#define _Py_SHIM_NAME_5(t, n, ...) n, _Py_SHIM_NAME_4(__VA_ARGS__)
+#define _Py_SHIM_NAME_6(t, n, ...) n, _Py_SHIM_NAME_5(__VA_ARGS__)
+#define _Py_SHIM_NAME_7(t, n, ...) n, _Py_SHIM_NAME_6(__VA_ARGS__)
+#define _Py_SHIM_NAME_8(t, n, ...) n, _Py_SHIM_NAME_7(__VA_ARGS__)
+#define _Py_SHIM_NAME(...) _Py_SHIM_CAT(_Py_SHIM_NAME_, _Py_SHIM_PAIRS(__VA_ARGS__))(__VA_ARGS__)
+
+/* The __asm__ barrier after dlsym() is load-bearing under LTO: without it the
+   compiler may tail-call dlsym(), breaking glibc's return-address caller lookup
+   and crashing at startup (glibc BZ #34156). */
+#define _Py_SHIM_RESOLVER(func)                                               \
+    static void *_Py_shim_##func;                                             \
+    __attribute__((constructor))                                              \
+    static void _Py_shim_##func##_resolve(void) {                             \
+        void *p = dlsym(RTLD_DEFAULT, #func);                                 \
+        __asm__ volatile("" ::: "memory");                                    \
+        _Py_shim_##func = p;                                                  \
+    }
+
+#define _Py_SHIM_LIBC(func)                                                   \
+    __typeof__(&_Py_##func) _Py_libc =                                        \
+        (__typeof__(&_Py_##func)) _Py_shim_##func
+
+/* Define _Py_<func>() + resolver from a signature given as flat type,name pairs.
+   The _NAMED form is for wrappers whose name differs from the syscall they issue
+   (e.g. eventfd() -> eventfd2): `nr` names the __NR_<nr> the fallback uses. */
+#define _Py_DEFINE_SYSCALL_SHIM_NAMED(func, nr, ret, ...)                     \
+    _Py_SHIM_RESOLVER(func)                                                   \
+    static inline ret _Py_##func(_Py_SHIM_DECL(__VA_ARGS__)) {                \
+        _Py_SHIM_LIBC(func);                                                  \
+        if (_Py_libc != NULL) {                                               \
+            return _Py_libc(_Py_SHIM_NAME(__VA_ARGS__));                      \
+        }                                                                     \
+        return syscall(__NR_##nr, _Py_SHIM_NAME(__VA_ARGS__));               \
+    }
+
+#define _Py_DEFINE_SYSCALL_SHIM(func, ret, ...)                               \
+    _Py_DEFINE_SYSCALL_SHIM_NAMED(func, func, ret, __VA_ARGS__)
+
+/* ---- copy_file_range() (glibc 2.27) ------------------------------------- */
+
+#if defined(_Py_HAVE_POSIX_SHIMS)
+#  define _Py_HAVE_COPY_FILE_RANGE
+/* off_t is 64-bit (_FILE_OFFSET_BITS=64), matching the kernel's loff_t. */
+_Py_DEFINE_SYSCALL_SHIM(copy_file_range, ssize_t,
+                        int, fd_in,
+                        off_t *, off_in,
+                        int, fd_out,
+                        off_t *, off_out,
+                        size_t, len,
+                        unsigned int, flags)
+
+#elif defined(HAVE_COPY_FILE_RANGE)
+#  define _Py_HAVE_COPY_FILE_RANGE
+#  define _Py_copy_file_range copy_file_range
+#endif
+
+
+/* ---- memfd_create() (glibc 2.27) ---------------------------------------- */
+
+#if defined(_Py_HAVE_POSIX_SHIMS)
+#  define _Py_HAVE_MEMFD_CREATE
+_Py_DEFINE_SYSCALL_SHIM(memfd_create, int,
+                        const char *, name,
+                        unsigned int, flags)
+
+#elif defined(HAVE_MEMFD_CREATE)
+#  define _Py_HAVE_MEMFD_CREATE
+#  define _Py_memfd_create memfd_create
+#endif
+
+
+/* ---- pidfd_open(), pidfd_getfd() (glibc 2.36) --------------------------- *
+
+   Previously unconditional raw syscalls; the shim now prefers glibc's wrapper.
+   Linux-only from the start (no non-Linux branch); the __NR_ and Android API
+   floor from the original guards are preserved. */
+
+#if defined(_Py_HAVE_POSIX_SHIMS) && defined(__NR_pidfd_open) \
+        && !(defined(__ANDROID__) && __ANDROID_API__ < 31)
+#  define _Py_HAVE_PIDFD_OPEN
+_Py_DEFINE_SYSCALL_SHIM(pidfd_open, int,
+                        pid_t, pid,
+                        unsigned int, flags)
+#endif
+
+#if defined(_Py_HAVE_POSIX_SHIMS) && defined(__NR_pidfd_getfd) \
+        && !(defined(__ANDROID__) && __ANDROID_API__ < 31)
+#  define _Py_HAVE_PIDFD_GETFD
+_Py_DEFINE_SYSCALL_SHIM(pidfd_getfd, int,
+                        int, pidfd,
+                        int, targetfd,
+                        unsigned int, flags)
+#endif
+
+#endif /* !Py_POSIXSHIMS_H */