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;
     }
 
@@ -762,13 +777,15 @@ static int is_process_alive(HANDLE hProcess) {
 }
 
 static void* analyze_pe(const wchar_t* mod_path, BYTE* remote_base, const char* secname) {
+    printf("DEBUG: analyze_pe called with mod_path=%ls, remote_base=%p, secname=%s\n", mod_path, remote_base, secname);
     HANDLE hFile = CreateFileW(mod_path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
     if (hFile == INVALID_HANDLE_VALUE) {
         PyErr_SetFromWindowsErr(0);
         DWORD error = GetLastError();
         PyErr_Format(PyExc_OSError,
             "Cannot open PE file for section '%s' analysis (error %lu)",
             secname, error);
+        printf("DEBUG: analyze_pe failed to open file, error=%lu\n", error);
         return NULL;
     }
 
@@ -820,10 +837,14 @@ static void* analyze_pe(const wchar_t* mod_path, BYTE* remote_base, const char*
     IMAGE_SECTION_HEADER* pSection_header = (IMAGE_SECTION_HEADER*)(mapView + pDOSHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS));
     void* runtime_addr = NULL;
 
+    printf("DEBUG: analyze_pe searching for section '%s', NumberOfSections=%d\n", secname, pNTHeaders->FileHeader.NumberOfSections);
     for (int i = 0; i < pNTHeaders->FileHeader.NumberOfSections; i++) {
         const char* name = (const char*)pSection_header[i].Name;
+        printf("DEBUG: analyze_pe section[%d] name='%.8s'\n", i, name);
         if (strncmp(name, secname, IMAGE_SIZEOF_SHORT_NAME) == 0) {
             runtime_addr = remote_base + pSection_header[i].VirtualAddress;
+            printf("DEBUG: analyze_pe found matching section at virtual address=0x%x, runtime_addr=%p\n", 
+                   pSection_header[i].VirtualAddress, runtime_addr);
             break;
         }
     }
@@ -832,12 +853,25 @@ static void* analyze_pe(const wchar_t* mod_path, BYTE* remote_base, const char*
     CloseHandle(hMap);
     CloseHandle(hFile);
 
+    if (runtime_addr == NULL) {
+        printf("DEBUG: analyze_pe section '%s' not found, setting error\n", secname);
+        // PyErr_Format(PyExc_RuntimeError,
+        //     "Section '%s' not found in PE file",
+        //     secname);
+    } else {
+        printf("DEBUG: analyze_pe returning runtime_addr=%p\n", runtime_addr);
+    }
+
+    /* 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;
 }
 
 
 static uintptr_t
 search_windows_map_for_section(proc_handle_t* handle, const char* secname, const wchar_t* substr) {
+    printf("DEBUG: search_windows_map_for_section called with pid=%d, secname=%s, substr=%ls\n", 
+           handle->pid, secname, substr);
     HANDLE hProcSnap;
     do {
         hProcSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, handle->pid);
@@ -850,25 +884,34 @@ 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;
     }
 
     MODULEENTRY32W moduleEntry;
     moduleEntry.dwSize = sizeof(moduleEntry);
     void* runtime_addr = NULL;
 
+    printf("DEBUG: search_windows_map_for_section enumerating modules\n");
     for (BOOL hasModule = Module32FirstW(hProcSnap, &moduleEntry); hasModule; hasModule = Module32NextW(hProcSnap, &moduleEntry)) {
+        printf("DEBUG: search_windows_map_for_section checking module: %ls\n", moduleEntry.szModule);
         // Look for either python executable or DLL
         if (wcsstr(moduleEntry.szModule, substr)) {
+            printf("DEBUG: search_windows_map_for_section found matching module: %ls, path: %ls\n", 
+                   moduleEntry.szModule, moduleEntry.szExePath);
             runtime_addr = analyze_pe(moduleEntry.szExePath, moduleEntry.modBaseAddr, secname);
             if (runtime_addr != NULL) {
+                printf("DEBUG: search_windows_map_for_section analyze_pe succeeded, runtime_addr=%p\n", runtime_addr);
                 break;
+            } else {
+                printf("DEBUG: search_windows_map_for_section analyze_pe failed for module %ls\n", moduleEntry.szModule);
             }
         }
     }
 
     CloseHandle(hProcSnap);
 
+    printf("DEBUG: search_windows_map_for_section returning runtime_addr=%p\n", runtime_addr);
     return (uintptr_t)runtime_addr;
 }
 
@@ -878,12 +921,16 @@ search_windows_map_for_section(proc_handle_t* handle, const char* secname, const
 static uintptr_t
 _Py_RemoteDebug_GetPyRuntimeAddress(proc_handle_t* handle)
 {
+    printf("DEBUG: _Py_RemoteDebug_GetPyRuntimeAddress called for pid=%d\n", handle->pid);
     uintptr_t address;
 
 #ifdef MS_WINDOWS
     // On Windows, search for 'python' in executable or DLL
+    printf("DEBUG: _Py_RemoteDebug_GetPyRuntimeAddress calling search_windows_map_for_section\n");
     address = search_windows_map_for_section(handle, "PyRuntime", L"python");
+    printf("DEBUG: _Py_RemoteDebug_GetPyRuntimeAddress search_windows_map_for_section returned address=0x%lx\n", address);
     if (address == 0) {
+        printf("DEBUG: _Py_RemoteDebug_GetPyRuntimeAddress address is 0, setting error\n");
         // Error out: 'python' substring covers both executable and DLL
         PyObject *exc = PyErr_GetRaisedException();
         PyErr_Format(PyExc_RuntimeError,
@@ -923,9 +970,11 @@ _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
 
+    printf("DEBUG: _Py_RemoteDebug_GetPyRuntimeAddress returning address=0x%lx\n", address);
     return address;
 }
 
@@ -942,6 +991,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 +1024,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 +1049,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 +1058,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 +1086,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 +1149,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 +1164,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 +1193,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 +1213,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 +1232,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;