python
diff --git a/‎Lib/test/test_external_inspection.py‎
Lines changed: 7 additions & 1 deletion b/‎Lib/test/test_external_inspection.py‎
Lines changed: 7 additions & 1 deletion
diff --git a/‎Modules/_testexternalinspection.c‎
Lines changed: 20 additions & 7 deletions b/‎Modules/_testexternalinspection.c‎
Lines changed: 20 additions & 7 deletions
@@ -434,7 +434,11 @@ async def main():
                         # no synchronization. That occasionally leads to invalid
                         # reads. Here we avoid making the test flaky.
                         msg = str(re)
-                        if msg.startswith("Unknown error reading memory"):
+                        if msg.startswith("Task list appears corrupted"):
+                            continue
+                        elif msg.startswith("Invalid linked list structure reading remote memory"):
+                            continue
+                        elif msg.startswith("Unknown error reading memory"):
                             continue
                         elif msg.startswith("Unhandled frame owner"):
                             continue
@@ -445,6 +449,8 @@ async def main():
                 self.assertEqual(len(all_awaited_by), 2)
                 # expected: a tuple with the thread ID and the awaited_by list
                 self.assertEqual(len(all_awaited_by[0]), 2)
+                # expected: no tasks in the fallback per-interp task list
+                self.assertEqual(all_awaited_by[1], (0, []))
                 entries = all_awaited_by[0][1]
                 # expected: at least 1000 pending tasks
                 self.assertGreaterEqual(len(entries), 1000)
 
@@ -1490,13 +1490,21 @@ append_awaited_by_for_thread(
         return -1;
     }
 
-size_t iteration_count = 0;
-const size_t MAX_ITERATIONS = 100000;  // Reasonable upper bound
-while ((uintptr_t)task_node.next != head_addr) {
-    if (++iteration_count > MAX_ITERATIONS) {
-        PyErr_SetString(PyExc_RuntimeError, "Task list appears corrupted");
-        return -1;
-    }
+    size_t iteration_count = 0;
+    const size_t MAX_ITERATIONS = 2 << 15;  // A reasonable upper bound
+    while ((uintptr_t)task_node.next != head_addr) {
+        if (++iteration_count > MAX_ITERATIONS) {
+            PyErr_SetString(PyExc_RuntimeError, "Task list appears corrupted");
+            return -1;
+        }
+
+        if (task_node.next == NULL) {
+            PyErr_SetString(
+                PyExc_RuntimeError,
+                "Invalid linked list structure reading remote memory");
+            return -1;
+        }
+
         uintptr_t task_addr = (uintptr_t)task_node.next
             - async_offsets->asyncio_task_object.task_node;
 
@@ -1698,6 +1706,11 @@ get_all_awaited_by(PyObject* self, PyObject* args)
     head_addr = interpreter_state_addr
         + local_async_debug.asyncio_interpreter_state.asyncio_tasks_head;
 
+    // On top of a per-thread task lists used by default by asyncio to avoid
+    // contention, there is also a fallback per-interpreter list of tasks;
+    // any tasks still pending when a thread is destroyed will be moved to the
+    // per-interpreter task list.  It's unlikely we'll find anything here, but
+    // interesting for debugging.
     if (append_awaited_by(pid, 0, head_addr, &local_debug_offsets,
                         &local_async_debug, result))
     {