Library import 16 (#2433)

Co-authored-by: robot-piglet <robot-piglet@yandex-team.com>
Co-authored-by: deshevoy <deshevoy@yandex-team.com>
Co-authored-by: robot-contrib <robot-contrib@yandex-team.com>
Co-authored-by: thegeorg <thegeorg@yandex-team.com>
Co-authored-by: robot-ya-builder <robot-ya-builder@yandex-team.com>
Co-authored-by: svidyuk <svidyuk@yandex-team.com>
Co-authored-by: shadchin <shadchin@yandex-team.com>
Co-authored-by: robot-ratatosk <robot-ratatosk@yandex-team.com>
Co-authored-by: innokentii <innokentii@yandex-team.com>
Co-authored-by: arkady-e1ppa <arkady-e1ppa@yandex-team.com>
Co-authored-by: snermolaev <snermolaev@yandex-team.com>
Co-authored-by: dimdim11 <dimdim11@yandex-team.com>
Co-authored-by: kickbutt <kickbutt@yandex-team.com>
Co-authored-by: abdullinsaid <abdullinsaid@yandex-team.com>
Co-authored-by: korsunandrei <korsunandrei@yandex-team.com>
Co-authored-by: petrk <petrk@yandex-team.com>
Co-authored-by: miroslav2 <miroslav2@yandex-team.com>
Co-authored-by: serjflint <serjflint@yandex-team.com>
Co-authored-by: akhropov <akhropov@yandex-team.com>
Co-authored-by: prettyboy <prettyboy@yandex-team.com>
Co-authored-by: ilikepugs <ilikepugs@yandex-team.com>
Co-authored-by: hiddenpath <hiddenpath@yandex-team.com>
Co-authored-by: mikhnenko <mikhnenko@yandex-team.com>
Co-authored-by: spreis <spreis@yandex-team.com>
Co-authored-by: andreyshspb <andreyshspb@yandex-team.com>
Co-authored-by: dimaandreev <dimaandreev@yandex-team.com>
Co-authored-by: rashid <rashid@yandex-team.com>
Co-authored-by: robot-ydb-importer <robot-ydb-importer@yandex-team.com>
Co-authored-by: r-vetrov <r-vetrov@yandex-team.com>
Co-authored-by: ypodlesov <ypodlesov@yandex-team.com>
Co-authored-by: zaverden <zaverden@yandex-team.com>
Co-authored-by: vpozdyayev <vpozdyayev@yandex-team.com>
Co-authored-by: robot-cozmo <robot-cozmo@yandex-team.com>
Co-authored-by: v-korovin <v-korovin@yandex-team.com>
Co-authored-by: arikon <arikon@yandex-team.com>
Co-authored-by: khoden <khoden@yandex-team.com>
Co-authored-by: psydmm <psydmm@yandex-team.com>
Co-authored-by: robot-javacom <robot-javacom@yandex-team.com>
Co-authored-by: dtorilov <dtorilov@yandex-team.com>
Co-authored-by: sennikovmv <sennikovmv@yandex-team.com>
Co-authored-by: hcpp <hcpp@ydb.tech>

1 files changed, 707 insertions, 0 deletions

diff --git a/contrib/tools/python3/Modules/fcntlmodule.c b/contrib/tools/python3/Modules/fcntlmodule.c
new file mode 100644
index 0000000000..2bca40213c
--- /dev/null
+++ b/contrib/tools/python3/Modules/fcntlmodule.c
@@ -0,0 +1,707 @@
+
+/* fcntl module */
+
+#define PY_SSIZE_T_CLEAN
+
+#include "Python.h"
+
+#ifdef HAVE_SYS_FILE_H
+#include <sys/file.h>
+#endif
+#ifdef HAVE_LINUX_FS_H
+#include <linux/fs.h>
+#endif
+
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#ifdef HAVE_STROPTS_H
+#include <stropts.h>
+#endif
+
+/*[clinic input]
+module fcntl
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=124b58387c158179]*/
+
+#include "clinic/fcntlmodule.c.h"
+
+/*[clinic input]
+fcntl.fcntl
+
+    fd: fildes
+    cmd as code: int
+    arg: object(c_default='NULL') = 0
+    /
+
+Perform the operation `cmd` on file descriptor fd.
+
+The values used for `cmd` are operating system dependent, and are available
+as constants in the fcntl module, using the same names as used in
+the relevant C header files.  The argument arg is optional, and
+defaults to 0; it may be an int or a string.  If arg is given as a string,
+the return value of fcntl is a string of that length, containing the
+resulting value put in the arg buffer by the operating system.  The length
+of the arg string is not allowed to exceed 1024 bytes.  If the arg given
+is an integer or if none is specified, the result value is an integer
+corresponding to the return value of the fcntl call in the C code.
+[clinic start generated code]*/
+
+static PyObject *
+fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg)
+/*[clinic end generated code: output=888fc93b51c295bd input=7955340198e5f334]*/
+{
+    unsigned int int_arg = 0;
+    int ret;
+    char *str;
+    Py_ssize_t len;
+    char buf[1024];
+    int async_err = 0;
+
+    if (PySys_Audit("fcntl.fcntl", "iiO", fd, code, arg ? arg : Py_None) < 0) {
+        return NULL;
+    }
+
+    if (arg != NULL) {
+        int parse_result;
+
+        if (PyArg_Parse(arg, "s#", &str, &len)) {
+            if ((size_t)len > sizeof buf) {
+                PyErr_SetString(PyExc_ValueError,
+                                "fcntl string arg too long");
+                return NULL;
+            }
+            memcpy(buf, str, len);
+            do {
+                Py_BEGIN_ALLOW_THREADS
+                ret = fcntl(fd, code, buf);
+                Py_END_ALLOW_THREADS
+            } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+            if (ret < 0) {
+                return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
+            }
+            return PyBytes_FromStringAndSize(buf, len);
+        }
+
+        PyErr_Clear();
+        parse_result = PyArg_Parse(arg,
+            "I;fcntl requires a file or file descriptor,"
+            " an integer and optionally a third integer or a string",
+            &int_arg);
+        if (!parse_result) {
+          return NULL;
+        }
+    }
+
+    do {
+        Py_BEGIN_ALLOW_THREADS
+        ret = fcntl(fd, code, (int)int_arg);
+        Py_END_ALLOW_THREADS
+    } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+    if (ret < 0) {
+        return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
+    }
+    return PyLong_FromLong((long)ret);
+}
+
+
+/*[clinic input]
+fcntl.ioctl
+
+    fd: fildes
+    request as code: unsigned_int(bitwise=True)
+    arg as ob_arg: object(c_default='NULL') = 0
+    mutate_flag as mutate_arg: bool = True
+    /
+
+Perform the operation `request` on file descriptor `fd`.
+
+The values used for `request` are operating system dependent, and are available
+as constants in the fcntl or termios library modules, using the same names as
+used in the relevant C header files.
+
+The argument `arg` is optional, and defaults to 0; it may be an int or a
+buffer containing character data (most likely a string or an array).
+
+If the argument is a mutable buffer (such as an array) and if the
+mutate_flag argument (which is only allowed in this case) is true then the
+buffer is (in effect) passed to the operating system and changes made by
+the OS will be reflected in the contents of the buffer after the call has
+returned.  The return value is the integer returned by the ioctl system
+call.
+
+If the argument is a mutable buffer and the mutable_flag argument is false,
+the behavior is as if a string had been passed.
+
+If the argument is an immutable buffer (most likely a string) then a copy
+of the buffer is passed to the operating system and the return value is a
+string of the same length containing whatever the operating system put in
+the buffer.  The length of the arg buffer in this case is not allowed to
+exceed 1024 bytes.
+
+If the arg given is an integer or if none is specified, the result value is
+an integer corresponding to the return value of the ioctl call in the C
+code.
+[clinic start generated code]*/
+
+static PyObject *
+fcntl_ioctl_impl(PyObject *module, int fd, unsigned int code,
+                 PyObject *ob_arg, int mutate_arg)
+/*[clinic end generated code: output=7f7f5840c65991be input=967b4a4cbeceb0a8]*/
+{
+#define IOCTL_BUFSZ 1024
+    /* We use the unsigned non-checked 'I' format for the 'code' parameter
+       because the system expects it to be a 32bit bit field value
+       regardless of it being passed as an int or unsigned long on
+       various platforms.  See the termios.TIOCSWINSZ constant across
+       platforms for an example of this.
+
+       If any of the 64bit platforms ever decide to use more than 32bits
+       in their unsigned long ioctl codes this will break and need
+       special casing based on the platform being built on.
+     */
+    int arg = 0;
+    int ret;
+    Py_buffer pstr;
+    char *str;
+    Py_ssize_t len;
+    char buf[IOCTL_BUFSZ+1];  /* argument plus NUL byte */
+
+    if (PySys_Audit("fcntl.ioctl", "iIO", fd, code,
+                    ob_arg ? ob_arg : Py_None) < 0) {
+        return NULL;
+    }
+
+    if (ob_arg != NULL) {
+        if (PyArg_Parse(ob_arg, "w*:ioctl", &pstr)) {
+            char *arg;
+            str = pstr.buf;
+            len = pstr.len;
+
+            if (mutate_arg) {
+                if (len <= IOCTL_BUFSZ) {
+                    memcpy(buf, str, len);
+                    buf[len] = '\0';
+                    arg = buf;
+                }
+                else {
+                    arg = str;
+                }
+            }
+            else {
+                if (len > IOCTL_BUFSZ) {
+                    PyBuffer_Release(&pstr);
+                    PyErr_SetString(PyExc_ValueError,
+                        "ioctl string arg too long");
+                    return NULL;
+                }
+                else {
+                    memcpy(buf, str, len);
+                    buf[len] = '\0';
+                    arg = buf;
+                }
+            }
+            if (buf == arg) {
+                Py_BEGIN_ALLOW_THREADS /* think array.resize() */
+                ret = ioctl(fd, code, arg);
+                Py_END_ALLOW_THREADS
+            }
+            else {
+                ret = ioctl(fd, code, arg);
+            }
+            if (mutate_arg && (len <= IOCTL_BUFSZ)) {
+                memcpy(str, buf, len);
+            }
+            if (ret < 0) {
+                PyErr_SetFromErrno(PyExc_OSError);
+                PyBuffer_Release(&pstr);
+                return NULL;
+            }
+            PyBuffer_Release(&pstr);
+            if (mutate_arg) {
+                return PyLong_FromLong(ret);
+            }
+            else {
+                return PyBytes_FromStringAndSize(buf, len);
+            }
+        }
+
+        PyErr_Clear();
+        if (PyArg_Parse(ob_arg, "s*:ioctl", &pstr)) {
+            str = pstr.buf;
+            len = pstr.len;
+            if (len > IOCTL_BUFSZ) {
+                PyBuffer_Release(&pstr);
+                PyErr_SetString(PyExc_ValueError,
+                                "ioctl string arg too long");
+                return NULL;
+            }
+            memcpy(buf, str, len);
+            buf[len] = '\0';
+            Py_BEGIN_ALLOW_THREADS
+            ret = ioctl(fd, code, buf);
+            Py_END_ALLOW_THREADS
+            if (ret < 0) {
+                PyErr_SetFromErrno(PyExc_OSError);
+                PyBuffer_Release(&pstr);
+                return NULL;
+            }
+            PyBuffer_Release(&pstr);
+            return PyBytes_FromStringAndSize(buf, len);
+        }
+
+        PyErr_Clear();
+        if (!PyArg_Parse(ob_arg,
+             "i;ioctl requires a file or file descriptor,"
+             " an integer and optionally an integer or buffer argument",
+             &arg)) {
+          return NULL;
+        }
+        // Fall-through to outside the 'if' statement.
+    }
+    Py_BEGIN_ALLOW_THREADS
+    ret = ioctl(fd, code, arg);
+    Py_END_ALLOW_THREADS
+    if (ret < 0) {
+        PyErr_SetFromErrno(PyExc_OSError);
+        return NULL;
+    }
+    return PyLong_FromLong((long)ret);
+#undef IOCTL_BUFSZ
+}
+
+/*[clinic input]
+fcntl.flock
+
+    fd: fildes
+    operation as code: int
+    /
+
+Perform the lock operation `operation` on file descriptor `fd`.
+
+See the Unix manual page for flock(2) for details (On some systems, this
+function is emulated using fcntl()).
+[clinic start generated code]*/
+
+static PyObject *
+fcntl_flock_impl(PyObject *module, int fd, int code)
+/*[clinic end generated code: output=84059e2b37d2fc64 input=0bfc00f795953452]*/
+{
+    int ret;
+    int async_err = 0;
+
+    if (PySys_Audit("fcntl.flock", "ii", fd, code) < 0) {
+        return NULL;
+    }
+
+#ifdef HAVE_FLOCK
+    do {
+        Py_BEGIN_ALLOW_THREADS
+        ret = flock(fd, code);
+        Py_END_ALLOW_THREADS
+    } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+#else
+
+#ifndef LOCK_SH
+#define LOCK_SH         1       /* shared lock */
+#define LOCK_EX         2       /* exclusive lock */
+#define LOCK_NB         4       /* don't block when locking */
+#define LOCK_UN         8       /* unlock */
+#endif
+    {
+        struct flock l;
+        if (code == LOCK_UN)
+            l.l_type = F_UNLCK;
+        else if (code & LOCK_SH)
+            l.l_type = F_RDLCK;
+        else if (code & LOCK_EX)
+            l.l_type = F_WRLCK;
+        else {
+            PyErr_SetString(PyExc_ValueError,
+                            "unrecognized flock argument");
+            return NULL;
+        }
+        l.l_whence = l.l_start = l.l_len = 0;
+        do {
+            Py_BEGIN_ALLOW_THREADS
+            ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);
+            Py_END_ALLOW_THREADS
+        } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+    }
+#endif /* HAVE_FLOCK */
+    if (ret < 0) {
+        return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
+    }
+    Py_RETURN_NONE;
+}
+
+
+/*[clinic input]
+fcntl.lockf
+
+    fd: fildes
+    cmd as code: int
+    len as lenobj: object(c_default='NULL') = 0
+    start as startobj: object(c_default='NULL') = 0
+    whence: int = 0
+    /
+
+A wrapper around the fcntl() locking calls.
+
+`fd` is the file descriptor of the file to lock or unlock, and operation is one
+of the following values:
+
+    LOCK_UN - unlock
+    LOCK_SH - acquire a shared lock
+    LOCK_EX - acquire an exclusive lock
+
+When operation is LOCK_SH or LOCK_EX, it can also be bitwise ORed with
+LOCK_NB to avoid blocking on lock acquisition.  If LOCK_NB is used and the
+lock cannot be acquired, an OSError will be raised and the exception will
+have an errno attribute set to EACCES or EAGAIN (depending on the operating
+system -- for portability, check for either value).
+
+`len` is the number of bytes to lock, with the default meaning to lock to
+EOF.  `start` is the byte offset, relative to `whence`, to that the lock
+starts.  `whence` is as with fileobj.seek(), specifically:
+
+    0 - relative to the start of the file (SEEK_SET)
+    1 - relative to the current buffer position (SEEK_CUR)
+    2 - relative to the end of the file (SEEK_END)
+[clinic start generated code]*/
+
+static PyObject *
+fcntl_lockf_impl(PyObject *module, int fd, int code, PyObject *lenobj,
+                 PyObject *startobj, int whence)
+/*[clinic end generated code: output=4985e7a172e7461a input=5480479fc63a04b8]*/
+{
+    int ret;
+    int async_err = 0;
+
+    if (PySys_Audit("fcntl.lockf", "iiOOi", fd, code, lenobj ? lenobj : Py_None,
+                    startobj ? startobj : Py_None, whence) < 0) {
+        return NULL;
+    }
+
+#ifndef LOCK_SH
+#define LOCK_SH         1       /* shared lock */
+#define LOCK_EX         2       /* exclusive lock */
+#define LOCK_NB         4       /* don't block when locking */
+#define LOCK_UN         8       /* unlock */
+#endif  /* LOCK_SH */
+    {
+        struct flock l;
+        if (code == LOCK_UN)
+            l.l_type = F_UNLCK;
+        else if (code & LOCK_SH)
+            l.l_type = F_RDLCK;
+        else if (code & LOCK_EX)
+            l.l_type = F_WRLCK;
+        else {
+            PyErr_SetString(PyExc_ValueError,
+                            "unrecognized lockf argument");
+            return NULL;
+        }
+        l.l_start = l.l_len = 0;
+        if (startobj != NULL) {
+#if !defined(HAVE_LARGEFILE_SUPPORT)
+            l.l_start = PyLong_AsLong(startobj);
+#else
+            l.l_start = PyLong_Check(startobj) ?
+                            PyLong_AsLongLong(startobj) :
+                    PyLong_AsLong(startobj);
+#endif
+            if (PyErr_Occurred())
+                return NULL;
+        }
+        if (lenobj != NULL) {
+#if !defined(HAVE_LARGEFILE_SUPPORT)
+            l.l_len = PyLong_AsLong(lenobj);
+#else
+            l.l_len = PyLong_Check(lenobj) ?
+                            PyLong_AsLongLong(lenobj) :
+                    PyLong_AsLong(lenobj);
+#endif
+            if (PyErr_Occurred())
+                return NULL;
+        }
+        l.l_whence = whence;
+        do {
+            Py_BEGIN_ALLOW_THREADS
+            ret = fcntl(fd, (code & LOCK_NB) ? F_SETLK : F_SETLKW, &l);
+            Py_END_ALLOW_THREADS
+        } while (ret == -1 && errno == EINTR && !(async_err = PyErr_CheckSignals()));
+    }
+    if (ret < 0) {
+        return !async_err ? PyErr_SetFromErrno(PyExc_OSError) : NULL;
+    }
+    Py_RETURN_NONE;
+}
+
+/* List of functions */
+
+static PyMethodDef fcntl_methods[] = {
+    FCNTL_FCNTL_METHODDEF
+    FCNTL_IOCTL_METHODDEF
+    FCNTL_FLOCK_METHODDEF
+    FCNTL_LOCKF_METHODDEF
+    {NULL, NULL}  /* sentinel */
+};
+
+
+PyDoc_STRVAR(module_doc,
+"This module performs file control and I/O control on file\n\
+descriptors.  It is an interface to the fcntl() and ioctl() Unix\n\
+routines.  File descriptors can be obtained with the fileno() method of\n\
+a file or socket object.");
+
+/* Module initialisation */
+
+
+static int
+all_ins(PyObject* m)
+{
+    if (PyModule_AddIntMacro(m, LOCK_SH)) return -1;
+    if (PyModule_AddIntMacro(m, LOCK_EX)) return -1;
+    if (PyModule_AddIntMacro(m, LOCK_NB)) return -1;
+    if (PyModule_AddIntMacro(m, LOCK_UN)) return -1;
+/* GNU extensions, as of glibc 2.2.4 */
+#ifdef LOCK_MAND
+    if (PyModule_AddIntMacro(m, LOCK_MAND)) return -1;
+#endif
+#ifdef LOCK_READ
+    if (PyModule_AddIntMacro(m, LOCK_READ)) return -1;
+#endif
+#ifdef LOCK_WRITE
+    if (PyModule_AddIntMacro(m, LOCK_WRITE)) return -1;
+#endif
+#ifdef LOCK_RW
+    if (PyModule_AddIntMacro(m, LOCK_RW)) return -1;
+#endif
+
+#ifdef F_DUPFD
+    if (PyModule_AddIntMacro(m, F_DUPFD)) return -1;
+#endif
+#ifdef F_DUPFD_CLOEXEC
+    if (PyModule_AddIntMacro(m, F_DUPFD_CLOEXEC)) return -1;
+#endif
+#ifdef F_GETFD
+    if (PyModule_AddIntMacro(m, F_GETFD)) return -1;
+#endif
+#ifdef F_SETFD
+    if (PyModule_AddIntMacro(m, F_SETFD)) return -1;
+#endif
+#ifdef F_GETFL
+    if (PyModule_AddIntMacro(m, F_GETFL)) return -1;
+#endif
+#ifdef F_SETFL
+    if (PyModule_AddIntMacro(m, F_SETFL)) return -1;
+#endif
+#ifdef F_GETLK
+    if (PyModule_AddIntMacro(m, F_GETLK)) return -1;
+#endif
+#ifdef F_SETLK
+    if (PyModule_AddIntMacro(m, F_SETLK)) return -1;
+#endif
+#ifdef F_SETLKW
+    if (PyModule_AddIntMacro(m, F_SETLKW)) return -1;
+#endif
+#ifdef F_OFD_GETLK
+    if (PyModule_AddIntMacro(m, F_OFD_GETLK)) return -1;
+#endif
+#ifdef F_OFD_SETLK
+    if (PyModule_AddIntMacro(m, F_OFD_SETLK)) return -1;
+#endif
+#ifdef F_OFD_SETLKW
+    if (PyModule_AddIntMacro(m, F_OFD_SETLKW)) return -1;
+#endif
+#ifdef F_GETOWN
+    if (PyModule_AddIntMacro(m, F_GETOWN)) return -1;
+#endif
+#ifdef F_SETOWN
+    if (PyModule_AddIntMacro(m, F_SETOWN)) return -1;
+#endif
+#ifdef F_GETPATH
+    if (PyModule_AddIntMacro(m, F_GETPATH)) return -1;
+#endif
+#ifdef F_GETSIG
+    if (PyModule_AddIntMacro(m, F_GETSIG)) return -1;
+#endif
+#ifdef F_SETSIG
+    if (PyModule_AddIntMacro(m, F_SETSIG)) return -1;
+#endif
+#ifdef F_RDLCK
+    if (PyModule_AddIntMacro(m, F_RDLCK)) return -1;
+#endif
+#ifdef F_WRLCK
+    if (PyModule_AddIntMacro(m, F_WRLCK)) return -1;
+#endif
+#ifdef F_UNLCK
+    if (PyModule_AddIntMacro(m, F_UNLCK)) return -1;
+#endif
+/* LFS constants */
+#ifdef F_GETLK64
+    if (PyModule_AddIntMacro(m, F_GETLK64)) return -1;
+#endif
+#ifdef F_SETLK64
+    if (PyModule_AddIntMacro(m, F_SETLK64)) return -1;
+#endif
+#ifdef F_SETLKW64
+    if (PyModule_AddIntMacro(m, F_SETLKW64)) return -1;
+#endif
+/* GNU extensions, as of glibc 2.2.4. */
+#ifdef FASYNC
+    if (PyModule_AddIntMacro(m, FASYNC)) return -1;
+#endif
+#ifdef F_SETLEASE
+    if (PyModule_AddIntMacro(m, F_SETLEASE)) return -1;
+#endif
+#ifdef F_GETLEASE
+    if (PyModule_AddIntMacro(m, F_GETLEASE)) return -1;
+#endif
+#ifdef F_NOTIFY
+    if (PyModule_AddIntMacro(m, F_NOTIFY)) return -1;
+#endif
+/* Old BSD flock(). */
+#ifdef F_EXLCK
+    if (PyModule_AddIntMacro(m, F_EXLCK)) return -1;
+#endif
+#ifdef F_SHLCK
+    if (PyModule_AddIntMacro(m, F_SHLCK)) return -1;
+#endif
+
+/* Linux specifics */
+#ifdef F_SETPIPE_SZ
+    if (PyModule_AddIntMacro(m, F_SETPIPE_SZ)) return -1;
+#endif
+#ifdef F_GETPIPE_SZ
+    if (PyModule_AddIntMacro(m, F_GETPIPE_SZ)) return -1;
+#endif
+#ifdef FICLONE
+    if (PyModule_AddIntMacro(m, FICLONE)) return -1;
+#endif
+#ifdef FICLONERANGE
+    if (PyModule_AddIntMacro(m, FICLONERANGE)) return -1;
+#endif
+
+/* OS X specifics */
+#ifdef F_FULLFSYNC
+    if (PyModule_AddIntMacro(m, F_FULLFSYNC)) return -1;
+#endif
+#ifdef F_NOCACHE
+    if (PyModule_AddIntMacro(m, F_NOCACHE)) return -1;
+#endif
+
+/* FreeBSD specifics */
+#ifdef F_DUP2FD
+    if (PyModule_AddIntMacro(m, F_DUP2FD)) return -1;
+#endif
+#ifdef F_DUP2FD_CLOEXEC
+    if (PyModule_AddIntMacro(m, F_DUP2FD_CLOEXEC)) return -1;
+#endif
+
+/* For F_{GET|SET}FL */
+#ifdef FD_CLOEXEC
+    if (PyModule_AddIntMacro(m, FD_CLOEXEC)) return -1;
+#endif
+
+/* For F_NOTIFY */
+#ifdef DN_ACCESS
+    if (PyModule_AddIntMacro(m, DN_ACCESS)) return -1;
+#endif
+#ifdef DN_MODIFY
+    if (PyModule_AddIntMacro(m, DN_MODIFY)) return -1;
+#endif
+#ifdef DN_CREATE
+    if (PyModule_AddIntMacro(m, DN_CREATE)) return -1;
+#endif
+#ifdef DN_DELETE
+    if (PyModule_AddIntMacro(m, DN_DELETE)) return -1;
+#endif
+#ifdef DN_RENAME
+    if (PyModule_AddIntMacro(m, DN_RENAME)) return -1;
+#endif
+#ifdef DN_ATTRIB
+    if (PyModule_AddIntMacro(m, DN_ATTRIB)) return -1;
+#endif
+#ifdef DN_MULTISHOT
+    if (PyModule_AddIntMacro(m, DN_MULTISHOT)) return -1;
+#endif
+
+#ifdef HAVE_STROPTS_H
+    /* Unix 98 guarantees that these are in stropts.h. */
+    if (PyModule_AddIntMacro(m, I_PUSH)) return -1;
+    if (PyModule_AddIntMacro(m, I_POP)) return -1;
+    if (PyModule_AddIntMacro(m, I_LOOK)) return -1;
+    if (PyModule_AddIntMacro(m, I_FLUSH)) return -1;
+    if (PyModule_AddIntMacro(m, I_FLUSHBAND)) return -1;
+    if (PyModule_AddIntMacro(m, I_SETSIG)) return -1;
+    if (PyModule_AddIntMacro(m, I_GETSIG)) return -1;
+    if (PyModule_AddIntMacro(m, I_FIND)) return -1;
+    if (PyModule_AddIntMacro(m, I_PEEK)) return -1;
+    if (PyModule_AddIntMacro(m, I_SRDOPT)) return -1;
+    if (PyModule_AddIntMacro(m, I_GRDOPT)) return -1;
+    if (PyModule_AddIntMacro(m, I_NREAD)) return -1;
+    if (PyModule_AddIntMacro(m, I_FDINSERT)) return -1;
+    if (PyModule_AddIntMacro(m, I_STR)) return -1;
+    if (PyModule_AddIntMacro(m, I_SWROPT)) return -1;
+#ifdef I_GWROPT
+    /* despite the comment above, old-ish glibcs miss a couple... */
+    if (PyModule_AddIntMacro(m, I_GWROPT)) return -1;
+#endif
+    if (PyModule_AddIntMacro(m, I_SENDFD)) return -1;
+    if (PyModule_AddIntMacro(m, I_RECVFD)) return -1;
+    if (PyModule_AddIntMacro(m, I_LIST)) return -1;
+    if (PyModule_AddIntMacro(m, I_ATMARK)) return -1;
+    if (PyModule_AddIntMacro(m, I_CKBAND)) return -1;
+    if (PyModule_AddIntMacro(m, I_GETBAND)) return -1;
+    if (PyModule_AddIntMacro(m, I_CANPUT)) return -1;
+    if (PyModule_AddIntMacro(m, I_SETCLTIME)) return -1;
+#ifdef I_GETCLTIME
+    if (PyModule_AddIntMacro(m, I_GETCLTIME)) return -1;
+#endif
+    if (PyModule_AddIntMacro(m, I_LINK)) return -1;
+    if (PyModule_AddIntMacro(m, I_UNLINK)) return -1;
+    if (PyModule_AddIntMacro(m, I_PLINK)) return -1;
+    if (PyModule_AddIntMacro(m, I_PUNLINK)) return -1;
+#endif
+#ifdef F_ADD_SEALS
+    /* Linux: file sealing for memfd_create() */
+    if (PyModule_AddIntMacro(m, F_ADD_SEALS)) return -1;
+    if (PyModule_AddIntMacro(m, F_GET_SEALS)) return -1;
+    if (PyModule_AddIntMacro(m, F_SEAL_SEAL)) return -1;
+    if (PyModule_AddIntMacro(m, F_SEAL_SHRINK)) return -1;
+    if (PyModule_AddIntMacro(m, F_SEAL_GROW)) return -1;
+    if (PyModule_AddIntMacro(m, F_SEAL_WRITE)) return -1;
+#endif
+    return 0;
+}
+
+static int
+fcntl_exec(PyObject *module)
+{
+    if (all_ins(module) < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+static PyModuleDef_Slot fcntl_slots[] = {
+    {Py_mod_exec, fcntl_exec},
+    {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
+    {0, NULL}
+};
+
+static struct PyModuleDef fcntlmodule = {
+    PyModuleDef_HEAD_INIT,
+    .m_name = "fcntl",
+    .m_doc = module_doc,
+    .m_size = 0,
+    .m_methods = fcntl_methods,
+    .m_slots = fcntl_slots,
+};
+
+PyMODINIT_FUNC
+PyInit_fcntl(void)
+{
+    return PyModuleDef_Init(&fcntlmodule);
+}