| #define _GNU_SOURCE |
| #include "pyconfig.h" |
| |
| #include "Python.h" |
| #include "internal/pycore_runtime.h" |
| #include "internal/pycore_ceval.h" |
| |
| #if defined(Py_REMOTE_DEBUG) && defined(Py_SUPPORTS_REMOTE_DEBUG) |
| #include "remote_debug.h" |
| |
| static int |
| init_proc_handle(proc_handle_t *handle, pid_t pid) { |
| return _Py_RemoteDebug_InitProcHandle(handle, pid); |
| } |
| |
| static void |
| cleanup_proc_handle(proc_handle_t *handle) { |
| _Py_RemoteDebug_CleanupProcHandle(handle); |
| } |
| |
| static int |
| read_memory(proc_handle_t *handle, uint64_t remote_address, size_t len, void* dst) |
| { |
| return _Py_RemoteDebug_ReadRemoteMemory(handle, remote_address, len, dst); |
| } |
| |
| // Why is pwritev not guarded? Except on Android API level 23 (no longer |
| // supported), HAVE_PROCESS_VM_READV is sufficient. |
| #if defined(__linux__) && HAVE_PROCESS_VM_READV |
| static int |
| write_memory_fallback(proc_handle_t *handle, uintptr_t remote_address, size_t len, const void* src) |
| { |
| if (handle->memfd == -1) { |
| if (open_proc_mem_fd(handle) < 0) { |
| return -1; |
| } |
| } |
| |
| struct iovec local[1]; |
| Py_ssize_t result = 0; |
| Py_ssize_t written = 0; |
| |
| do { |
| local[0].iov_base = (char*)src + result; |
| local[0].iov_len = len - result; |
| off_t offset = remote_address + result; |
| |
| written = pwritev(handle->memfd, local, 1, offset); |
| if (written < 0) { |
| PyErr_SetFromErrno(PyExc_OSError); |
| return -1; |
| } |
| |
| result += written; |
| } while ((size_t)written != local[0].iov_len); |
| return 0; |
| } |
| #endif // __linux__ |
| |
| static int |
| write_memory(proc_handle_t *handle, uintptr_t remote_address, size_t len, const void* src) |
| { |
| #ifdef MS_WINDOWS |
| SIZE_T written = 0; |
| SIZE_T result = 0; |
| do { |
| if (!WriteProcessMemory(handle->hProcess, (LPVOID)(remote_address + result), (const char*)src + result, len - result, &written)) { |
| PyErr_SetFromWindowsErr(0); |
| return -1; |
| } |
| result += written; |
| } while (result < len); |
| return 0; |
| #elif defined(__linux__) && HAVE_PROCESS_VM_READV |
| if (handle->memfd != -1) { |
| return write_memory_fallback(handle, remote_address, len, src); |
| } |
| struct iovec local[1]; |
| struct iovec remote[1]; |
| Py_ssize_t result = 0; |
| Py_ssize_t written = 0; |
| |
| do { |
| local[0].iov_base = (void*)((char*)src + result); |
| local[0].iov_len = len - result; |
| remote[0].iov_base = (void*)((char*)remote_address + result); |
| remote[0].iov_len = len - result; |
| |
| written = process_vm_writev(handle->pid, local, 1, remote, 1, 0); |
| if (written < 0) { |
| if (errno == ENOSYS) { |
| return write_memory_fallback(handle, remote_address, len, src); |
| } |
| PyErr_SetFromErrno(PyExc_OSError); |
| return -1; |
| } |
| |
| result += written; |
| } while ((size_t)written != local[0].iov_len); |
| return 0; |
| #elif defined(__APPLE__) && TARGET_OS_OSX |
| kern_return_t kr = mach_vm_write( |
| pid_to_task(handle->pid), |
| (mach_vm_address_t)remote_address, |
| (vm_offset_t)src, |
| (mach_msg_type_number_t)len); |
| |
| if (kr != KERN_SUCCESS) { |
| switch (kr) { |
| case KERN_PROTECTION_FAILURE: |
| PyErr_SetString(PyExc_PermissionError, "Not enough permissions to write memory"); |
| break; |
| case KERN_INVALID_ARGUMENT: |
| PyErr_SetString(PyExc_PermissionError, "Invalid argument to mach_vm_write"); |
| break; |
| default: |
| PyErr_Format(PyExc_RuntimeError, "Unknown error writing memory: %d", (int)kr); |
| } |
| return -1; |
| } |
| return 0; |
| #else |
| Py_UNREACHABLE(); |
| #endif |
| } |
| |
| static int |
| is_prerelease_version(uint64_t version) |
| { |
| return (version & 0xF0) != 0xF0; |
| } |
| |
| static int |
| ensure_debug_offset_compatibility(const _Py_DebugOffsets* debug_offsets) |
| { |
| if (memcmp(debug_offsets->cookie, _Py_Debug_Cookie, sizeof(debug_offsets->cookie)) != 0) { |
| // The remote is probably running a Python version predating debug offsets. |
| PyErr_SetString( |
| PyExc_RuntimeError, |
| "Can't determine the Python version of the remote process"); |
| return -1; |
| } |
| |
| // Assume debug offsets could change from one pre-release version to another, |
| // or one minor version to another, but are stable across patch versions. |
| if (is_prerelease_version(Py_Version) && Py_Version != debug_offsets->version) { |
| PyErr_SetString( |
| PyExc_RuntimeError, |
| "Can't send commands from a pre-release Python interpreter" |
| " to a process running a different Python version"); |
| return -1; |
| } |
| |
| if (is_prerelease_version(debug_offsets->version) && Py_Version != debug_offsets->version) { |
| PyErr_SetString( |
| PyExc_RuntimeError, |
| "Can't send commands to a pre-release Python interpreter" |
| " from a process running a different Python version"); |
| return -1; |
| } |
| |
| unsigned int remote_major = (debug_offsets->version >> 24) & 0xFF; |
| unsigned int remote_minor = (debug_offsets->version >> 16) & 0xFF; |
| |
| if (PY_MAJOR_VERSION != remote_major || PY_MINOR_VERSION != remote_minor) { |
| PyErr_Format( |
| PyExc_RuntimeError, |
| "Can't send commands from a Python %d.%d process to a Python %d.%d process", |
| PY_MAJOR_VERSION, PY_MINOR_VERSION, remote_major, remote_minor); |
| return -1; |
| } |
| |
| // The debug offsets differ between free threaded and non-free threaded builds. |
| if (_Py_Debug_Free_Threaded && !debug_offsets->free_threaded) { |
| PyErr_SetString( |
| PyExc_RuntimeError, |
| "Cannot send commands from a free-threaded Python process" |
| " to a process running a non-free-threaded version"); |
| return -1; |
| } |
| |
| if (!_Py_Debug_Free_Threaded && debug_offsets->free_threaded) { |
| PyErr_SetString( |
| PyExc_RuntimeError, |
| "Cannot send commands to a free-threaded Python process" |
| " from a process running a non-free-threaded version"); |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| static int |
| read_offsets( |
| proc_handle_t *handle, |
| uintptr_t *runtime_start_address, |
| _Py_DebugOffsets* debug_offsets |
| ) { |
| if (_Py_RemoteDebug_ReadDebugOffsets(handle, runtime_start_address, debug_offsets)) { |
| return -1; |
| } |
| if (ensure_debug_offset_compatibility(debug_offsets)) { |
| return -1; |
| } |
| return 0; |
| } |
| |
| static int |
| send_exec_to_proc_handle(proc_handle_t *handle, int tid, const char *debugger_script_path) |
| { |
| uintptr_t runtime_start_address; |
| struct _Py_DebugOffsets debug_offsets; |
| |
| if (read_offsets(handle, &runtime_start_address, &debug_offsets)) { |
| return -1; |
| } |
| |
| uintptr_t interpreter_state_list_head = (uintptr_t)debug_offsets.runtime_state.interpreters_head; |
| |
| uintptr_t interpreter_state_addr; |
| if (0 != read_memory( |
| handle, |
| runtime_start_address + interpreter_state_list_head, |
| sizeof(void*), |
| &interpreter_state_addr)) |
| { |
| return -1; |
| } |
| |
| if (interpreter_state_addr == 0) { |
| PyErr_SetString(PyExc_RuntimeError, "Can't find a running interpreter in the remote process"); |
| return -1; |
| } |
| |
| int is_remote_debugging_enabled = 0; |
| if (0 != read_memory( |
| handle, |
| interpreter_state_addr + debug_offsets.debugger_support.remote_debugging_enabled, |
| sizeof(int), |
| &is_remote_debugging_enabled)) |
| { |
| return -1; |
| } |
| |
| if (is_remote_debugging_enabled != 1) { |
| PyErr_SetString( |
| PyExc_RuntimeError, |
| "Remote debugging is not enabled in the remote process"); |
| return -1; |
| } |
| |
| uintptr_t thread_state_addr; |
| unsigned long this_tid = 0; |
| |
| if (tid != 0) { |
| if (0 != read_memory( |
| handle, |
| interpreter_state_addr + debug_offsets.interpreter_state.threads_head, |
| sizeof(void*), |
| &thread_state_addr)) |
| { |
| return -1; |
| } |
| while (thread_state_addr != 0) { |
| if (0 != read_memory( |
| handle, |
| thread_state_addr + debug_offsets.thread_state.native_thread_id, |
| sizeof(this_tid), |
| &this_tid)) |
| { |
| return -1; |
| } |
| |
| if (this_tid == (unsigned long)tid) { |
| break; |
| } |
| |
| if (0 != read_memory( |
| handle, |
| thread_state_addr + debug_offsets.thread_state.next, |
| sizeof(void*), |
| &thread_state_addr)) |
| { |
| return -1; |
| } |
| } |
| |
| if (thread_state_addr == 0) { |
| PyErr_SetString( |
| PyExc_RuntimeError, |
| "Can't find the specified thread in the remote process"); |
| return -1; |
| } |
| } else { |
| if (0 != read_memory( |
| handle, |
| interpreter_state_addr + debug_offsets.interpreter_state.threads_main, |
| sizeof(void*), |
| &thread_state_addr)) |
| { |
| return -1; |
| } |
| |
| if (thread_state_addr == 0) { |
| PyErr_SetString( |
| PyExc_RuntimeError, |
| "Can't find the main thread in the remote process"); |
| return -1; |
| } |
| } |
| |
| // Ensure our path is not too long |
| if (debug_offsets.debugger_support.debugger_script_path_size <= strlen(debugger_script_path)) { |
| PyErr_SetString(PyExc_ValueError, "Debugger script path is too long"); |
| return -1; |
| } |
| |
| uintptr_t debugger_script_path_addr = (uintptr_t)( |
| thread_state_addr + |
| debug_offsets.debugger_support.remote_debugger_support + |
| debug_offsets.debugger_support.debugger_script_path); |
| if (0 != write_memory( |
| handle, |
| debugger_script_path_addr, |
| strlen(debugger_script_path) + 1, |
| debugger_script_path)) |
| { |
| return -1; |
| } |
| |
| int pending_call = 1; |
| uintptr_t debugger_pending_call_addr = (uintptr_t)( |
| thread_state_addr + |
| debug_offsets.debugger_support.remote_debugger_support + |
| debug_offsets.debugger_support.debugger_pending_call); |
| if (0 != write_memory( |
| handle, |
| debugger_pending_call_addr, |
| sizeof(int), |
| &pending_call)) |
| |
| { |
| return -1; |
| } |
| |
| uintptr_t eval_breaker; |
| if (0 != read_memory( |
| handle, |
| thread_state_addr + debug_offsets.debugger_support.eval_breaker, |
| sizeof(uintptr_t), |
| &eval_breaker)) |
| { |
| return -1; |
| } |
| |
| eval_breaker |= _PY_EVAL_PLEASE_STOP_BIT; |
| |
| if (0 != write_memory( |
| handle, |
| thread_state_addr + (uintptr_t)debug_offsets.debugger_support.eval_breaker, |
| sizeof(uintptr_t), |
| &eval_breaker)) |
| |
| { |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| #endif // defined(Py_REMOTE_DEBUG) && defined(Py_SUPPORTS_REMOTE_DEBUG) |
| |
| int |
| _PySysRemoteDebug_SendExec(int pid, int tid, const char *debugger_script_path) |
| { |
| #if !defined(Py_SUPPORTS_REMOTE_DEBUG) |
| PyErr_SetString(PyExc_RuntimeError, "Remote debugging is not supported on this platform"); |
| return -1; |
| #elif !defined(Py_REMOTE_DEBUG) |
| PyErr_SetString(PyExc_RuntimeError, "Remote debugging support has not been compiled in"); |
| return -1; |
| #else |
| |
| PyThreadState *tstate = _PyThreadState_GET(); |
| const PyConfig *config = _PyInterpreterState_GetConfig(tstate->interp); |
| if (config->remote_debug != 1) { |
| PyErr_SetString(PyExc_RuntimeError, "Remote debugging is not enabled"); |
| return -1; |
| } |
| |
| proc_handle_t handle; |
| if (init_proc_handle(&handle, pid) < 0) { |
| return -1; |
| } |
| |
| int rc = send_exec_to_proc_handle(&handle, tid, debugger_script_path); |
| cleanup_proc_handle(&handle); |
| return rc; |
| #endif |
| } |
| |
