Fix: gh-152635 _interpchannels channel lock alloc failure

now raises MemoryError

Previously, an allocation failure when creating
the lock for a channel in _interpchannels would trigger an assert.
Caused by `handle_channel_error` being passed an error code of -1
which is only allowed if an exception has been set.
(in this case, no exception was set)

`channelsmod_create` now forwards the error code from `channel_create`
which `handle_channel_error` already handled.

Because the only way to get a -7 error code
(was `ERR_CHANNEL_MUTEX_INIT`) is via an allocation failure in
`PyThread_allocate_lock`, I made `handle_channel_error` raise a
`MemoryError` for this case rather than a `ChannelError`.

I also renamed the constant from `ERR_CHANNEL_MUTEX_INIT` to
`ERR_CHANNEL_ALLOC_LOCK` to make this clearer for future changes.

Author: stestagg

Lib/test/test_interpreters/test_channels.py

@@ -11,6 +11,7 @@
 from concurrent import interpreters
 from test.support import channels
 from .utils import _run_output, TestBase
+import _testcapi
 
 
 class LowLevelTests(TestBase):
@@ -30,6 +31,22 @@ def test_highlevel_reloaded(self):
         # See gh-115490 (https://github.com/python/cpython/issues/115490).
         importlib.reload(channels)
 
+    def test_lock_allocation_failure(self):
+        # see gh-152635 (https://github.com/python/cpython/issues/152635)
+        # The first allocation to happen is the lock, which
+        # historically triggered an assert if alloc failed.
+        cid = None
+        _testcapi.set_nomemory(0, 1)
+        try:
+            cid = _channels.create()
+        except MemoryError:
+            pass  # MemoryError is expected behavior
+        finally:
+            _testcapi.remove_mem_hooks()
+            if cid is not None:
+                _channels.close(cid, force=True)
+                _channels.destroy(cid)
+
 
 class TestChannels(TestBase):
 

Misc/NEWS.d/next/Core_and_Builtins/2026-06-29-23-29-14.gh-issue-152635.O21J0O.rst

@@ -0,0 +1,2 @@
+Fix a crash caused when running out of memory creating a
+:mod:`!_interpchannels` channel. Now a :exc:`MemoryError` is correctly raised.

Modules/_interpchannelsmodule.c

@@ -354,7 +354,7 @@ clear_module_state(module_state *state)
 #define ERR_CHANNEL_INTERP_CLOSED -4
 #define ERR_CHANNEL_EMPTY -5
 #define ERR_CHANNEL_NOT_EMPTY -6
-#define ERR_CHANNEL_MUTEX_INIT -7
+#define ERR_CHANNEL_MUTEX_ALLOC_FAIL -7
 #define ERR_CHANNELS_MUTEX_INIT -8
 #define ERR_NO_NEXT_CHANNEL_ID -9
 #define ERR_CHANNEL_CLOSED_WAITING -10
@@ -427,9 +427,8 @@ handle_channel_error(int err, PyObject *mod, int64_t cid)
                      "if not empty (try force=True)",
                      cid);
     }
-    else if (err == ERR_CHANNEL_MUTEX_INIT) {
-        PyErr_SetString(state->ChannelError,
-                        "can't initialize mutex for new channel");
+    else if (err == ERR_CHANNEL_MUTEX_ALLOC_FAIL) {
+        PyErr_NoMemory();
     }
     else if (err == ERR_CHANNELS_MUTEX_INIT) {
         PyErr_SetString(state->ChannelError,
@@ -1744,7 +1743,7 @@ channel_create(_channels *channels, struct _channeldefaults defaults)
 {
     PyThread_type_lock mutex = PyThread_allocate_lock();
     if (mutex == NULL) {
-        return ERR_CHANNEL_MUTEX_INIT;
+        return ERR_CHANNEL_MUTEX_ALLOC_FAIL;
     }
     _channel_state *chan = _channel_new(mutex, defaults);
     if (chan == NULL) {
@@ -2938,7 +2937,7 @@ channelsmod_create(PyObject *self, PyObject *args, PyObject *kwds)
 
     int64_t cid = channel_create(&_globals.channels, defaults);
     if (cid < 0) {
-        (void)handle_channel_error(-1, self, cid);
+        (void)handle_channel_error(cid, self, cid);
         return NULL;
     }
     module_state *state = get_module_state(self);