Add debug asserts

Author: pablogsal

Modules/_remote_debugging_module.c

@@ -11,6 +11,7 @@
  * HEADERS AND INCLUDES
  * ============================================================================ */
 
+#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
@@ -2479,6 +2480,8 @@ unwind_stack_for_thread(
     Py_XDECREF(thread_id);
     Py_XDECREF(result);
     cleanup_stack_chunks(&chunks);
+    /* Assert that an exception has been set when returning NULL */
+    assert(PyErr_Occurred());
     return NULL;
 }
 
@@ -2761,6 +2764,8 @@ _remote_debugging_RemoteUnwinder_get_stack_trace_impl(RemoteUnwinderObject *self
 
 exit:
    _Py_RemoteDebug_ClearCache(&self->handle);
+    /* Assert that if we're returning NULL, an exception has been set */
+    assert(result != NULL || PyErr_Occurred());
     return result;
 }
 
@@ -2849,6 +2854,8 @@ _remote_debugging_RemoteUnwinder_get_all_awaited_by_impl(RemoteUnwinderObject *s
 result_err:
     _Py_RemoteDebug_ClearCache(&self->handle);
     Py_XDECREF(result);
+    /* Assert that an exception has been set when returning NULL */
+    assert(PyErr_Occurred());
     return NULL;
 }
 
@@ -2923,6 +2930,8 @@ _remote_debugging_RemoteUnwinder_get_async_stack_trace_impl(RemoteUnwinderObject
 result_err:
     _Py_RemoteDebug_ClearCache(&self->handle);
     Py_XDECREF(result);
+    /* Assert that an exception has been set when returning NULL */
+    assert(PyErr_Occurred());
     return NULL;
 }
 

Python/remote_debug.h

@@ -67,6 +67,7 @@ extern "C" {
 #include <tlhelp32.h>
 #endif
 
+#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
@@ -165,6 +166,7 @@ _Py_RemoteDebug_InitProcHandle(proc_handle_t *handle, pid_t pid) {
     handle->task = pid_to_task(handle->pid);
     if (handle->task == 0) {
         _set_debug_exception_cause(PyExc_RuntimeError, "Failed to initialize macOS process handle");
+        assert(PyErr_Occurred());
         return -1;
     }
 #elif defined(MS_WINDOWS)
@@ -174,6 +176,7 @@ _Py_RemoteDebug_InitProcHandle(proc_handle_t *handle, pid_t pid) {
     if (handle->hProcess == NULL) {
         PyErr_SetFromWindowsErr(0);
         _set_debug_exception_cause(PyExc_RuntimeError, "Failed to initialize Windows process handle");
+        assert(PyErr_Occurred());
         return -1;
     }
 #elif defined(__linux__)
@@ -248,6 +251,7 @@ return_section_address64(
                         "mach_vm_region failed while parsing 64-bit Mach-O binary "
                         "at base address 0x%lx (kern_return_t: %d)",
                         base, ret);
+                    assert(PyErr_Occurred());
                     return 0;
                 }
             }
@@ -311,6 +315,7 @@ return_section_address32(
                         "mach_vm_region failed while parsing 32-bit Mach-O binary "
                         "at base address 0x%lx (kern_return_t: %d)",
                         base, ret);
+                    assert(PyErr_Occurred());
                     return 0;
                 }
             }
@@ -352,13 +357,15 @@ return_section_address_fat(
             "Failed to determine CPU type via sysctlbyname "
             "for fat binary analysis at 0x%lx: %s",
             base, strerror(errno));
+        assert(PyErr_Occurred());
         return 0;
     }
     if (sysctlbyname("hw.cpu64bit_capable", &is_abi64, &abi64_size, NULL, 0) != 0) {
         PyErr_Format(PyExc_OSError,
             "Failed to determine CPU ABI capability via sysctlbyname "
             "for fat binary analysis at 0x%lx: %s",
             base, strerror(errno));
+        assert(PyErr_Occurred());
         return 0;
     }
 
@@ -403,6 +410,7 @@ return_section_address_fat(
         "No matching architecture found for CPU type 0x%x "
         "in fat binary at base 0x%lx (%u architectures examined)",
         cpu, base, nfat_arch);
+    assert(PyErr_Occurred());
     return 0;
 }
 
@@ -414,6 +422,7 @@ search_section_in_file(const char* secname, char* path, uintptr_t base, mach_vm_
         PyErr_Format(PyExc_OSError,
             "Cannot open binary file '%s' for section '%s' search: %s",
             path, secname, strerror(errno));
+        assert(PyErr_Occurred());
         return 0;
     }
 
@@ -423,6 +432,7 @@ search_section_in_file(const char* secname, char* path, uintptr_t base, mach_vm_
             "Cannot get file size for binary '%s' during section '%s' search: %s",
             path, secname, strerror(errno));
         close(fd);
+        assert(PyErr_Occurred());
         return 0;
     }
 
@@ -432,6 +442,7 @@ search_section_in_file(const char* secname, char* path, uintptr_t base, mach_vm_
             "Cannot memory map binary file '%s' (size: %lld bytes) for section '%s' search: %s",
             path, (long long)fs.st_size, secname, strerror(errno));
         close(fd);
+        assert(PyErr_Occurred());
         return 0;
     }
 
@@ -455,6 +466,7 @@ search_section_in_file(const char* secname, char* path, uintptr_t base, mach_vm_
         PyErr_Format(PyExc_RuntimeError,
             "Unrecognized Mach-O magic number 0x%x in binary file '%s' for section '%s' search",
             magic, path, secname);
+        assert(PyErr_Occurred());
         break;
     }
 
@@ -486,6 +498,7 @@ pid_to_task(pid_t pid)
             "Cannot get task port for PID %d (kern_return_t: %d). "
             "This typically requires running as root or having the 'com.apple.system-task-ports' entitlement.",
             pid, result);
+        assert(PyErr_Occurred());
         return 0;
     }
     return task;
@@ -506,6 +519,7 @@ search_map_for_section(proc_handle_t *handle, const char* secname, const char* s
                 "Cannot get task port for PID %d during section search",
                 handle->pid);
         }
+        assert(PyErr_Occurred());
         return 0;
     }
 
@@ -671,6 +685,7 @@ search_linux_map_for_section(proc_handle_t *handle, const char* secname, const c
         PyErr_Format(PyExc_OSError,
             "Cannot open process memory map file '%s' for PID %d section search: %s",
             maps_file_path, handle->pid, strerror(errno));
+        assert(PyErr_Occurred());
         return 0;
     }
 
@@ -832,6 +847,8 @@ static void* analyze_pe(const wchar_t* mod_path, BYTE* remote_base, const char*
     CloseHandle(hMap);
     CloseHandle(hFile);
 
+    /* Assert that if we're returning NULL, an exception should be set somewhere up the call stack */
+    assert(runtime_addr != NULL || PyErr_Occurred());
     return runtime_addr;
 }
 
@@ -850,6 +867,7 @@ search_windows_map_for_section(proc_handle_t* handle, const char* secname, const
             "Unable to create module snapshot for PID %d section '%s' "
             "search (error %lu). Check permissions or PID validity",
             handle->pid, secname, error);
+        assert(PyErr_Occurred());
         return 0;
     }
 
@@ -923,6 +941,7 @@ _Py_RemoteDebug_GetPyRuntimeAddress(proc_handle_t* handle)
 #else
     _set_debug_exception_cause(PyExc_RuntimeError,
         "Reading the PyRuntime section is not supported on this platform");
+    assert(PyErr_Occurred());
     return 0;
 #endif
 
@@ -942,6 +961,7 @@ open_proc_mem_fd(proc_handle_t *handle)
         PyErr_SetFromErrno(PyExc_OSError);
         _set_debug_exception_cause(PyExc_OSError,
             "failed to open file %s: %s", mem_file_path, strerror(errno));
+        assert(PyErr_Occurred());
         return -1;
     }
     return 0;
@@ -974,6 +994,7 @@ read_remote_memory_fallback(proc_handle_t *handle, uintptr_t remote_address, siz
                 "preadv failed for PID %d at address 0x%lx "
                 "(size %zu, partial read %zd bytes): %s",
                 handle->pid, remote_address + result, len - result, result, strerror(errno));
+            assert(PyErr_Occurred());
             return -1;
         }
 
@@ -998,6 +1019,7 @@ _Py_RemoteDebug_ReadRemoteMemory(proc_handle_t *handle, uintptr_t remote_address
             if (!is_process_alive(handle->hProcess)) {
                 _set_errno(ESRCH);
                 PyErr_SetFromErrno(PyExc_OSError);
+                assert(PyErr_Occurred());
                 return -1;
             }
             PyErr_SetFromWindowsErr(0);
@@ -1006,6 +1028,7 @@ _Py_RemoteDebug_ReadRemoteMemory(proc_handle_t *handle, uintptr_t remote_address
                 "ReadProcessMemory failed for PID %d at address 0x%lx "
                 "(size %zu, partial read %zu bytes): Windows error %lu",
                 handle->pid, remote_address + result, len - result, result, error);
+            assert(PyErr_Occurred());
             return -1;
         }
         result += read_bytes;
@@ -1033,12 +1056,14 @@ _Py_RemoteDebug_ReadRemoteMemory(proc_handle_t *handle, uintptr_t remote_address
             }
             PyErr_SetFromErrno(PyExc_OSError);
             if (errno == ESRCH) {
+                assert(PyErr_Occurred());
                 return -1;
             }
             _set_debug_exception_cause(PyExc_OSError,
                 "process_vm_readv failed for PID %d at address 0x%lx "
                 "(size %zu, partial read %zd bytes): %s",
                 handle->pid, remote_address + result, len - result, result, strerror(errno));
+            assert(PyErr_Occurred());
             return -1;
         }
 
@@ -1094,6 +1119,7 @@ _Py_RemoteDebug_ReadRemoteMemory(proc_handle_t *handle, uintptr_t remote_address
                 "(size %zu): kern_return_t %d",
                 handle->pid, remote_address, len, kr);
         }
+        assert(PyErr_Occurred());
         return -1;
     }
     return 0;
@@ -1108,6 +1134,7 @@ _Py_RemoteDebug_PagedReadRemoteMemory(proc_handle_t *handle,
                                       size_t size,
                                       void *out)
 {
+    int result = 0;
     size_t page_size = handle->page_size;
     uintptr_t page_base = addr & ~(page_size - 1);
     size_t offset_in_page = addr - page_base;
@@ -1136,6 +1163,7 @@ _Py_RemoteDebug_PagedReadRemoteMemory(proc_handle_t *handle,
                         "Cannot allocate %zu bytes for page cache entry "
                         "during read from PID %d at address 0x%lx",
                         page_size, handle->pid, addr);
+                    assert(PyErr_Occurred());
                     return -1;
                 }
             }
@@ -1155,7 +1183,9 @@ _Py_RemoteDebug_PagedReadRemoteMemory(proc_handle_t *handle,
 
 fallback:
     // Cache full — fallback to uncached read
-    return _Py_RemoteDebug_ReadRemoteMemory(handle, addr, size, out);
+    result = _Py_RemoteDebug_ReadRemoteMemory(handle, addr, size, out);
+    assert(result == 0 || PyErr_Occurred());
+    return result;
 }
 
 static int
@@ -1172,11 +1202,13 @@ _Py_RemoteDebug_ReadDebugOffsets(
                 handle->pid);
         }
         _set_debug_exception_cause(PyExc_RuntimeError, "PyRuntime address lookup failed during debug offsets initialization");
+        assert(PyErr_Occurred());
         return -1;
     }
     size_t size = sizeof(struct _Py_DebugOffsets);
     if (0 != _Py_RemoteDebug_ReadRemoteMemory(handle, *runtime_start_address, size, debug_offsets)) {
         _set_debug_exception_cause(PyExc_RuntimeError, "Failed to read debug offsets structure from remote process");
+        assert(PyErr_Occurred());
         return -1;
     }
     return 0;