User error codes and fix 32-bit system issues

Summary:
Port the latest changes from the [perf-map C-API PR](python/cpython#103546). This includes using error codes instead of exceptions to avoid the need to hold the GIL.

Additionally, there was an issue with Fedora on a 32-bit system that was fixed in this [PR](python/cpython#104811), so I also ported the fix.

Reviewed By: carljm

Differential Revision: D46041553

fbshipit-source-id: 6502189f489ca6cf11949ecd93c044e5ebe4fd2c

Author: Gamal Sallam

Doc/c-api/perfmaps.rst

@@ -1,5 +1,3 @@
-
-
 .. highlight:: c
 
 .. _perfmaps:
@@ -10,30 +8,43 @@ Support for Perf Maps
 On supported platforms (as of this writing, only Linux), the runtime can take
 advantage of *perf map files* to make Python functions visible to an external
 profiling tool (such as `perf <https://perf.wiki.kernel.org/index.php/Main_Page>`_).
-A running process may create a file in the `/tmp` directory, which contains entries
+A running process may create a file in the ``/tmp`` directory, which contains entries
 that can map a section of executable code to a name. This interface is described in the
 `documentation of the Linux Perf tool <https://git.kernel.org/pub/scm/linux/
 kernel/git/torvalds/linux.git/tree/tools/perf/Documentation/jit-interface.txt>`_.
 
 In Python, these helper APIs can be used by libraries and features that rely
 on generating machine code on the fly.
 
+Note that holding the Global Interpreter Lock (GIL) is not required for these APIs.
+
 .. c:function:: int PyUnstable_PerfMapState_Init(void)
-   Open the `/tmp/perf-$pid.map` file, unless it's already opened, and create
+
+   Open the ``/tmp/perf-$pid.map`` file, unless it's already opened, and create
    a lock to ensure thread-safe writes to the file (provided the writes are
    done through :c:func:`PyUnstable_WritePerfMapEntry`). Normally, there's no need
-   to call this explicitly, and it is safe to directly use :c:func:`PyUnstable_WritePerfMapEntry`
-   in your code. If the state isn't already initialized, it will be created on
-   the first call.
+   to call this explicitly; just use :c:func:`PyUnstable_WritePerfMapEntry`
+   and it will initialize the state on first call.
+
+   Returns ``0`` on success, ``-1`` on failure to create/open the perf map file,
+   or ``-2`` on failure to create a lock. Check ``errno`` for more information
+   about the cause of a failure.
+
 .. c:function:: int PyUnstable_WritePerfMapEntry(const void *code_addr, unsigned int code_size, const char *entry_name)
-   Write one single entry to the `/tmp/perf-$pid.map` file. This function is
+
+   Write one single entry to the ``/tmp/perf-$pid.map`` file. This function is
    thread safe. Here is what an example entry looks like::
+
       # address      size  name
-      0x7f3529fcf759 b     py::bar:/run/t.py
-   Extensions are encouraged to directly call this API when needed, instead of
-   separately initializing the state by calling :c:func:`PyUnstable_PerfMapState_Init`.
-.. c:function:: int PyUnstable_PerfMapState_Fini(void)
-   Close the perf map file, which was opened in `PyUnstable_PerfMapState_Init`. This
-   API is called by the runtime itself, during interpreter shut-down. In general,
-   there shouldn't be a reason to explicitly call this, except to handle specific
-   scenarios such as forking.
+      7f3529fcf759 b     py::bar:/run/t.py
+
+   Will call :c:func:`PyUnstable_PerfMapState_Init` before writing the entry, if
+   the perf map file is not already opened. Returns ``0`` on success, or the
+   same error codes as :c:func:`PyUnstable_PerfMapState_Init` on failure.
+
+.. c:function:: void PyUnstable_PerfMapState_Fini(void)
+
+   Close the perf map file opened by :c:func:`PyUnstable_PerfMapState_Init`.
+   This is called by the runtime itself during interpreter shut-down. In
+   general, there shouldn't be a reason to explicitly call this, except to
+   handle specific scenarios such as forking.

Include/osmodule.h

@@ -11,19 +11,6 @@ extern "C" {
 PyAPI_FUNC(PyObject *) PyOS_FSPath(PyObject *path);
 #endif
 
-#if !defined(Py_LIMITED_API)
-typedef struct {
-     FILE* perf_map;
-    PyThread_type_lock map_lock;
-} PerfMapState;
-
-PyAPI_FUNC(int) PyUnstable_PerfMapState_Init(void);
-
-PyAPI_FUNC(int) PyUnstable_WritePerfMapEntry(const void *code_addr, unsigned int code_size, const char *entry_name);
-
-PyAPI_FUNC(void) PyUnstable_PerfMapState_Fini(void);
-#endif
-
 #ifdef __cplusplus
 }
 #endif

Include/sysmodule.h

@@ -29,6 +29,19 @@ PyAPI_FUNC(int) PySys_HasWarnOptions(void);
 PyAPI_FUNC(void) PySys_AddXOption(const wchar_t *);
 PyAPI_FUNC(PyObject *) PySys_GetXOptions(void);
 
+#if !defined(Py_LIMITED_API)
+typedef struct {
+    FILE* perf_map;
+    PyThread_type_lock map_lock;
+} PerfMapState;
+
+PyAPI_FUNC(int) PyUnstable_PerfMapState_Init(void);
+
+PyAPI_FUNC(int) PyUnstable_WritePerfMapEntry(const void *code_addr, unsigned int code_size, const char *entry_name);
+
+PyAPI_FUNC(void) PyUnstable_PerfMapState_Fini(void);
+#endif
+
 #ifndef Py_LIMITED_API
 #  define Py_CPYTHON_SYSMODULE_H
 #  include  "cpython/sysmodule.h"

Modules/_testinternalcapi.c

@@ -413,19 +413,24 @@ test_gc_visit_objects(PyObject *Py_UNUSED(self), PyObject *Py_UNUSED(ignored)) {
 static PyObject *
 write_perf_map_entry(PyObject *self, PyObject *args)
 {
+    PyObject *code_addr_v;
     const void *code_addr;
     unsigned int code_size;
     const char *entry_name;
 
-    if (!PyArg_ParseTuple(args, "KIs", &code_addr, &code_size, &entry_name))
+    if (!PyArg_ParseTuple(args, "OIs", &code_addr_v, &code_size, &entry_name))
         return NULL;
+    code_addr = PyLong_AsVoidPtr(code_addr_v);
+    if (code_addr == NULL) {
+        return NULL;
+    }
 
     int ret = PyUnstable_WritePerfMapEntry(code_addr, code_size, entry_name);
-    if (ret == -1) {
-        PyErr_SetString(PyExc_OSError, "Failed to write performance map entry");
+    if (ret < 0) {
+        PyErr_SetFromErrno(PyExc_OSError);
         return NULL;
     }
-    return Py_BuildValue("i", ret);
+    return PyLong_FromLong(ret);
 }
 
 static PyObject *

Objects/perf_trampoline.c

@@ -194,13 +194,13 @@ perf_map_write_entry(void *state, const void *code_addr,
         filename = PyUnicode_AsUTF8(co->co_filename);
     }
     size_t perf_map_entry_size = snprintf(NULL, 0, "py::%s:%s", entry, filename) + 1;
-    char* perf_map_entry = (char*) malloc(perf_map_entry_size);
+    char* perf_map_entry = (char*) PyMem_RawMalloc(perf_map_entry_size);
     if (perf_map_entry == NULL) {
         return;
     }
     snprintf(perf_map_entry, perf_map_entry_size, "py::%s:%s", entry, filename);
     PyUnstable_WritePerfMapEntry(code_addr, code_size, perf_map_entry);
-    free(perf_map_entry);
+    PyMem_RawFree(perf_map_entry);
 }
 
 _PyPerf_Callbacks _Py_perfmap_callbacks = {
@@ -398,13 +398,6 @@ _PyPerfTrampoline_Init(int activate)
         if (new_code_arena() < 0) {
             return -1;
         }
-        if (trampoline_api.state == NULL && trampoline_api.init_state != NULL) {
-            void *state = trampoline_api.init_state();
-            if (state == NULL) {
-                return -1;
-            }
-            trampoline_api.state = state;
-        }
         extra_code_index = _PyEval_RequestCodeExtraIndex(NULL);
         if (extra_code_index == -1) {
             return -1;

Python/sysmodule.c

@@ -2110,20 +2110,19 @@ PyAPI_FUNC(int) PyUnstable_PerfMapState_Init(void) {
                 (intmax_t)pid);
     int fd = open(filename, flags, 0600);
     if (fd == -1) {
-        PyErr_SetFromErrnoWithFilename(PyExc_OSError, filename);
         return -1;
     }
     else{
         perf_map_state.perf_map = fdopen(fd, "a");
         if (perf_map_state.perf_map == NULL) {
-            PyErr_SetFromErrnoWithFilename(PyExc_OSError, filename);
+            close(fd);
             return -1;
         }
     }
     perf_map_state.map_lock = PyThread_allocate_lock();
     if (perf_map_state.map_lock == NULL) {
-        PyErr_SetString(PyExc_RuntimeError, "failed to create a lock for perf-maps");
-        return -1;
+        fclose(perf_map_state.perf_map);
+        return -2;
     }
 #endif
     return 0;
@@ -2136,8 +2135,9 @@ PyAPI_FUNC(int) PyUnstable_WritePerfMapEntry(
 ) {
 #ifndef MS_WINDOWS
     if (perf_map_state.perf_map == NULL) {
-        if(PyUnstable_PerfMapState_Init() == -1){
-            return -1;
+        int ret = PyUnstable_PerfMapState_Init();
+        if(ret != 0){
+            return ret;
         }
     }
     PyThread_acquire_lock(perf_map_state.map_lock, 1);