Index: setup.py
===================================================================
--- setup.py	(revision 83356)
+++ setup.py	(working copy)
@@ -1636,8 +1636,7 @@
                    '_ctypes/callbacks.c',
                    '_ctypes/callproc.c',
                    '_ctypes/stgdict.c',
-                   '_ctypes/cfield.c',
-                   '_ctypes/malloc_closure.c']
+                   '_ctypes/cfield.c']
         depends = ['_ctypes/ctypes.h']
 
         if sys.platform == 'darwin':
Index: Modules/_ctypes/malloc_closure.c
===================================================================
--- Modules/_ctypes/malloc_closure.c	(revision 83356)
+++ Modules/_ctypes/malloc_closure.c	(working copy)
@@ -1,110 +0,0 @@
-#include <Python.h>
-#include <ffi.h>
-#ifdef MS_WIN32
-#include <windows.h>
-#else
-#include <sys/mman.h>
-#include <unistd.h>
-# if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
-#  define MAP_ANONYMOUS MAP_ANON
-# endif
-#endif
-#include "ctypes.h"
-
-/* BLOCKSIZE can be adjusted.  Larger blocksize will take a larger memory
-   overhead, but allocate less blocks from the system.  It may be that some
-   systems have a limit of how many mmap'd blocks can be open.
-*/
-
-#define BLOCKSIZE _pagesize
-
-/* #define MALLOC_CLOSURE_DEBUG */ /* enable for some debugging output */
-
-/******************************************************************/
-
-typedef union _tagITEM {
-    ffi_closure closure;
-    union _tagITEM *next;
-} ITEM;
-
-static ITEM *free_list;
-static int _pagesize;
-
-static void more_core(void)
-{
-    ITEM *item;
-    int count, i;
-
-/* determine the pagesize */
-#ifdef MS_WIN32
-    if (!_pagesize) {
-        SYSTEM_INFO systeminfo;
-        GetSystemInfo(&systeminfo);
-        _pagesize = systeminfo.dwPageSize;
-    }
-#else
-    if (!_pagesize) {
-#ifdef _SC_PAGESIZE
-        _pagesize = sysconf(_SC_PAGESIZE);
-#else
-        _pagesize = getpagesize();
-#endif
-    }
-#endif
-
-    /* calculate the number of nodes to allocate */
-    count = BLOCKSIZE / sizeof(ITEM);
-
-    /* allocate a memory block */
-#ifdef MS_WIN32
-    item = (ITEM *)VirtualAlloc(NULL,
-                                           count * sizeof(ITEM),
-                                           MEM_COMMIT,
-                                           PAGE_EXECUTE_READWRITE);
-    if (item == NULL)
-        return;
-#else
-    item = (ITEM *)mmap(NULL,
-                        count * sizeof(ITEM),
-                        PROT_READ | PROT_WRITE | PROT_EXEC,
-                        MAP_PRIVATE | MAP_ANONYMOUS,
-                        -1,
-                        0);
-    if (item == (void *)MAP_FAILED)
-        return;
-#endif
-
-#ifdef MALLOC_CLOSURE_DEBUG
-    printf("block at %p allocated (%d bytes), %d ITEMs\n",
-           item, count * sizeof(ITEM), count);
-#endif
-    /* put them into the free list */
-    for (i = 0; i < count; ++i) {
-        item->next = free_list;
-        free_list = item;
-        ++item;
-    }
-}
-
-/******************************************************************/
-
-/* put the item back into the free list */
-void _ctypes_free_closure(void *p)
-{
-    ITEM *item = (ITEM *)p;
-    item->next = free_list;
-    free_list = item;
-}
-
-/* return one item from the free list, allocating more if needed */
-void *_ctypes_alloc_closure(void)
-{
-    ITEM *item;
-    if (!free_list)
-        more_core();
-    if (!free_list)
-        return NULL;
-    item = free_list;
-    free_list = item->next;
-    return item;
-}
Index: Modules/_ctypes/_ctypes.c
===================================================================
--- Modules/_ctypes/_ctypes.c	(revision 83356)
+++ Modules/_ctypes/_ctypes.c	(working copy)
@@ -3367,7 +3367,7 @@
     self->callable = callable;
 
     self->thunk = thunk;
-    *(void **)self->b_ptr = (void *)thunk->pcl;
+    *(void **)self->b_ptr = (void *)thunk->pcl_exec;
 
     Py_INCREF((PyObject *)thunk); /* for KeepRef */
     if (-1 == KeepRef((CDataObject *)self, 0, (PyObject *)thunk)) {
Index: Modules/_ctypes/ctypes.h
===================================================================
--- Modules/_ctypes/ctypes.h	(revision 83356)
+++ Modules/_ctypes/ctypes.h	(working copy)
@@ -54,7 +54,8 @@
 
 typedef struct {
     PyObject_VAR_HEAD
-    ffi_closure *pcl; /* the C callable */
+    ffi_closure *pcl_write; /* the C callable, writeable */
+    void *pcl_exec;         /* the C callable, executable */
     ffi_cif cif;
     int flags;
     PyObject *converters;
Index: Modules/_ctypes/callbacks.c
===================================================================
--- Modules/_ctypes/callbacks.c	(revision 83356)
+++ Modules/_ctypes/callbacks.c	(working copy)
@@ -16,8 +16,8 @@
     Py_XDECREF(self->converters);
     Py_XDECREF(self->callable);
     Py_XDECREF(self->restype);
-    if (self->pcl)
-        _ctypes_free_closure(self->pcl);
+    if (self->pcl_write)
+        ffi_closure_free(self->pcl_write);
     PyObject_GC_Del(self);
 }
 
@@ -370,7 +370,8 @@
         return NULL;
     }
 
-    p->pcl = NULL;
+    p->pcl_exec = NULL;
+    p->pcl_write = NULL;
     memset(&p->cif, 0, sizeof(p->cif));
     p->converters = NULL;
     p->callable = NULL;
@@ -400,8 +401,9 @@
 
     assert(CThunk_CheckExact((PyObject *)p));
 
-    p->pcl = _ctypes_alloc_closure();
-    if (p->pcl == NULL) {
+    p->pcl_write = ffi_closure_alloc(sizeof(ffi_closure),
+                                     &p->pcl_exec);
+    if (p->pcl_write == NULL) {
         PyErr_NoMemory();
         goto error;
     }
@@ -446,7 +448,9 @@
                      "ffi_prep_cif failed with %d", result);
         goto error;
     }
-    result = ffi_prep_closure(p->pcl, &p->cif, closure_fcn, p);
+    result = ffi_prep_closure_loc(p->pcl_write, &p->cif, closure_fcn,
+                                  p,
+                                  p->pcl_exec);
     if (result != FFI_OK) {
         PyErr_Format(PyExc_RuntimeError,
                      "ffi_prep_closure failed with %d", result);